Java8中的lambda表达式

2014年3月18日,Oracle终于发布Java8正式版。在新的版本里面加入了很多特性, 总共增加了55个新特性,其中最最吸引人的就是Lambdas表达式和Stream函数式编程,本文详细讲解这两个特性。

其他特性比如日期API,泛型,反射,注解,集合框架,并发,Nashorn引擎等等这里暂时就不详细介绍了。 具体可以参考:http://openjdk.java.net/projects/jdk8/features

昨天参加了Oracle的Java8宣讲活动,有幸目睹了Simon Ritter的风采,写个总结来分享下。

Java并发编程演变:

版本 发布年份 并发技术
1.4 2002 java.lang.Thread
5 2004 java.util.concurrent(jsr166)
6 2006 Phasers, etc(jsr166)
7 2011 Fork/Join Framework(jsr166y)
8 2014 Project Lambda

先来一个小例子见识下Java8的威力!

传统的外部迭代处理代码

1
2
3
4
5
6
7
8
9
List<Student> students = ...
double highestScore = 0.0;
for (Student s : students) {
if (s.gradYear == 2011) {
if (s.score > highestScore) {
highestScore = s.score;
}
}
}

传统的外部迭代主要问题:

  • 程序员自己控制迭代,容易出问题!
  • 顺序执行:迭代从开始到结束一个一个的顺序迭代元素
  • 线程不安全,由于业务逻辑依靠可修改变量,容易产生竞态问题

基于Inner Classes的内部迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
List<Student> students = ...
double highestScore = students.
filter(new Predicate<Student>() {
public boolean op(Student s) {
return s.getGradYear() == 2011;
}
}).
map(new Mapper<Student,Double>() {
public Double extract(Student s) {
return s.getScore();
}
}).
max();

这种迭代形式已经具备了函数式特征。

优点:

  • 迭代,过滤和累加器由核心库完成
  • 遍历操作可以并行执行
  • 遍历可以延迟执行
  • 线程安全 – 因为客户端的逻辑是无状态的

缺点:

代码写的有点难看

基于Lambdas的内部迭代

1
2
3
4
5
SomeList<Student> students = ...
double highestScore = students.
filter(Student s -> s.getGradYear() == 2011).
map(Student s -> s.getScore()).
max();

这种写法可以算是完美了:^_^

  • 可读性很好
  • 更加抽象化
  • 简单化后,自然就不容易出现bug了
  • 不再依赖可变变量
  • 很容易实现并行化

进入正题 ~~

Lambda篇

Lambda表达式简单来讲就是匿名函数

  • 就像一个方法一样,它又参数列表,一个返回类型,抛出的异常集和一个执行体
  • 但是跟方法不同的是,它不跟任何Class关联。

也就是说,现在我们在Java的方法调用中不仅仅可以传值,还可以传动作(也就是函数),这个有点类似于C语言的函数指针的概念了。

Lambda表达式的类型:

在Java中,到处都可以看到只有一个方法的接口,这种接口现在定义为函数式接口, 而Lambda表达式类型就是函数式接口,也就是只有一个方法的接口。

几个函数式接口的例子:

1
2
3
4
5
interface Comparator<T> { boolean compare(T x, T y); }
interface FileFilter { boolean accept(File x); }
interface Runnable { void run(); }
interface ActionListener { void actionPerformed(…); }
interface Callable<T> { T call(); }

局部变量捕获

Lambda表达式可以引用上下文中的final等效局部变量。

final等效指的是变量的用法是final的,而不必声明为final,比如变量只赋值一次,那么它就是final等效的。

1
2
3
void expire(File root, long before) {
root.listFiles(File p -> p.lastModified() <= before);
}

this关键字

Lambda表达式中的this指的是包含这个Lambda的外部对象,而不是Lambda本身。 永远记住,Lambda表达式类型其实就是一个函数式接口。

1
2
3
4
5
6
7
8
class SessionManager {
long before = ...;
void expire(File root) {
// refers to 'this.before', just like outside the lambda
root.listFiles(File p -> checkExpiry(p.lastModified(), this.before));
}
boolean checkExpiry(long time, long expiry) { ... }
}

