Stream中的Peek操作

1.引言

　　如果你试图对流操作中的流水线进行调试, 了解stream流水线每个操作之前和操作之后的中间值, 该如何去做?

　　首先我们看一个例子, 使用forEach将流操作的结果打印出来.

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 public class PeekTestOne {
 7     public static void main(String[] args) {
 8         List<Integer> list = Arrays.asList(4, 7, 9, 11, 12);
 9         list.stream()
10                 .map(x -> x + 2)
11                 .filter(x -> x % 2 != 0)
12                 .limit(2)
13                 .forEach(System.out::println);
14     }
15 }
16 输出结果如下:
17 9
18 11

　　可以很明显的看出, 一旦调用了forEach操作, 整个流就会恢复运行.并不能很好的帮助我们了解Stream流水线中的每个操作(如:map,filter,limit等)产生的输出.

　　再来看一个例子

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 public class PeekTestTwo {
 7     public static void main(String[] args) {
 8         Stream<Integer> stream = Arrays.asList(4, 7, 9, 11, 12).stream();
 9         stream.peek(System.out::println);
10
11     }
12 }
13 这段代码是想打印stream中的值,却没有任何输出.

2.中间操作和终止操作

　　中间操作是流水线中的数据进行加工的, 它是一个懒操作, 并不会马上执行, 需要等待有终止操作的时候才会执行.

　　终止操作是Stream的启动操作, 当有终止操作的时候, Stream才会真正的开始执行.

　　因此, 这里可以解释上面的peek操作是一个中间操作, 所以没有任何输出.

3.使用peek进行debug操作

peek的设计初衷就是在流的每个元素恢复运行之前的时候插入一个执行操作. 它不想forEach那样恢复整个流的运行操作. 而是在一个元素上完成操作之后, 它只会将操作顺承到流水线的下一个操作. 它能够将中间变量的值输出到日志. 有效的帮助我们了解流水线的每一步操作的输出值.如下图:

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 public class PeekTestThree {
 7     public static void main(String[] args) {
 8         List<Integer> list = Arrays.asList(4, 7, 9, 11, 12);
 9         list.stream()
10                 .peek(x -> System.out.println("stream: " + x))
11                 .map(x -> x + 2)
12                 .peek(x -> System.out.println("map: " + x))
13                 .filter(x -> x % 2 != 0)
14                 .peek(x -> System.out.println("filter: " + x))
15                 .limit(2)
16                 .peek(x -> System.out.println("limit: " + x))
17                 .collect(toList());
18     }
19 }
20 输出结果如下：
21 stream: 4
22 map: 6
23 stream: 7
24 map: 9
25 filter: 9
26 limit: 9
27 stream: 9
28 map: 11
29 filter: 11
30 limit: 11
31
32 Process finished with exit code 0

4.peek和map的区别

　　使用peek操作流，流中的元素没有改变。

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 public class PeekAndMapTestOne {
 7     public static void main(String[] args) {
 8         Arrays.asList("a","b")
 9                 .stream()
10                 .peek(x -> x.toUpperCase())
11                 .forEach(System.out::println);
12     }
13 }
14 输出：
15 a
16 b
17
18 Process finished with exit code 0

　　使用map操作流，流中的元素有改变。

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 public class PeekAndMapTestTwo {
 7     public static void main(String[] args) {
 8         Arrays.asList("a","b")
 9                 .stream()
10                 .map(x -> x.toUpperCase())
11                 .forEach(System.out::println);
12     }
13 }
14 输出：
15 A
16 B
17
18 Process finished with exit code 0

　　可以通过上面两个例子看出，map操作是对元素进行了转换。

　　注意:peek对一个对象进行操作的时候,对象不变,但是可以改变对象里面的值.如下:

 1 /**
 2  * @author lyh
 3  * @version v-1.0.0
 4  * @since 2021/5/28
 5  */
 6 @Getter
 7 @Setter
 8 @AllArgsConstructor
 9 @ToString
10 public class Person {
11
12     private String id;
13     private String name;
14
15 }
16 ----------------------------------------------------------------------------
17 /**
18  * @author lyh
19  * @version v-1.0.0
20  * @since 2021/5/28
21  */
22 public class PeekAndMapTestThree {
23     public static void main(String[] args) {
24         Arrays.asList(new Person("001","zs"),new Person("002","ls"))
25                 .stream().peek(p -> p.setId("000")).forEach(System.out::println);
26     }
27 }
28 输出:
29 Person(id=000, name=zs)
30 Person(id=000, name=ls)
31
32 Process finished with exit code 0

　　peek的定义

1 Stream<T> peek(Consumer<? super T> action);

　　peek方法接收一个Consumer的入参. 了解λ表达式的应该明白 Consumer的实现类应该只有一个方法，该方法返回类型为void. 它只是对Stream中的元素进行某些操作,但是操作之后的数据并不返回到Stream中,所以Stream中的元素还是原来的元素.

　　map的定义

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

　　map方法接收一个Function作为入参. Function是有返回值的, 这就表示map对Stream中的元素的操作结果都会返回到Stream中去.

​　  觉得此文不错, 点赞+转发+关注, 本人非常感谢!