Java 8 的 lambda 表达式

红薯 发布于 2012/06/25 20:24
阅读 49K+
收藏 88

解锁HarmonyOS核心技能,赢取限量周边好礼>>>

Java 8 预计将在 2013 年发布,Java 8 将支持 Lambda 功能,尽管该规范还在不断的变化,但是 Java 8 的开发版已经实现了对 lambda 的支持。

关于 lambda 表达式的定义请看维基百科

该文章将带你熟悉 lambda 语法,以及使用集合 API 中的 lambda 以及相关的语言增强,本文所有的代码都是在 JDK 8 lambda build b39 编译。

功能接口

只包含一个方法的接口被称为功能接口,Lambda 表达式用用于任何功能接口适用的地方。

java.awt.event.ActionListener 就是一个功能接口,因为它只有一个方法:void actionPerformed(ActionEvent). 在 Java 7 中我们会编写如下代码:

button.addActionListener(new ActionListener() { 
    public void actionPerformed(ActionEvent e) { 
        ui.dazzle(e.getModifiers());
    }
});
而 Java 8 中可以简化为:
button.addActionListener(e -> { ui.dazzle(e.getModifiers()); });

编译器知道lambda 表达式必须符合 void actionPerformed(ActionEvent) 方法的定义。看起来 lambda 实体返回 void,实际上它可以推断出参数 e 的类型是 java.awt.event.ActionEvent.

函数集合

Java 8 的类库包含一个新的包 java.util.functions ,这个包中有很多新的功能接口,这些接口可与集合 API 一起使用。

java.util.functions.Predicate

使用谓词 (Predicate) 来筛选集合:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");
List<String> filteredNames = names
        .filter(e -> e.length() >= 4)
        .into(new ArrayList<String>());
for (String name : filteredNames) {
    System.out.println(name);
}
这里我们有两个新方法:
  • Iterable<T> filter(Predicate<? super T>) 用于获取元素满足某个谓词返回 true 的结果
  • <A extends Fillable<? super T>> A into(A) 将用返回的结果填充 ArrayList

java.util.functions.Block

我们可使用一个新的迭代器方法来替换 for 循环 void forEach(Block<? super T>):

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");
names
   .filter(e -> e.length() >= 4)
   .forEach(e -> { System.out.println(e); });
forEach() 方法是 internal iteration 的一个实例:迭代过程在  IterableBlock 内部进行,每次可访问一个元素。

最后的结果就是用更少的代码来处理集合:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");
names
   .mapped(e -> { return e.length(); })
   .asIterable() // returns an Iterable of BiValue elements
                 // an element's key is the person's name, its value is the string length
   .filter(e -> e.getValue() >= 4)
   .sorted((a, b) -> a.getValue() - b.getValue())
   .forEach(e -> { System.out.println(e.getKey() + '\t' + e.getValue()); });
这样做的优点是:
元素在需要的时候才进行计算
如果我们取一个上千个元素的集合的前三条时,其他元素就不会被映射
鼓励使用方法链
我们无需才存储中间结果来构建新的集合
内部迭代过程因此大多数细节
例如,我们可以通过下面代码来并行 map() 操作
writing myCollection.parallel().map(e ‑> e.length()).

方法引用

我们可通过 :: 语法来引用某个方法。方法引用被认为是跟 lambda 表达式一样的,可用于功能接口所适用的地方。

我们可以引用一个静态方法:
executorService.submit(MethodReference::sayHello);

private static void sayHello() {
        System.out.println("hello");
}
或者是一个实例的方法:
Arrays.asList("Alice", "Bob", "Charlie", "Dave").forEach(System.out::println);
我们也可以创建工程方法并将构造器引用赋值给 java.util.functions.Factory:
Factory<Biscuit> biscuitFactory = Biscuit::new;
Biscuit biscuit = biscuitFactory.make();

最后,我们创建一个引用到随意实例的例子:

interface Accessor<BEAN, PROPERTY> {
        PROPERTY access(BEAN bean);
}

public static void main(String[] args) {
        Address address = new Address("29 Acacia Road", "Tunbridge Wells");
        Accessor<Address, String> accessor = Address::getCity;
        System.out.println(accessor.access(address));
}

这里我们无需绑定方法引用到某个实例,我们直接将实例做为功能接口的参数进行传递。

默认方法

直到今天的 Java ,都不可能为一个接口添加方法而不会影响到已有的实现类。而 Java 8 允许你为接口自身指定一个默认的实现:

interface Queue {
        Message read();
        void delete(Message message);
        void deleteAll() default {
                Message message;
                while ((message = read()) != null) {
                        delete(message);
                }
        }
}
子接口可以覆盖默认的方法:
interface BatchQueue extends Queue {
        void setBatchSize(int batchSize);
        void deleteAll() default {
                setBatchSize(100);
                Queue.super.deleteAll();
        }
}
或者子接口也可以通过重新声明一个没有方法体的方法来删除默认的方法:
interface FastQueue extends Queue {
        void deleteAll();
}
这个将强制所有实现了 FastQueue 的类必须实现 deleteAll() 方法。