类型推断

很多情况下,编译器都可以根据目标函数式接口的方法签名来推断参数类型。 在Collections接口中有个sort接口:

1
static T void sort(List<T> l, Comparator<? super T> c);

正常来讲,应该这么写:

1
2
List<String> list = getList();
Collections.sort(list, (String x, String y) -> x.length() - y.length());

借助类型推断,可以简化为:

1
2
List<String> list = getList();
Collections.sort(list, (x, y) -> x.length() - y.length());

方法引用

方法引用可以让我们将一个方法作为一个Lambda表达式重复利用。

比如,java.io.FileFilter作为一个函数式接口,仅有一个方法:

1
boolean accept(File pathname);

正常的Lambda表达式用法:

1
FileFilter x = File f -> f.canRead();

通过方法引用,可以简化为:

1
FileFilter x = File::canRead;

方法引用语法格式有以下三种:

1
2
3
objectName::instanceMethod
ClassName::staticMethod
ClassName::instanceMethod

前两种方式类似,等同于把lambda表达式的参数直接当成instanceMethod|staticMethod的参数来调用。

比如 System.out::println 等同于 x->System.out.println(x); Math::max等同于(x, y)->Math.max(x,y)

最后一种方式,等同于把lambda表达式的第一个参数当成instanceMethod的目标对象, 其他剩余参数当成该方法的参数。比如String::toLowerCase等同于x->x.toLowerCase()

构造器引用

构造器引用语法如下:ClassName::new,把lambda表达式的参数当成ClassName构造器的参数 。 例如BigDecimal::new等同于x->new BigDecimal(x)

和方法引用类似,构造器引用示例:

正常的Lambda表达式的构造器示例:

1
Factory<List<String>> f = () -> return new ArrayList<String>();

通过构造器引用,可以简化为:

1
Factory<List<String>> f = ArrayList<String>::new;

接口扩展

在Java中,接口是不能随便新增方法的,因为接口中一旦增加方法,那么所以实现类都必须重写。 可以在Interface中使用default关键字来增加一个新的接口方法,并提供一个默认实现。 接口的实现类可以不用管,也可以覆盖这个方法。

1
2
3
4
5
interface Collection<E> {
default Stream<E> stream() {
return StreamSupport.stream(spliterator());
}
}

还可以使用@FunctionalInterface这个注解来注解函数式接口,如果接口中多于一个抽象方法,编译器肯定报错。

更甚至,在Java8中,在接口中也可以增加静态方法了。

Stream篇

定义

许多的业务逻辑都需要聚集操作,比如按地区分类获取最优价值产品,按币种分类获取交易量。 之前版本的Java都是通过外部循环来完成这些操作,前面也说过了这种做法的很多弊端。

Java8给出完美解决方案:Lambda表达式+Stream API

Java中对Stream的定义:

1
A sequence of elements supporting sequential and parallel aggregate operations.

我们来解读一下上面的那句话:

1
2
- Stream是元素的集合,这点让Stream看起来用些类似Iterator;
– 可以支持顺序和并行的对原Stream进行汇聚的操作;

大家可以把Stream当成一个高级版本的Iterator。原始版本的Iterator, 用户只能一个一个的遍历元素并对其执行某些操作;高级版本的Stream, 用户只要给出需要对其包含的元素执行什么操作, 比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等, 具体这些操作如何应用到每个元素上,就给Stream就好了!(这个秘籍,一般人我不告诉他:)) 大家看完这些可能对Stream还没有一个直观的认识,莫急,容我慢慢道来!

Stream管道

Stream管道包含三部分,缺一不可:

  1. stream源
  • 零个或多个中间操作
  • 一个终止操作,产生一个结果或者一个副作用
1
2
3
4
int sum = transactions.stream().
filter(t -> t.getBuyer().getCity().equals(“London”)).
mapToInt(Transaction::getPrice).
sum();

transactions.stream() -> stream源

filter/mapToInt -> 中间操作

sum() -> 产生结果

剖析Stream通用语法,再来看一个例子:

