Java8Stream流

Stream流呢，以前我也有所了解，像一些面试题中也出现过，Java8的新特性，有一块就是这个Stream操作集合，而且在看一些项目中也使用的比较多。但总感觉自己学的一知半解，所以今天打算系统的过一下，再巩固巩固。

概念

Stream是JDK8 API中的新成员，它允许以声明性方式处理集合。
流程

1、把集合转换为流Stream
2、操作Stream流
Stream流在管道中经过中间操作(intermediate operation)的处理，最后由最终操作(terminal operation)得到前面处理的结果
一些常见的中间操作和中止操作

• 中间操作（过滤、映射、限制...)，可以多个
  

方法名方法作用返回值类型方法类型filter过滤Stream中间操作map映射（转换）接收一个函数作为参数，这个函数会被应用到每个元素上，并将其映射成为一个新的元素Stream中间操作peek窥探Stream中间操作skip跳过前几个Stream中间操作limit截取前几个Stream中间操作distinct去重操作(比较的是地址)Stream中间操作sorted排序操作Stream中间操作

• 终止操作（最常见的是收集），只可以设置1个
  

方法名方法作用返回值类型方法类型collect收集处理结果泛型终止操作count统计个数long终止操作forEach逐一处理void终止操作reduce汇总操作Optional  该对象有get方法可以获取返回值终止操作Stream的3个注意事项:

• Stream中间操作方法返回的是新的流
  
• Stream不调用终结方法，中间的操作不会执行
  
• Stream只能调用一次终止操作。得到结果后，不能再次使用这个流。
  

下面是一些小demo

点击查看代码

1. /**
2.      * 过滤集合中不符合条件的元素
3.      */
4.     @Test
5.     public void testfilter(){
6.         List<String> stringList = Arrays.asList("abc", "", "bc", "def", "abcd", "", "jkl");
7.         List<String> aList = stringList.stream().filter(str -> str.contains("a")).collect(Collectors.toList());
8.         aList.forEach(System.err::println);
9.     }
11.     /**
12.      *去重
13.      */
14.     @Test
15.     public void testDistinct(){
16.         List<String> stringList = Arrays.asList("abc", "", "bc", "def", "abcd", "", "jkl","jkl");
17.         List<String> distinctStr = stringList.stream().distinct().collect(Collectors.toList());
18.         distinctStr.forEach(System.out::println);
19.         //--------------------------------
20.         Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
21.         Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
22.         Product prod3 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
23.         ArrayList<Product> proList = Lists.newArrayList(prod1, prod2, prod3);
24.         List<Product> distinctProList = proList.stream().distinct().collect(Collectors.toList());
25.         distinctProList.forEach(System.out::println);
26.     }
28.     /**
29.      * limit(n)获取流中的前n个元素
30.      */
31.     @Test
32.     public void testLimit(){
33.         List<String> stringList = Arrays.asList("abc", "", "bc", "def", "abcd", "", "jkl","jkl");
34.         List<String> limitStr = stringList.stream().limit(3).collect(Collectors.toList());
35.         System.out.println(limitStr);
36.     }
38.     /**
39.      * skip(n)
40.      */
41.     @Test
42.     public void testSkip(){
43.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
44.         List<String> skipStrList = stringList.stream().skip(2).collect(Collectors.toList());
45.         System.out.println(skipStrList);
46.     }
48.     /**
49.      * map() 接收一个函数作为参数，这个函数会被应用到每个元素上，并将其映射成为一个新的元素
50.      */
51.     @Test
52.     public void testMap(){
53.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
54.         List<String> mapStrList = stringList.stream().map(str -> str.concat("_map")).collect(Collectors.toList());
55.         System.out.println(mapStrList);
56.     }
58.     @Test
59.     public void testSorted(){
60.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
61.         List<String> sortedStrList = stringList.stream().sorted().collect(Collectors.toList());
62.         System.out.println(sortedStrList);
63.     }
65.     /**
66.      * collect():将流转换为其他形式 list set map
67.      */
68.     @Test
69.     public void testCollect(){
70.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
71.         Set<String> collectSet = stringList.stream().collect(Collectors.toSet());
72.         System.out.println(collectSet);
73.     }
75.     /**
76.      * 将流中元素反复结合起来得到一个结果
77.      */
78.     @Test
79.     public void testReduce(){
80.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
81.         Optional<String> reduce = stringList.stream().reduce((acc, item) -> {return acc + item;});
82.         if (reduce.isPresent()) System.out.println(reduce.get());
83.     }
85.     /**
86.      * 将流中元素反复结合起来得到一个结果
87.      */
88.     @Test
89.     public void testCount(){
90.         List<String> stringList = Arrays.asList("abc", "", "bcd", "def", "abcd", "", "jkl","jkl");
91.         long count = stringList.stream().count();
92.         System.out.println(count);
93.     }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！