`

Lambdas & Streams in Java8

    博客分类:
  • Java
阅读更多

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的威力!

一,传统的外部迭代处理代码:

        List<Student> students = ...
        double highestScore = 0.0;
        for (Student s : students) {
            if (s.gradYear == 2011) {
                if (s.score > highestScore) {
                    highestScore = s.score;
                }
            }
        }

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

• 程序员自己控制迭代,容易出问题!

• 顺序执行:迭代从开始到结束一个一个的顺序迭代元素

• 线程不安全,由于业务逻辑依靠可修改变量,容易产生竞态问题

 

二,基于Inner Classes的内部迭代:

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的内部迭代:

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表达式类型就是函数式接口,也就是只有一个方法的接口。

几个函数式接口的例子:

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等效的。

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

 

this关键字:

Lambda表达式中的this指的是包含这个Lambda的外部对象,而不是Lambda本身。

永远记住,Lambda表达式类型其实就是一个函数式接口。

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接口:

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

 正常来讲,应该这么写:

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

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

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

 

方法引用:

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

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

boolean accept(File pathname);

 正常的Lambda表达式用法:

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

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

FileFilter x = File::canRead;

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

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表达式的构造器示例:

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

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

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

 

接口扩展:

在Java中,接口是不能随便新增方法的,因为接口中一旦增加方法,那么所以实现类都必须重写。

可以在Interface中使用default关键字来增加一个新的接口方法,并提供一个默认实现。接口的实现类可以不用管,也可以覆盖这个方法。

interface Collection<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator());
    }
}

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

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

 

Stream篇

许多的业务逻辑都需要聚集操作,比如按地区分类获取最优价值产品,按币种分类获取交易量。

之前版本的Java都是通过外部循环来完成这些操作,前面也说过了这种做法的很多弊端。

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

Java中对Stream的定义:

Oracle 写道
A sequence of elements supporting sequential and parallel aggregate operations.

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

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

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

 

先解释下Stream管道:

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

1. stream源

2. 零个或多个中间操作

3. 一个终止操作,产生一个结果或者一个副作用

int sum = transactions.stream().
        filter(t -> t.getBuyer().getCity().equals(“London”)).
        mapToInt(Transaction::getPrice).
        sum();

transactions.stream()   ->  stream源

filter/mapToInt      -> 中间操作

sum()             -> 产生结果

 

剖析Stream通用语法

再来看一个例子:

//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的基本步骤:

> 创建Stream;

> 转换Stream,每次转换原有Stream对象不改变,返回一个新的Stream对象(**可以有多次转换**);

> 对Stream进行聚合(Reduce)操作,获取想要的结果;

 

stream源

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

1. 从集合和数组产生:

– Collection.stream()  //接口default方法
– Collection.parallelStream()  //接口default方法
– Arrays.stream(T array) or Stream.of()  // 接口default方法或者是静态方法
 2. 静态工厂方法:
– IntStream.range()
– Files.walk()

 

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

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

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

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

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()方法来用。

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

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方法):

<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]

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

 

其他汇聚

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

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

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

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方法还有一个很常用的变种:

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

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

其他的;

– allMatch:是不是Stream中的所有元素都满足给定的匹配条件

– anyMatch:Stream中是否存在任何一个元素满足匹配条件

– findFirst: 返回Stream中的第一个元素,如果Stream为空,返回空Optional

– noneMatch:是不是Stream中的所有元素都不满足给定的匹配条件

– max和min:使用给定的比较器(Operator),返回Stream中的最大|最小值

 

其他Tips: 

Optional<T>防止空指针异常

考虑一个常见的嵌套调用:

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

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

String version = "UNKNOWN";
if(computer != null){
    Soundcard soundcard = computer.getSoundcard();
    if(soundcard != null){
        USB usb = soundcard.getUSB();
        if(usb != null){
            version = usb.getVersion();
        }
    }
}

 很显然,这个种做法太挫了!

Groovy语言里面有个?.的语法可以非常优雅的解决这个问题:

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

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

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同时在语言、虚拟机、核心库方面做了大幅度的改进和优化,使得编程更简单,更快速。

 

本人博客已搬家,新地址为:http://www.pycoding.com/

分享到:
评论

相关推荐

    高清彩版 Java 8 in Action Lambdas, Streams and Functional-style Programming

    ### 高清彩版 Java 8 in Action:Lambdas, Streams 和 Functional-style Programming #### 知识点一:Java 8 的 Lambda 表达式 **Lambda 表达式**是 Java 8 引入的一项重要特性,它使得 Java 开发者能够以一种更加...

    Java Lambdas and Parallel Streams

    This compact book introduces the concepts of Java Lambdas and parallel Streams in a concise form. It begins by introducing new supporting features such as functional interfaces, default methods and ...

    Mastering Lambdas Java Programming in a Multicore World

    he Definitive Guide to Lambda Expressions Mastering Lambdas: Java Programming in a Multicore World describes how the lambda-related features of Java SE 8 will enable Java to meet the challenges of ...

    Mastering Lambdas- Java Programming in a Multicore World

    Lambda expressions were introduced in Java 8 as a significant feature to enhance functional programming capabilities within the Java ecosystem. These expressions allow developers to treat functions as...

    Java in easy steps Covers Java 9 6th Edition

    Java是一种广泛使用的面向对象编程语言,它从Java 8版本开始引入了Lambda表达式和流(Streams),从而增强了Java的函数式编程特性。《Java in easy steps》涵盖了Java 9,并特别针对Java 8的新特性进行了详细讲解。...

    java8stream源码-java8InAction:java8InAction

    java8流源码Java8InAction 该存储库包含 Java 8 实战:Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书:或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章:Java 8:...

    Modern Java Recipes

    Modern Java Recipes: Simple Solutions to Difficult Problems in Java 8 and 9 by Ken Kousen English | 11 Aug. 2017 | ISBN: 149197317X | ASIN: B074R6B13N | 322 Pages | AZW3 | 1.35 MB The introduction of...

    Java 9 for Programmers (Deitel Developer Series) 完整高清azw3版

    level language, this book applies the Deitel signature live-code approach to teaching programming and explores the Java® 9 language and APIs in depth. The book presents concepts in fully tested ...

    Modern Java Recipes(O'Reilly,2017)

    The introduction of functional programming concepts in Java SE 8 was a drastic change for this venerable object-oriented language. Lambda expressions, method references, and streams fundamentally ...

    modern java recipes(英文高清版-带书签)

    The introduction of functional programming concepts in Java SE 8 was a drastic change for this venerable object-oriented language. Lambda expressions, method references, and streams fundamentally ...

    Java SE 8 for the Really Impatient

    Eagerly anticipated by millions of programmers, Java SE 8 is the most important Java update in many years. The addition of lambda expressions (closures) and streams represents the biggest change to ...

    java8stream源码-java8_in_action:“java8inaction”研究的示例代码

    java8流源码Java8InAction 该存储库包含 Java 8 实战:Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书:或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章:Java 8:...

    java8stream源码-Java8InAction:Java8上的示例代码和项目

    java8流源码Java8InAction 该存储库包含 Java 8 实战:Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书:或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章:Java 8:...

    java8stream源码-Java8InAction:Java8InAction

    java8流源码Java8InAction 该存储库包含 Java 8 实战:Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书:或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章:Java 8:...

Global site tag (gtag.js) - Google Analytics