1
2
3
//Lists是Guava中的一个工具类
List<Integer> nums = Lists.newArrayList(1,null,3,4,null,6);
nums.stream().filter(num -> num != null).count();

图片就是对于Stream例子的一个解析,可以很清楚的看见:原本一条语句被三种颜色的框分割成了三个部分。 红色框中的语句是一个Stream的生命开始的地方,负责创建一个Stream实例; 绿色框中的语句是赋予Stream灵魂的地方,把一个Stream转换成另外一个Stream, 红框的语句生成的是一个包含所有nums变量的Stream,进过绿框的filter方法以后, 重新生成了一个过滤掉原nums列表所有null以后的Stream; 蓝色框中的语句是丰收的地方,把Stream的里面包含的内容按照某种算法来汇聚成一个值, 例子中是获取Stream中包含的元素个数。

使用Stream的基本步骤

  1. 创建Stream;
  2. 转换Stream,每次转换原有Stream对象不改变,返回一个新的Stream对象(可以有多次转换);
  3. 对Stream进行聚合(Reduce)操作,获取想要的结果;

stream源

有很多方式可以产生stream源:

1. 从集合和数组产生:

1
2
3
Collection.stream()  //接口default方法
Collection.parallelStream() //接口default方法
Arrays.stream(T array) or Stream.of() // 接口default方法或者是静态方法

2. 静态工厂方法:

1
2
IntStream.range()
Files.walk()

3. 使用Stream静态方法来创建Stream源

1) of方法:有两个overload方法,一个接受变长参数,一个接口单一值

1
2
Stream<Integer> integerStream = Stream.of(1, 2, 3, 5);
Stream<String> stringStream = Stream.of("taobao");

2) generator方法:生成一个无限长度的Stream, 其元素的生成是通过给定的Supplier(这个接口可以看成一个对象的工厂,每次调用返回一个给定类型的对象)

1
2
3
4
5
6
7
8
Stream.generate(new Supplier<Double>() {
@Override
public Double get() {
return Math.random();
}
});
Stream.generate(() -> Math.random());
Stream.generate(Math::random);

三条语句的作用都是一样的,只是使用了lambda表达式和方法引用的语法来简化代码。 每条语句其实都是生成一个无限长度的Stream,其中值是随机的。 这个无限长度Stream是懒加载,一般这种无限长度的Stream都会配合Stream的limit()方法来用。

4. iterate方法:也是生成无限长度的Stream

和generator不同的是,其元素的生成是重复对给定的种子值(seed)调用用户指定函数来生成的。 其中包含的元素可以认为是:seed,f(seed),f(f(seed))无限循环

1
Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);

这段代码就是先获取一个无限长度的正整数集合的Stream,然后取出前10个打印。千万记住使用limit方法,不然会无限打印下去。

转换Stream

转换Stream其实就是把一个Stream通过某些行为转换成一个新的Stream。Stream接口中定义了几个常用的转换方法,下面我们挑选几个常用的转换方法来解释。

  1. distinct: 对于Stream中包含的元素进行去重操作(去重逻辑依赖元素的equals方法),新生成的Stream中没有重复的元素;
  2. filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作,新生成的Stream只包含符合条件的元素;
  3. map: 对于Stream中包含的元素使用给定的转换函数进行转换操作,新生成的Stream只包含转换生成的元素。 这个方法有三个对于原始类型的变种方法,分别是:mapToInt,mapToLong和mapToDouble。 这三个方法也比较好理解,比如mapToInt就是把原始Stream转换成一个新的Stream, 这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法,可以免除自动装箱/拆箱的额外消耗;
  4. flatMap:和map类似,不同的是其每个元素转换得到的是Stream对象,会把子Stream中的元素压缩到父集合中;
  5. peek: 生成一个包含原Stream的所有元素的新Stream,同时会提供一个消费函数(Consumer实例),新Stream每个元素被消费的时候都会执行给定的消费函数;
  6. limit: 对一个Stream进行截断操作,获取其前N个元素,如果原Stream中包含的元素个数小于N,那就获取其所有的元素;
  7. skip: 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream,如果原Stream中包含的元素个数小于N,那么返回空Stream;

性能问题

