玩转Java8的 Stream 之从零认识Stream

小鱼儿 2022-12-16 13:09 242阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbG9nZW5pdXM_size_16_color_FFFFFF_t_70_pic_center]

相信Java8的Stream 大家都已听说过了，但是可能大家不会用或者用的不熟，笔者将在《玩转Java8Stream》系列文章中带大家从零开始使用，循序渐进，带你走向Stream的巅峰。

## 操作符 ##

什么是操作符呢？操作符就是对数据进行的一种处理工作，一道加工程序；就好像工厂的工人对流水线上的产品进行一道加工程序一样。

![dad7daa9413ea2bc362cbeac1df68f28.png][]

**Stream**的操作符大体上分为两种：**中间操作符**和**终止操作符**

### 中间操作符 ###

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符。

中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作)：

> 1.  map(mapToInt,mapToLong,mapToDouble) 转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。
> 2.  flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int\[\]\{2,3,4\} 拍平 变成 2，3，4 也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。
> 3.  limit 限流操作，比如数据流中有10个 我只要出前3个就可以使用。
> 4.  distint 去重操作，对重复元素去重，底层使用了equals方法。
> 5.  filter 过滤操作，把不想要的数据过滤。
> 6.  peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。
> 7.  skip 跳过操作，跳过某些元素。
> 8.  sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

### 终止操作符 ###

数据经过中间加工操作，就轮到终止操作符上场了；终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。

> 1.  collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。
> 2.  count 统计操作，统计最终的数据个数。
> 3.  findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。
> 4.  noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素 返回值为bool 值。
> 5.  min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。
> 6.  reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。
> 7.  forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。
> 8.  toArray 数组操作，将数据流的元素转换成数组。

这里只介绍了Stream，并没有涉及到**IntStream**、**LongStream**、**DoubleStream**，这三个流实现了一些特有的操作符，我将在后续文章中介绍到。

说了这么多，只介绍这些操作符还远远不够；俗话说，实践出真知。那么，Let‘s go。

## 代码演练 ##

**Stream 的一系列操作必须要使用终止操作，否者整个数据流是不会流动起来的，即处理操作不会执行。**

### map ###

*  map，可以看到 map 操作符要求输入一个Function的函数是接口实例，功能是将T类型转换成R类型的,map 方法用于映射每个元素到对应的结果

![faa05ce27f4dbcda146573eb0d2f6193.png][]

一起来看下面的例子,map操作将原来的单词 转换成了每个单的长度，利用了String自身的length()方法，该方法返回类型为int。这里我直接使用了lambda表达式，关于lambda表达式 还请读者们自行了解吧。

public class Main { 
    
        public static void main(String[] args) { 
         Stream.of("apple","banana","orange","waltermaleon","grape")
                    .map(e->e.length()) //转成单词的长度 int
                    .forEach(e->System.out.println(e)); //输出
        }
    }

当然也可以这样，这里使用了成员函数引用，为了便于读者们理解，后续的例子中将使用lambda表达式而非函数引用。

public class Main { 
    
        public static void main(String[] args) { 
                 Stream.of("apple","banana","orange","waltermaleon","grape")
                        .map(String::length) //转成单词的长度 int
                        .forEach(System.out::println);
        }
    }

map如图：

![1652b54386c8f123262f7f14ccd0bdcf.png][]

### mapToInt ###

*  mapToInt 将数据流中得元素转成Int，这限定了转换的类型Int，最终产生的流为IntStream，及结果只能转化成int。

![3aaadf77f3e157005a656be1d33349ec.png][]

public class Main { 
    
        public static void main(String[] args) { 
             Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .mapToInt(e -> e.length()) //转成int
                    .forEach(e -> System.out.println(e));
        }
    }

mapToInt如图：

![da8a9613b0f85b19488d6427d68e7764.png][]

### mapToLong ###

*  mapToLong、mapToDouble 与mapToInt 类似

public class Main { 
    
        public static void main(String[] args) { 
             Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .mapToLong(e -> e.length()) //转成long ,本质上是int 但是存在类型自动转换
                    .forEach(e -> System.out.println(e));
        }
    }

mapToLong 如图：

![da8a9613b0f85b19488d6427d68e7764.png][]

### mapToDouble ###

public class Main { 
    
        public static void main(String[] args) { 
             Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .mapToDouble(e -> e.length()) //转成Double ，自动类型转换成Double
                    .forEach(e -> System.out.println(e));
        }
    }

mapToDouble如图：

