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

　　能够根据上边2个事例看得出，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中来.

 ​　  感觉该文非常好, 关注点赞 分享 关心, 自己特别感谢!