1024问

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

Vanessa ·
更新时间:2024-11-10
· 673 次阅读 


本文是博主在学习《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 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( Dis
h::getName) .forEach( a -> System.out.println(a) );menu.streams() .filter( Dish::isVegetarian).map( Dish::getName) .forEach( a -> System.out.println(a) );
其运行输出的结果：
640?wx_fmt=png

怎么样，神奇吧！！！
在解释上面的代码之前，我们先对流做一个理论上的介绍。
流是什么？
流，就是数据流，是元素序列，在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 filter(Predicate 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 Stream map(Function 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(ToLongFunction mapper)
3DoubleStream mapToDouble(ToDoubleFunction 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}
输出结果：
640?wx_fmt=png

为什么会返回两个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}
其返回结果：
640?wx_fmt=png

还是
符合预期，其实原因也很好理解，再次经过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}
其输出结果：
640?wx_fmt=png

符合预期。一言以蔽之，flatMap可以把两个流合并成一个流进行操作。查找和匹配
Stream API提供了allMatch、anyMatch、noneMatch、findFirst和findAny方法来实现对流中数据的匹配与查找。
allMatch
我们先看一下该方法的声明：
1boolean allMatch(Predicate predicate);boolean allMatch(Predicate 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(Predicate 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(Predicate 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 accumulator)
1Optional reduce(BinaryOperator accumulator); reduce(BinaryOperator accumulator);
可以理解为没有初始值的归约，如果流为空，则会返回空，故其返回值使用了Optional类来优雅处理null值。
1 U reduce(U identity, BiFunction accumulator, BinaryOperator combiner); U reduce(U identity, BiFunction accumulator, BinaryOperator 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 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  {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次合并。<
/p>
流的基本操作就介绍到这里，在此总结一下，目前接触到的流操作：
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
640?wx_fmt=jpeg



作者：JAVA葵花宝典
                    

 

                


                            stream
                            java8
                            实战
                            JAVA
                            读书
1024 个赞
编辑 举报
需要 登录 后方可回复, 如果你还没有账号请 注册新账号
相关文章
Bootstrap4 颜色
Tallulah 2021-02-10
862
CSS中单位px与em的区别(推荐)
Miki 2020-07-14
552
PHP析构函数destruct与垃圾回收机制的讲解
Ebony 2021-02-05
984
Nginx反代Mogilefs分布式储存示例详解
Penelope 2021-08-02
525
使用log_format为Nginx服务器设置更详细的日志格式方法
Akili 2020-10-05
894
Java状态设计模式实现对象状态转换的优雅方式
Pandora 2023-07-12
895
Java实现自定义语言和表达式解析的解释器模式
Tani 2023-07-12
1302
Java享元设计模式优化对象创建提高性能和效率
Tanisha 2023-07-12
1798
Java桥梁设计模式优雅地将抽象与实现分离
Kande 2023-07-12
1132
Java如何判断字符串中是否包含某个字符
Rhea 2023-07-18
1094
Mybatis-plus操作json字段实战教程
Nora 2023-07-18
548
前端ajax请求+后端java实现的下载zip压缩包功能示例
Malinda 2023-07-20
1062
使用linux java shell启动脚本
Antonia 2023-07-20
60
SQL DNSlog注入实战
Dagny 2023-07-20
239
oracle分区表创建(自动按年、月、日分区)实战记录
Roselani 2023-07-20
1764
关于Java中RabbitMQ的高级特性
Gretel 2023-07-20
430
JavaScript实现留言板实战案例
Maha 2023-07-20
1308
Java基础技术之反射详解
Xylona 2023-07-21
1208
Android创建文件时出现java.io.IOException: Operation not permitted异常的解决方法
Tia 2023-07-21
531
C#字符串与数值类型、字节数组的互相转换实战案例
Janna 2023-07-22
650