HotSpot 实现

lambda 不只是可以减少很多代码的编写,其字节码和运行时的实现也比 Java 7 中的匿名类的效率更高。针对每一个 lambda 表达式,编译器都会创建一个对应的形如 lambda$1() 这样的方法。这个过程被称之为 lambda body desugaring. 当遇见一个 lambda 表达式,编译器将会发起一个 invokedynamic 调用,并从目标功能接口中获取返回值。

深入阅读

本文很多内容都基于 Brian Goetz 的文章:State of the Lambda, State of the Lambda: Libraries Edition and Translation of Lambda Expressions. 这些文字详细描述了 lambda 语法、变量捕获、类型接口和编译等内容。

英文原文OSCHINA原创翻译

加载中
1
TX
TX
以后可以少写好多代码了
1
ValueError
ValueError

引用来自“liuex”的答案

引用来自“无知的T”的答案

引用来自“liuex”的答案

引用来自“红薯”的答案

默认方法这个不错哦:)
默认方法,实际上就是把接口变成抽象类了,而类是可以实现多个接口的,然后就间接的允许了多重继承,Java真是越来越复杂了。。。

Mixin 用法是多重继承很好的一个实践,我看默认方法的设计是照着这个方向的。你自己看下它还是和抽象类有很大区别的:

  • 接口不能继承普通类,只能继承接口
  • 接口可以多重继承,一个类也可以实现多个接口,但一个类只能继承一个普通类
这个和 Ruby 的 Mixin 设计一模一样,可以把接口对应到 Ruby 的 module,普通类对应到 Ruby 的 class。

"接口不能继承普通类,只能继承接口"

默认方法,使得接口本身就能带上方法的实现,也就是说子接口继承父接口后,就能继承父接口的默认方法。我觉得不应该纠结于接口、抽象类、类这几个名词,而是看他的实质。从语义功能上来说接口有了默认方法以后,抽象类、接口、类的区别就很模糊了:

接口:方法实现+多重继承+实现多个接口,抽象类:方法实现+单根继承+实现多个接口,类:方法实现+单根继承+实现多个接口。

想必以后对于“这个XX应该设计成接口还是抽象类?”的问题争论的更多了。

此外,多重继承会破坏封装,破坏信息隐藏,暴露继承层次中的一些内部实现,很难说到底是好还是坏。

ps:我不了解Ruby的module/class,Mixin是什么概念也不清楚。请解释一下:1、Mixin是否可以多重继承?2、Mixin是否可以有方法实现?

Mixin 是 Ruby 允许的一种受限的多重继承用法,Mixin 类可以多重继承,可以有方法实现,但是仅限于 Mixin 类以内。多重继承会引起的方法查找规则复杂问题在 Mixin 类里面一般不会出现,因为一般 Mixin 类是设计成供组合的 partial 类,而非完整的职责类。这个说到底,其实是用继承的语法来实现组合。

module Commentable
  def add_comment(content)
    comment = Comment.new()
    comment.content = content
    @comments << comment
  end
end

class NewsArticle < ActiveRecord::Base
  include Commentable
  include Removeable
  include Timestamp
  include Jsonizable

  # omit...
end

我知道不少说法是:这么做和让宿主类实现一堆接口,然后用委托的方式调用一堆实现是等价的。但是等价归等价,Mixin 的写法更清晰是事实。标准库中的 Observer 实现就非常搞笑地把“继承”用在了本应该组合的场合。我认为语言设计中噪音太多、给开发者带来太多不必要的工作量,正是当前 Java 的弊病所在。为什么要写一堆 getter 和 setter 方法而不开放重载属性访问操作符的途径?为什么要写一堆只是调用了一下委托对象的方法,而不开放一种直接声明的写法?语言已经把其他的门关上了,就因为有更麻烦的做法可以“等价”。

0
红薯
红薯
默认方法这个不错哦:)
mj4738
mj4738
这些所谓的新特性,scala已经提供了
dytes
dytes
终于改进了。 默认方法这个好像F#接口里面也有这个功能。
晕dows
晕dows
+1
0
徐建兴
徐建兴
大神级的人物。
0
0
张子游回来了
张子游回来了
看不懂,还是Java6好。
一号男嘉宾
一号男嘉宾
我也卡不懂介个
0
z
zm112358
默认方法,这个原理是怎么实现的呢? 
0
Evo
Evo
lambda没有c#看起来简洁。。
0
all_bright
all_bright

Java: "C#有的我都要有 :-)".

dytes
dytes
@all_bright 虽然没太多更新,但稳定也算一个有点吧,一直跟着微软跑,也挺累的。
all_bright
all_bright
回复 @dytes : Java语言本身已无长处 :-)
dytes
dytes
互相学习长处么,没必要害臊,哈哈!
OSCHINA
登录后可查看更多优质内容
返回顶部
顶部