java8实战读书笔记：初识Stream、流的基本操作（流计算）

本文是博主在学习《java8实战》的一些学习笔记。

从本节开始，将进入到java8 Stream(流)的学习中来。

本文中的部分示例基于如下场景：餐厅点菜，Dish为餐厅中可提供的菜品，Dish的定义如下：

 1public class Dish { 2    /** 菜品名称 */ 3    private final String name; 4    /** 是否是素食 */ 5    private final boolean vegetarian; 6    /** 含卡路里 */ 7    private final int calories; 8    /** 类型 */ 9    private final Type type;1011    public Dish(String name, boolean vegetarian, int calories, Type type) {12        this.name = name;13        this.vegetarian = vegetarian;14        this.calories = calories;15        this.type = type;16    }1718    public enum Type { MEAT, FISH, OTHER }1920    // 省略set get方法21}public class Dish {
 2    /** 菜品名称 */
 3    private final String name;
 4    /** 是否是素食 */
 5    private final boolean vegetarian;
 6    /** 含卡路里 */
 7    private final int calories;
 8    /** 类型 */
 9    private final Type type;
10
11    public Dish(String name, boolean vegetarian, int calories, Type type) {
12        this.name = name;
13        this.vegetarian = vegetarian;
14        this.calories = calories;
15        this.type = type;
16    }
17
18    public enum Type { MEAT, FISH, OTHER }
19
20    // 省略set get方法
21}

菜单的数据如下：

 1List menu = Arrays.asList( 2new Dish("pork", false, 800, Dish.Type.MEAT), 3new Dish("beef", false, 700, Dish.Type.MEAT), 4new Dish("chicken", false, 400, Dish.Type.MEAT), 5new Dish("french fries", true, 530, Dish.Type.OTHER), 6new Dish("rice", true, 350, Dish.Type.OTHER), 7new Dish("season fruit", true, 120, Dish.Type.OTHER), 8new Dish("pizza", true, 550, Dish.Type.OTHER), 9new Dish("prawns", false, 300, Dish.Type.FISH),10new Dish("salmon", false, 450, Dish.Type.FISH) );List menu = Arrays.asList(
 2new Dish("pork", false, 800, Dish.Type.MEAT),
 3new Dish("beef", false, 700, Dish.Type.MEAT),
 4new Dish("chicken", false, 400, Dish.Type.MEAT),
 5new Dish("french fries", true, 530, Dish.Type.OTHER),
 6new Dish("rice", true, 350, Dish.Type.OTHER),
 7new Dish("season fruit", true, 120, Dish.Type.OTHER),
 8new Dish("pizza", true, 550, Dish.Type.OTHER),
 9new Dish("prawns", false, 300, Dish.Type.FISH),
10new Dish("salmon", false, 450, Dish.Type.FISH) );

我们以一个简单的示例来引入流：从菜单列表中，查找出是素食的菜品，并打印其菜品的名称。

在Java8之前，我们通常是这样实现该需求的：

 1List dishNames = new ArrayList<>(); 2for(Dish d menu) { 3    if(d.isVegetarian()) { 4        dishNames.add(d.getName());  5    } 6} 7//输出帅选出来的菜品的名称： 8for(String n : dishNames) { 9    System.out.println(n);10}List<String> dishNames = new ArrayList<>();
 2for(Dish d menu) {
 3    if(d.isVegetarian()) {
 4        dishNames.add(d.getName()); 
 5    }
 6}
 7//输出帅选出来的菜品的名称：
 8for(String n : dishNames) {
 9    System.out.println(n);
10}

那在java8中，我们可以这样写：

1menu.streams() .filter( Dish::isVegetarian).map( Dish::getName) .forEach( a -> System.out.println(a) );menu.streams() .filter( Dish::isVegetarian).map( Dish::getName) .forEach( a -> System.out.println(a) );

其运行输出的结果：

怎么样，神奇吧！！！

在解释上面的代码之前，我们先对流做一个理论上的介绍。

流是什么？

流，就是数据流，是元素序列，在Java8中，流的接口定义在 java.util.stream.Stream包中，并且在Collection(集合)接口中新增一个方法：