有些细心的同学可能会有这样的疑问:在对于一个Stream进行多次转换操作,每次都对Stream的每个元素进行转换, 而且是执行多次,这样时间复杂度就是一个for循环里把所有操作都做掉的N(转换的次数)倍啊。其实不是这样的, 转换操作都是lazy的,多个转换操作只会在汇聚操作的时候融合起来,一次循环完成。我们可以这样简单的理解, Stream里有个操作函数的集合,每次转换操作就是把转换函数放入这个集合中, 在汇聚操作的时候循环Stream对应的集合,然后对每个元素执行所有的函数。

聚集(Reduce)Stream

可变汇聚

可变汇聚对应的只有一个方法:collect,正如其名字显示的,它可以把Stream中的要有元素收集到一个结果容器中(比如Collection)。

通用的collect方法的定义(还有其他override方法):

1
2
3
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);

先来看看这三个参数的含义:Supplier supplier是一个工厂函数,用来生成一个新的容器; BiConsumer accumulator也是一个函数,用来把Stream中的元素添加到结果容器中; BiConsumer combiner还是一个函数,用来把中间状态的多个结果容器合并成为一个(并发的时候会用到)

还有好消息,Java8还给我们提供了Collector的工具类–[Collectors]

1
2
List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null).
collect(Collectors.toList());

其他汇聚

reduce方法:reduce方法非常的通用,后面介绍的count,sum等都可以使用其实现。 reduce方法有三个override的方法,本文介绍两个最常用的, 先来看reduce方法的第一种形式,其方法定义如下:

1
Optional<T> reduce(BinaryOperator<T> accumulator);

接受一个BinaryOperator类型的参数,在使用的时候我们可以用lambda表达式来。

1
2
List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println("ints sum is:" + ints.stream().reduce((sum, item) -> sum + item).get());

可以看到reduce方法接受一个函数,这个函数有两个参数,第一个参数是上次函数执行的返回值(也称为中间结果), 第二个参数是stream中的元素,这个函数把这两个值相加,得到的和会被赋值给下次执行这个函数的第一个参数。

reduce方法还有一个很常用的变种:

1
T reduce(T identity, BinaryOperator<T> accumulator);

这个定义了初值,不是默认的第一个位初值。

其他参数:

  • allMatch:是不是Stream中的所有元素都满足给定的匹配条件
  • anyMatch:Stream中是否存在任何一个元素满足匹配条件
  • findFirst: 返回Stream中的第一个元素,如果Stream为空,返回空Optional
  • noneMatch:是不是Stream中的所有元素都不满足给定的匹配条件
  • max和min:使用给定的比较器(Operator),返回Stream中的最大|最小值

其他Tips:

Optional防止空指针异常,考虑一个常见的嵌套调用:

1
String version = computer.getSoundcard().getUSB().getVersion();

在之前的Java中,我们对于空指针需要这么做:

1
2
3
4
5
6
7
8
9
10
String version = "UNKNOWN";
if(computer != null){
Soundcard soundcard = computer.getSoundcard();
if(soundcard != null){
USB usb = soundcard.getUSB();
if(usb != null){
version = usb.getVersion();
}
}
}

很显然,这个种做法太挫了! Groovy语言里面有个?.的语法可以非常优雅的解决这个问题:

1
String version = computer?.getSoundcard()?.getUSB()?.getVersion() ?: "UNKNOWN";

当然了,Java8不能示弱啊,所以就有了Optional:

1
2
3
4
5
Optional computer = Optional.ofNullable(computer);
String name = computer.map(Computer::getSoundcard)
.map(Soundcard::getUSB)
.map(USB::getVersion)
.orElse("UNKNOWN");

关于Opational的更多信息,请参考[Oracle官网] (http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html)

结束语

  1. Java需要lambda表达式和Stream API,充分发挥多核并行的优势,大大提高核心库的运行速度。
  2. 通过default关键字扩展接口来进行接口演变,同时保持向后兼容。
  3. 通过lambda表达式,大大简化了集合类的操作
  4. Java8同时在语言、虚拟机、核心库方面做了大幅度的改进和优化,使得编程更简单,更快速。