JDK-Stream

1.Stream

1.前沿

​ Stream是JDK1.8出现的，提供了我们对集合进行一些操作的API，配合这Lambda的使用，个人感觉是棒极了，虽然我们用普通的代码也可以实现，但是用Stream的话 ，会让代码更加的清新。

2.Stream的工作流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3iGSkC5P-1637593204295)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211121203638775.png)]

一个Stream数据源，我们可以做多个中间操作，但是只能做一个终止操作

3.四个基本的函数式接口

1. Consumer 消费型接口
2. Supplier 供给型接口
3. Function<T , R> 函数行接口
4. Predicate 断言行接口

4.起始操作

1.上面我们提到Stream可以更好为我们的集合进行一些数据的操作，所以我们的集合中都有一个.stream()的方法。

2.我们还可以通过Stream的静态方法创建一个Stream

1. 通过静态方法of

   Stream<Integer> integerStream = Stream.of(1, 2, 3);
   

2. 静态方法 generate

   Supplier supplier = () ->
                   Math.round(10);
           Stream generate = Stream.generate(supplier);
   

3. 静态方法

   Stream iterate = Stream.iterate(10, x -> x + 3).limit(10);
   
   iterate.forEach(System.err::println);
   

5.中间操作

1. 筛选与切片

1. Stream filter(Predicate<? super T> predicate); 从流中过滤某些元素

   
   Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
           //断言型函数
           //过滤集合中的某些元素
           Predicate predicate = new Predicate() {
               @Override
               public boolean test(Object o) {
                   return false;
               }
           };
           stream.filter(x->x>2);
   

2. Stream distinct();根据泛型的hashCode和equals去去除重复元素

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   stream.distinct();
   

3. Stream limit(long maxSize); 类似于mysql的分页，截断流

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   long maxSize = 3;
   stream.limit(maxSize);
   

4. Stream skip(Long n); 跳过N个元素

   /**
            * 跳过N个元素，如果数据的长度小于跳过的长度，将会返回一个空流，与Limit互补
            */
   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   long n = 3;
   stream.skip(n);
   

2.映射

1. 接收一个功能函数作为参数，该函数会应用到每一个元素上，并将其映射成一个新的元素

   //接收一个功能函数作为参数，该函数会应用到每一个元素上，并将其映射成一个新的元素
           Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
           Function<Integer,Integer> function = new Function<Integer, Integer>() {
               @Override
               public Integer apply(Integer integer) {
                   return (int)integer.longValue();
               }
           };
           stream.map(x->x.longValue());
   

2. 其他类型的同理

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gf4pxuNn-1637593204296)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122214317585.png)]

3.排序

1. 自然排序

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   stream.sorted();
   

2. 根据Component排序

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
           //返回一个int >0 排前边  =0 相等  <0 排后边
       Comparator comparator = new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
                   return 0;
               }
           };
    stream.sorted((x,y)->x.intValue() - y.intValue());
   

4.随时更新

6.终止操作

1.获取值

1. 最大值

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
       Comparator c = new Comparator() {
               @Override
               public int compare(Object o1, Object o2){
                   return 0;
               }
           };
   stream.max((x,y)->x.intValue() - y.intValue());
   

2. 最小值

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
           Comparator c = new Comparator() {
               @Override
               public int compare(Object o1, Object o2){
                   return 0;
               }
           };
   stream.min((x,y)->x.intValue() - y.intValue());
   

3. 元素总个数

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   stream.count();
   

2.遍历值

1. foreach（参数是一个消费函数）

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
           Consumer<Integer> consumer = new Consumer<Integer>() {
               @Override
               public void accept(Integer integer) {
                   return;
               }
           };
   stream.forEach(x->x.intValue());
   

3.匹配与查找

1. 检查是否匹配所有元素（参数是断言函数）

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
           Predicate<Integer> predicate = new Predicate<Integer>() {
               @Override
               public boolean test(Integer integer) {
                   return false;
               }
           };
   stream.allMatch(x->{return true;});
   

2. 检查是否匹配其中一个函数

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   Predicate<Integer> predicate = new Predicate<Integer>() {
               @Override
               public boolean test(Integer integer) {
                   return false;
               }
           };
   stream.anyMatch(x->x.intValue()>0);
   

3. 返回第一个元素

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   Optional<Integer> first = stream.findFirst();
   System.err.println(first.get());
   

4. 返回当前流任意一个数据

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   Optional<Integer> first = stream.findAny();
   System.err.println(first.toString());
   

4.收集

1. Collect

   Stream<Integer> stream = Stream.of(1, 2, 2, 4, 5, 6);
   //参数接口一个collector的实现即可
   stream.collect(Collectors.toList());
   stream.collect(Collectors.toSet());
   

2.附图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qhniaV8k-1637593204298)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225250215.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sotnTI05-1637593204299)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225257666.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MIlLCGOX-1637593204300)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225304240.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-alaK7TmC-1637593204305)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225310392.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XvEZKvLW-1637593204306)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225319663.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1kjpBpPf-1637593204307)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225325532.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-759ilG3S-1637593204308)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225334515.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hW8GMFId-1637593204309)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225343483.png)]

[外链图片转存中…(img-MIlLCGOX-1637593204300)]

[外链图片转存中…(img-alaK7TmC-1637593204305)]

[外链图片转存中…(img-XvEZKvLW-1637593204306)]

[外链图片转存中…(img-1kjpBpPf-1637593204307)]

[外链图片转存中…(img-759ilG3S-1637593204308)]

[外链图片转存中…(img-hW8GMFId-1637593204309)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-amtsTDSA-1637593204309)(C:\Users\user\AppData\Roaming\Typora\typora-user-images\image-20211122225352447.png)]