1default Stream stream() {2        return StreamSupport.stream(spliterator(), false);3}default Stream stream() {
2        return StreamSupport.stream(spliterator(), false);
3}

流的简短定义：从支持数据处理操作的源生成的元素序列。例如集合、数组都是支持数据操作的数据结构（容器），都可以做为流的创建源，该定义的核心要素如下：

注意：流和迭代器Iterator一样，只能遍历一次，如果要多次遍历，请创建多个流。

接下来我们将重点先介绍流的常用操作方法。

流的常用操作

filter

filter函数的方法声明如下：

1java.util.stream.Stream#filter2Stream filter(Predicate predicate);java.util.stream.Stream#filter
2Stream<T> filter(Predicatesuper T> predicate);

该方法接收一个谓词，返回一个流，即filter方法接收的lambda表达式需要满足 （  T  -> Boolean ）。

示例：从菜单中选出所有是素食的菜品：

1List vegetarianDishs = menu.stream().filter(  Dish::isVegetarian )    // 使用filter过滤流中的菜品。2                                          .collect(toList())；              // 将流转换成List，该方法将在后面介绍。List vegetarianDishs = menu.stream().filter(  Dish::isVegetarian )    // 使用filter过滤流中的菜品。
2                                          .collect(toList())；              // 将流转换成List，该方法将在后面介绍。

温馨提示：流的操作可以分成中间件操作和终端操作。中间操作通常的返回结果还是流，并且在调用终端操作之前，并不会立即调用，等终端方法调用后，中间操作才会真正触发执行，该示例中的collect方法为终端方法。

我们类比一下数据库查询操作，除了基本的筛选动作外，还有去重，分页等功能，那java8的流API能支持这些操作吗？
答案当然是肯定。

distinct

distinct，类似于数据库中的排重函数，就是对结果集去重。
例如有一个数值numArr = [1,5,8,6,5,2,6]，现在要输出该数值中的所有奇数并且不能重复输出，那该如何实现呢？

1Arrays.stream(numArr).filter(  a -> a % 2 == 0 ).distinict().forEach(System.out::println);2 == 0 ).distinict().forEach(System.out::println);

limit

截断流，返回一个i不超过指定元素个数的流。
还是以上例举例，如果要输出的元素是偶数，不能重复输出，并且只输出1个元素，那又该如何实现呢？

1Arrays.stream(numArr).filter(  a -> a % 2 == 0 ).distinict().limit(1).forEach(System.out::println);2 == 0 ).distinict().limit(1).forEach(System.out::println);

skip

跳过指定元素，返回剩余元素的流，与limit互补。

Map

还是类比数据库操作，我们通常可以只选择一个表中的某一列，java8流操作也提供了类似的方法。
例如，我们需要从菜单中提取所有菜品的名称，在java8中我们可以使用如下代码实现：

1版本1：List dishNames = menu.stream().map( (Dish d) -> d.getName() ).collect(Collectors.toList());2版本2：List dishNames = menu.stream().map( d -> d.getName() ).collect(Collectors.toList());3版本3：List dishNames = menu.stream().map(Dish::getName).collect(Collectors.toList());1：List dishNames = menu.stream().map( (Dish d) -> d.getName() ).collect(Collectors.toList());
2版本2：List dishNames = menu.stream().map( d -> d.getName() ).collect(Collectors.toList());
3版本3：List dishNames = menu.stream().map(Dish::getName).collect(Collectors.toList());

文章的后续部分尽量使用最简洁的lambda表达式。

我们来看一下Stream关于map方法的声明：

1 Stream map(Function mapper)2<R> Stream<R> map(Function super T, ? extends R> mapper)
2

接受一个函数Function，其函数声明为：T -> R，接收一个T类型的对象，返回一个R类型的对象。

当然，java为了高效的处理基础数据类型（避免装箱、拆箱带来性能损耗）也定义了如下方法：

1IntStream mapToInt(ToIntFunction mapper)2LongStream mapToLong(ToLongFunction mapper)3DoubleStream mapToDouble(ToDoubleFunction mapper)super T> mapper)
2LongStream mapToLong(ToLongFunctionsuper T> mapper)
3DoubleStream mapToDouble(ToDoubleFunctionsuper T> mapper)