![d691d60a9a7afed5bc83445cd4b0332e.png][]

### flatMap ###

*  flatmap 作用就是将元素拍平拍扁 ，将拍扁的元素重新组成Stream，并将这些Stream 串行合并成一条Stream

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

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of("a-b-c-d","e-f-i-g-h")
                    .flatMap(e->Stream.of(e.split("-")))
                    .forEach(e->System.out.println(e));
    
        }
    }

flatmap 如图：

![19d91c10dc11036b1efcd23fa94f4bbb.png][]

*  flatmapToInt、flatmapToLong、flatmapToDouble 跟flatMap 都类似的，只是类型被限定了，这里就不在举例子了。

### limit ###

*  limit 限制元素的个数，只需传入 long 类型 表示限制的最大数

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of(1,2,3,4,5,6)
                    .limit(3) //限制三个
                    .forEach(e->System.out.println(e)); //将输出 前三个 1，2，3
        }
    }

limit如图：

![5f531285d51cf9658e8e9f08107b522b.png][]

### distinct ###

*  distinct 将根据equals 方法进行判断，如果要对自己自定义的bean 去重，则需要 重写equals方法，但是这不是唯一的方法，后面文章我将带大家实现自定义（bean 的某个字段去重）去重。

![5890e29682e794eb23ba056ff1196c86.png][]

public class Main { 
    
        public static void main(String[] args) { 
    
            Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)
                    .distinct() //去重
                    .forEach(e->System.out.println(e));
    
        }
    }

distinct 如图：

![105406cc3543ed19471375e4663a1621.png][]

### filter ###

*  filter 对某些元素进行过滤，不符合筛选条件的将无法进入流的下游

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)
                    .filter(e->e>=5) //过滤小于5的
                    .forEach(e->System.out.println(e));
        }
    }

filter 如图：

![a6791b82f299c759dc59835da2aa7cfd.png][]

### peek ###

*  peek 挑选 ，将元素挑选出来，可以理解为提前消费

public class Main { 
    
        public static void main(String[] args) { 
    
            User w = new User("w",10);
            User x = new User("x",11);
            User y = new User("y",12);
    
            Stream.of(w,x,y)
                    .peek(e->{ e.setName(e.getAge()+e.getName());}) //重新设置名字 变成 年龄+名字
                    .forEach(e->System.out.println(e.toString()));
    
        }
    
        static class User { 
    
            private String name;
    
            private int age;
    
            public User(String name, int age) { 
                this.name = name;
                this.age = age;
            }
    
            public String getName() { 
                return name;
            }
    
            public void setName(String name) { 
                this.name = name;
            }
    
            public int getAge() { 
                return age;
            }
    
            public void setAge(int age) { 
                this.age = age;
            }
    
            @Override
            public String toString() { 
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
    }

peek 如图：

![6ef7cdf0550404ba08310e00182a5a2f.png][]

### skip ###

*  skip 跳过 元素

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of(1,2,3,4,5,6,7,8,9)
                    .skip(4) //跳过前四个
                    .forEach(e->System.out.println(e)); //输出的结果应该只有5，6，7，8，9
        }
    }

skip 如图：

![57d708c253f6e47214fc2793e8b89a40.png][]

### sorted ###

*  sorted 排序 底层依赖Comparable 实现，也可以提供自定义比较器

这里Integer 实现了比较器

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of(2,1,3,6,4,9,6,8,0)
                    .sorted()
                    .forEach(e->System.out.println(e));
        }
    }

sorted 默认比较器如图：

![adec5979e6061888d57dc7041a9c60b8.png][]

这里使用自定义比较，当然User 可以实现Comparable 接口

public class Main { 
    
        public static void main(String[] args) { 
    
            User x = new User("x",11);
            User y = new User("y",12);
            User w = new User("w",10);
    
            Stream.of(w,x,y)
                    .sorted((e1,e2)->e1.age>e2.age?1:e1.age==e2.age?0:-1)
                    .forEach(e->System.out.println(e.toString()));
    
        }
    
        static class User { 
    
            private String name;
    
            private int age;
    
            public User(String name, int age) { 
                this.name = name;
                this.age = age;
            }
    
            public String getName() { 
                return name;
            }
    
            public void setName(String name) { 
                this.name = name;
            }
    
            public int getAge() { 
                return age;
            }
    
            public void setAge(int age) { 
                this.age = age;
            }
    