思考题：对于字符数值["Hello","World"] ，输出字符序列，并且去重。
第一次尝试：

1public static void test_flat_map() {2    String[] strArr = new String[] {"hello", "world"};3    List strList = Arrays.asList(strArr);4    strList.stream().map( s -> s.split(""))5                    .distinct().forEach(System.out::println);6}public static void test_flat_map() {
2    String[] strArr = new String[] {"hello", "world"};
3    List strList = Arrays.asList(strArr);
4    strList.stream().map( s -> s.split(""))
5                    .distinct().forEach(System.out::println);
6}

输出结果：

为什么会返回两个String[]元素呢？因为map(s -> s.split()) 此时返回的流为Stream，那我们是不是可以继续对该Steam[String[]],把String[]转换为字符流，其代码如下：

1public static void test_flat_map() {2    String[] strArr = new String[] {"hello", "world"};3    List strList = Arrays.asList(strArr);4    strList.stream().map( s -> s.split(""))5                    .map(Arrays::stream)6                    .distinct().forEach(System.out::println);7}public static void test_flat_map() {
2    String[] strArr = new String[] {"hello", "world"};
3    List strList = Arrays.asList(strArr);
4    strList.stream().map( s -> s.split(""))
5                    .map(Arrays::stream)
6                    .distinct().forEach(System.out::println);
7}

其返回结果：

还是不符合预期，其实原因也很好理解，再次经过map(Arrays:stream)后，返回的结果为Stream，即包含两个元素，每一个元素为一个字符流，可以通过如下代码验证：

 1public static void test_flat_map() { 2    String[] strArr = new String[] {"hello", "world"}; 3    List strList = Arrays.asList(strArr); 4    strList.stream().map( s -> s.split("")) 5                    .map(Arrays::stream) 6                    .forEach(  (Stream s) -> { 7                        System.out.println("\n --start---"); 8                        s.forEach(a -> System.out.print(a + " ")); 9                        System.out.println("\n --end---");10                    } );11}public static void test_flat_map() {
 2    String[] strArr = new String[] {"hello", "world"};
 3    List strList = Arrays.asList(strArr);
 4    strList.stream().map( s -> s.split(""))
 5                    .map(Arrays::stream)
 6                    .forEach(  (Stream s) -> {
 7                        System.out.println("\n --start---");
 8                        s.forEach(a -> System.out.print(a + " "));
 9                        System.out.println("\n --end---");
10                    } );
11}

综合上述分析，之所以不符合预期，主要是原数组中的两个字符，经过map后返回的是两个独立的流，那有什么方法将这两个流合并成一个流，然后再进行disinic去重呢？

答案当然是可以的，flatMap方法闪亮登场：先看代码和显示结果：

1public static void test_flat_map() {2    String[] strArr = new String[] {"hello", "world"};3    List strList = Arrays.asList(strArr);4    strList.stream().map( s -> s.split(""))5                    .flatMap(Arrays::stream)6                    .distinct().forEach( a -> System.out.print(a +" "));7}public static void test_flat_map() {
2    String[] strArr = new String[] {"hello", "world"};
3    List strList = Arrays.asList(strArr);
4    strList.stream().map( s -> s.split(""))
5                    .flatMap(Arrays::stream)
6                    .distinct().forEach( a -> System.out.print(a +" "));
7}

其输出结果：

符合预期。一言以蔽之，flatMap可以把两个流合并成一个流进行操作。

查找和匹配

Stream API提供了allMatch、anyMatch、noneMatch、findFirst和findAny方法来实现对流中数据的匹配与查找。

allMatch

我们先看一下该方法的声明：

1boolean allMatch(Predicate predicate);boolean allMatch(Predicatesuper T> predicate);

接收一个谓词函数(T->boolean)，返回一个boolean值，是一个终端操作，用于判断流中的所有元素是否与Predicate相匹配，只要其中一个元素不复合，该表达式将返回false。
示例如下：例如存在这样一个List a,其中元素为 1,2,4,6,8。判断流中的元素是否都是偶数。

1boolean result = a.stream().allMatch(  a -> a % 2 == 0 )；  // 将返回false。boolean result = a.stream().allMatch(  a -> a % 2 == 0 )；  // 将返回false。

anyMatch

该方法的函数声明如下：

1boolean anyMatch(Predicate predicate)2boolean anyMatch(Predicatesuper T> predicate)
2

同样接收一个谓词Predicate( T -> boolean )，表示只要流中的元素至少一个匹配谓词，即返回真。

示例如下：例如存在这样一个List a,其中元素为 1,2,4,6,8。判断流中的元素是否包含偶数。

1boolean result = a.stream().anyMatch(  a -> a % 2 == 0 )；  // 将返回true。boolean result = a.stream().anyMatch(  a -> a % 2 == 0 )；  // 将返回true。

noneMatch

该方法的函数声明如下：

1boolean noneMatch(Predicate predicate);boolean noneMatch(Predicatesuper T> predicate);

同样接收一个谓词Predicate( T -> boolean )，表示只要流中的元素全部不匹配谓词表达式，则返回true。

示例如下：例如存在这样一个List a,其中元素为 2,4,6,8。判断流中的所有元素都不式奇数。

1boolean result = a.stream().noneMatch(  a -> a % 2 == 1 )；  // 将返回true。boolean result = a.stream().noneMatch(  a -> a % 2 == 1 )；  // 将返回true。

findFirst

查找流中的一个元素，其函数声明如下：

1Optional findFirst();Optional findFirst();

返回流中的一个元素。其返回值为Optional，这是jdk8中引入的一个类，俗称值容器类，其主要左右是用来避免值空指针，一种更加优雅的方式来处理null。该类的具体使用将在下一篇详细介绍。

1public static void test_find_first(List menu) {2    Optional dish = menu.stream().findFirst();3    // 这个方法表示，Optional中包含Dish对象，则执行里面的代码，否则什么事不干，是不是比判断是否为null更友好4    dish.ifPresent(a -> System.out.println(a.getName()));  5}public static void test_find_first(List menu) {
2    Optional dish = menu.stream().findFirst();
3    // 这个方法表示，Optional中包含Dish对象，则执行里面的代码，否则什么事不干，是不是比判断是否为null更友好
4    dish.ifPresent(a -> System.out.println(a.getName()));  
5}

findAny

返回流中任意一个元素，其函数声明如下：

1Optional findAny();Optional findAny();

reduce

reduce归约，看过大数据的人用过会非常敏感，目前的java8的流操作是不是有点map-reduce的味道，归约，就是对流中所有的元素进行统计分析，归约成一个数值。
首先我们看一下reduce的函数说明：

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

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

可以理解为没有初始值的归约，如果流为空，则会返回空，故其返回值使用了Optional类来优雅处理null值。

1 U reduce(U identity, BiFunction accumulator, BinaryOperator combiner);<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

首先，最后的返回值类型为U。

温馨提示：对流API的学习，一个最最重点的就是要掌握这些函数式编程接口，然后掌握如何使用Lambda表达式进行行为参数化（lambda表达当成参数传入到函数中）。

接下来我们举例来展示如何使用reduce。
示例1：对集合中的元素求和