            @Override
            public String toString() { 
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
    }

如图：

![0321b2010ce4723f5662680804e4a3d3.png][]

### collect ###

*  collect 收集，使用系统提供的收集器可以将最终的数据流收集到List，Set，Map等容器中。

这里我使用collect 将元素收集到一个set中

public class Main { 
    
        public static void main(String[] args) { 
            Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .collect(Collectors.toSet()) //set 容器
                    .forEach(e -> System.out.println(e));
        }
    }

咦？，不是说终止操作符只能使用一次吗，为什么这里调用了forEach 呢？forEach不仅仅是是Stream 中得操作符还是各种集合中得一个语法糖，不信咋们试试。

public class Main { 
    
        public static void main(String[] args) { 
            
            Set<String> stringSet = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .collect(Collectors.toSet()); //收集的结果就是set
            stringSet.forEach(e->System.out.println(e)); set的语法糖forEach
    }

结果如图：

![8067929cccf0959a81b502ae2fea3724.png][]

### count ###

*  count 统计数据流中的元素个数，返回的是long 类型

public class Main { 
    
        public static void main(String[] args) { 
    
            long count = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .count();
    
            System.out.println(count);
        }
    }

count 如图：

![206abe697843042e5aaaf1f8520dbbe0.png][]

### findFirst ###

*  findFirst 获取流中的第一个元素

这里找到第一个元素 apple

public class FindFirst { 
    
        public static void main(String[] args) { 
            Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .findFirst();
            stringOptional.ifPresent(e->System.out.println(e));
        }
    }

findFirst 结果如图：

![feb6b1141332229cdca013a2360bb865.png][]

*  findAny 获取流中任意一个元素

public class FindAny { 
    
        public static void main(String[] args) { 
            Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                    .parallel()
                    .findAny(); //在并行流下每次返回的结果可能一样也可能不一样
            stringOptional.ifPresent(e->System.out.println(e));
        }
    }

findAny 在并行流下 使用结果：

输出了orange

![0b77982a9dae8653f01d4cb22e70f71f.png][]

输出了banana

![d3853cec7c71d761fbb345483287df4b.png][]

### noneMatch ###

*  noneMatch 数据流中得没有一个元素与条件匹配的

这里 的作用是是判断数据流中 一个都没有与aa 相等元素 ，但是流中存在 aa ，所以最终结果应该是false

public class NoneMatch { 
    
        public static void main(String[] args) { 
            boolean result = Stream.of("aa","bb","cc","aa")
                    .noneMatch(e->e.equals("aa"));
            System.out.println(result);
        }
    }

noneMatch 如图：

![3b4004a93d1f90d1fe8fb081b9673ec7.png][]

### allMatch&anyMatch ###

*  allMatch和anyMatch 一个是全匹配，一个是任意匹配 和noneMatch 类似，这里就不在举例了。
    
    ### min ###
 *  min 最小的一个，传入比较器，也可能没有(如果数据流为空)

public class Main { 
    
        public static void main(String[] args) { 
    
            Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)
                    .min((e1,e2)->e1.compareTo(e2));
            integerOptional.ifPresent(e->System.out.println(e));
    
        }

min如图：

![3c22a04465ac47a6d5d82bc63b3f1296.png][]

### max ###

*  max 元素中最大的，需要传入比较器，也可能没有（流为Empty时）

public class Main { 
    
        public static void main(String[] args) { 
    
            Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)
                    .max((e1,e2)->e1.compareTo(e2));
    
            integerOptional.ifPresent(e->System.out.println(e));
    
        }
    }

max 如图：

![6869967cdb919a697a041a60bc804216.png][]

*  reduce 是一个规约操作，所有的元素归约成一个，比如对所有元素求和，乘啊等。
    