1List goodsNumber = Arrays.asList(   3, 5, 8, 4, 2, 13 );2java7之前的示例：3int sum = 0;4for(Integer i : goodsNumber) {5sum += i;//  sum = sum + i;6}7System.out.println("sum:" + sum);3, 5, 8, 4, 2, 13 );
2java7之前的示例：
3int sum = 0;
4for(Integer i : goodsNumber) {
5sum += i;//  sum = sum + i;
6}
7System.out.println("sum:" + sum);

求和运算符： c = a + b，也就是接受2个参数，返回一个值，并且这三个值的类型一致。

故我们可以使用T reduce(T identity, BinaryOperator< T> accumulator)来实现我们的需求：

1public static void test_reduce() {2    List goodsNumber = Arrays.asList(   3, 5, 8, 4, 2, 13 );3    int sum = goodsNumber.stream().reduce(0, (a,b) -> a + b);4    //这里也可以写成这样：5    // int sum = goodsNumber.stream().reduce(0, Integer::sum);6    System.out.println(sum);7}public static void test_reduce() {
2    List goodsNumber = Arrays.asList(   3, 5, 8, 4, 2, 13 );
3    int sum = goodsNumber.stream().reduce(0, (a,b) -> a + b);
4    //这里也可以写成这样：
5    // int sum = goodsNumber.stream().reduce(0, Integer::sum);
6    System.out.println(sum);
7}

不知大家是否只读(a,b)这两个参数的来源，其实第一个参数为初始值T identity，第二个参数为流中的元素。

那三个参数的reduce函数主要用在什么场景下呢？接下来还是用求和的例子来展示其使用场景。在java多线程编程模型中，引入了fork-join框架，就是对一个大的任务进行先拆解，用多线程分别并行执行，最终再两两进行合并，得出最终的结果。reduce函数的第三个函数，就是组合这个动作，下面给出并行执行的流式处理示例代码如下：

 1 public static void test_reduce_combiner() { 2 3    /** 初始化待操作的流 */ 4    List nums = new ArrayList<>(); 5    int s = 0; 6    for(int i = 0; i < 200; i ++) { 7        nums.add(i); 8        s = s + i; 9    }1011    // 对流进行归并，求和,这里使用了流的并行执行版本 parallelStream，内部使用Fork-Join框架多线程并行执行，12    // 关于流的内部高级特性，后续再进行深入，目前先以掌握其用法为主。13    int sum2 = nums.parallelStream().reduce(0,Integer::sum, Integer::sum);14    System.out.println("和为：" + sum2);1516    // 下面给出上述版本的debug版本。1718    // 累积器执行的次数19    AtomicInteger accumulatorCount = new AtomicInteger(0);2021    // 组合器执行的次数（其实就是内部并行度）22    AtomicInteger combinerCount = new AtomicInteger(0);2324    int sum = nums.parallelStream().reduce(0,(a,b) -> {25                accumulatorCount.incrementAndGet();26                return a + b;27           }, (c,d) -> {28                combinerCount.incrementAndGet();29                return  c+d;30        });3132    System.out.println("accumulatorCount:" + accumulatorCount.get());33    System.out.println("combinerCountCount:" + combinerCount.get());34}static void test_reduce_combiner() {
 2
 3    /** 初始化待操作的流 */
 4    List nums = new ArrayList<>();
 5    int s = 0;
 6    for(int i = 0; i < 200; i ++) {
 7        nums.add(i);
 8        s = s + i;
 9    }
10
11    // 对流进行归并，求和,这里使用了流的并行执行版本 parallelStream，内部使用Fork-Join框架多线程并行执行，
12    // 关于流的内部高级特性，后续再进行深入，目前先以掌握其用法为主。
13    int sum2 = nums.parallelStream().reduce(0,Integer::sum, Integer::sum);
14    System.out.println("和为：" + sum2);
15
16    // 下面给出上述版本的debug版本。
17
18    // 累积器执行的次数
19    AtomicInteger accumulatorCount = new AtomicInteger(0);
20
21    // 组合器执行的次数（其实就是内部并行度）
22    AtomicInteger combinerCount = new AtomicInteger(0);
23
24    int sum = nums.parallelStream().reduce(0,(a,b) -> {
25                accumulatorCount.incrementAndGet();
26                return a + b;
27           }, (c,d) -> {
28                combinerCount.incrementAndGet();
29                return  c+d;
30        });
31
32    System.out.println("accumulatorCount:" + accumulatorCount.get());
33    System.out.println("combinerCountCount:" + combinerCount.get());
34}

从结果上可以看出，执行了100次累积动作，但只进行了15次合并。

流的基本操作就介绍到这里，在此总结一下，目前接触到的流操作：

1、filter

2、distinct

3、skip

4、limit

5、map

6、flatMap

7、sorted

8、anyMatch

9、allMatch

10、 noneMatch

11、findAny

12、findFirst

13、forEach

14、collect

15、reduce

16、count

由于篇幅的原因，流的基本计算就介绍到这里了.

推荐阅读

八个开源的 Spring Boot 学习资源，你值得拥有

Spring Boot MyBatis 动态数据源切换、多数据源，读写分离

JAVA中令人眼花撩乱的数字魔法

一次非常有意思的SQL优化经历:从30248.271s到0.001s