    这里实现了一个加法，指定了初始化的值

public class Main { 
        public static void main(String[] args) { 
    
            int sum = Stream.of(0,9,8,4,5,6,-1)
                  .reduce(0,(e1,e2)->e1+e2);
            System.out.println(sum);
        }
    }

reduce 如图：

![ce075ab356b4d475c301b93e6c3cfb07.png][]

### forEach ###

forEach 其实前就已经见过了，对每个数据遍历迭代

*  forEachOrdered 适用用于并行流的情况下进行迭代，能保证迭代的有序性,这里通过并行的方式输出数字

public class ForEachOrdered { 
        public static void main(String[] args) { 
            Stream.of(0,2,6,5,4,9,8,-1)
                    .parallel()
                    .forEachOrdered(e->{ 
                        System.out.println(Thread.currentThread().getName()+": "+e);});
        }
    }

forEachOrdered 如图：

![42c1d60870118d6ffc4cfff5cf26e05c.png][]

### toArray ###

*  toArray 转成数组，可以提供自定义数组生成器

public class ToArray { 
        public static void main(String[] args) { 
            Object[] objects=Stream.of(0,2,6,5,4,9,8,-1)
                    .toArray();
    
            for (int i = 0; i < objects.length; i++) { 
                System.out.println(objects[i]);
            }
        }
    }

toArray 如图：

![453316d93982bd9cc070cdb34e7bab04.png][]

## 总结 ##

`Java8Stream` 第一篇就带大家认识到这里，如果你能跟着我的文章把每一个例子都敲一遍，相信都能掌握这些操作符的初步用法；后续文章我会带大家一步步深入Stream。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbG9nZW5pdXM_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/f215997537bf42dcb55a09b2dd05c576.png
[dad7daa9413ea2bc362cbeac1df68f28.png]: /images/20221123/43fe798a8cc34f4cb5d4d96101f192f4.png
[faa05ce27f4dbcda146573eb0d2f6193.png]: /images/20221123/4b84eb0303ff48be9f2fa4828e66642e.png
[1652b54386c8f123262f7f14ccd0bdcf.png]: /images/20221123/57c52d91d3064d68abde7315c258f3f6.png
[3aaadf77f3e157005a656be1d33349ec.png]: /images/20221123/83bdfbea494249abb05bd7c25f731cdf.png
[da8a9613b0f85b19488d6427d68e7764.png]: /images/20221123/9a4e684395ac4f8bb62290bd9cf10b5a.png
[d691d60a9a7afed5bc83445cd4b0332e.png]: /images/20221123/ce690b30809d49ae887d457ed268abdb.png
[19d91c10dc11036b1efcd23fa94f4bbb.png]: /images/20221123/e70f9c08e72141338df3572d6f9dfd13.png
[5f531285d51cf9658e8e9f08107b522b.png]: /images/20221123/8abe6aa03c7c4930a2dbff3e22564a59.png
[5890e29682e794eb23ba056ff1196c86.png]: /images/20221123/18cdd5c3888f42f99ce646dcec23816f.png
[105406cc3543ed19471375e4663a1621.png]: /images/20221123/ad4f12fb286f458fb7b0529f61b44454.png
[a6791b82f299c759dc59835da2aa7cfd.png]: /images/20221123/cb9a48f5b11b47efa08bd8c750e77dc2.png
[6ef7cdf0550404ba08310e00182a5a2f.png]: /images/20221123/f1ca8669c5be43b5811dd97781158e81.png
[57d708c253f6e47214fc2793e8b89a40.png]: /images/20221123/bfc646453cc244999b9bd2d24daa7d20.png
[adec5979e6061888d57dc7041a9c60b8.png]: /images/20221123/824fcd4ae4e7485b8995622447e1067b.png
[0321b2010ce4723f5662680804e4a3d3.png]: /images/20221123/b3fd3ca9d6564f70afcec87c1286d11f.png
[8067929cccf0959a81b502ae2fea3724.png]: /images/20221123/aa8de7ae77ac4ba987bbe7ed6ae3a142.png
[206abe697843042e5aaaf1f8520dbbe0.png]: /images/20221123/1c68104aa2ae4dc9a54dd904deccbd84.png
[feb6b1141332229cdca013a2360bb865.png]: /images/20221123/b36a876e93fa4f09b9d168f86032e117.png
[0b77982a9dae8653f01d4cb22e70f71f.png]: /images/20221123/5efe4e0884cd403582a187eee4ef55ae.png
[d3853cec7c71d761fbb345483287df4b.png]: /images/20221123/9b2f1b56444842a9ab06fa8faeb3fe5a.png
[3b4004a93d1f90d1fe8fb081b9673ec7.png]: /images/20221123/492b9ac7623741e290d16ee1cda477e9.png
[3c22a04465ac47a6d5d82bc63b3f1296.png]: /images/20221123/49b46cc913fd419d924340a79d7d834c.png
[6869967cdb919a697a041a60bc804216.png]: /images/20221123/6ff398d656934666992e31799e46f780.png
[ce075ab356b4d475c301b93e6c3cfb07.png]: /images/20221123/da052ffb6751458a9222321904c796de.png
[42c1d60870118d6ffc4cfff5cf26e05c.png]: /images/20221123/ab67048c71b64c55a1686d3761e960c9.png
[453316d93982bd9cc070cdb34e7bab04.png]: /images/20221123/91d5c777d05242e4a1605d678087dfee.png