Java8Stream（高效处理集合数据）

🔖什么是Stream？

---

 ▐ 概述

 •  这里的Stream流与之前JavaSE中的IO流是完全不同的两个概念，不要混淆！ 

 •  IO流是：输入输出文件内容

 •  java8stream是：处理数据集合，遍历数据集的高级迭代器，可以对数组、集合类进行各种操作.

 •  Stream处理数据大体过程：

    数组/集合类 ----> 流 ----> 各种操作 ( 如过滤、排序 ) ----> 最终结果 ( 数组/集合类 )    

🔖获取流

---

 ▐ 获取Stream流方式常用的有三种：

 •  使用Collection接口下的stream()   对应集合

 •  使用Arrays中的stream()方法，将数组转成流   对应数组

 •  使用Stream中的静态方法：of()

⌨️代码演示

 1.  使用Collection接口下的stream()

        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        Stream<Integer> stream = list.stream();

 2.  使用Arrays中的stream()方法，将数组转成流

        Integer[] array =new Integer[]{1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(array);

 3.  使用Stream中的静态方法：of()

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

🔖流操作

---

 •  流操作分为中间操作和终端操作

 •  对某一数据处理的过程为：数据源 ---> 中间操纵 ---> 终端操作 ---> 结果

🏷️中间操作

---

 

▐ 常用操作有：

 •  filter :      过滤流中的某些元素

        Integer[] array =new Integer[]{1,2,3,4,5,2,4};
        List<Integer> list=Arrays.stream(array)//获取流
                .filter((e)->{                 //中间操作(过滤)
                    return e>3;                //过滤条件
                })
                .collect(Collectors.toList()); //终端操作(返回一个集合)
        System.out.println(list);              //输出结果：[4, 5, 4]

 •  sorted：  排序（流中元素需要实现Comparable接口）

        Integer[] array =new Integer[]{1,2,3,4,5,2,4};
        List<Integer> list=Arrays.stream(array)//获取流
                .sorted((o1,o2)->{             //中间操作(排序)
                    return o2-o1;              //逆序
                })
                .collect(Collectors.toList()); //终端操作(返回一个集合)
        System.out.println(list);              //输出结果：[5, 4, 4, 3, 2, 2, 1]

 •  distinct：去掉重复元素

        Integer[] array =new Integer[]{1,2,3,4,5,2,4};
        List<Integer> list=Arrays.stream(array)//获取流
                .distinct()                    //中间操作(去掉重复元素)
                .collect(Collectors.toList()); //终端操作(返回一个集合)
        System.out.println(list);              //输出结果：[1, 2, 3, 4, 5]

 •  limit(n) ：获取n个元素

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        List<Integer> list = Arrays.stream(array)//获取流
                .limit(4)                       //中间操作(获取n个元素)
                .collect(Collectors.toList());  //终端操作(返回一个集合)
        System.out.println(list);               //输出结果：[1, 2, 3, 4]

 •  skip(n) ：跳过n个元素，配合limit(n)可以实现分页

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        List<Integer> list = Arrays.stream(array)//获取流
                .skip(3)                        //中间操作(跳过n个元素)
                .limit(4)                       //中间操作(获取n个元素)
                .collect(Collectors.toList());  //终端操作(返回一个集合)
        System.out.println(list);               //输出结果：[4, 5, 2, 4]

 •  map() ：  将其映射成一个新的元素

▐ 可以对数据进行多次中间操作

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        List<Integer> list = Arrays.stream(array)//获取流
                .distinct()                      //中间操作(去掉重复元素) 12345
                .sorted((o1,o2)->{
                    return o2-o1;
                })                               //中间操作(排序,逆序)   54321
                .limit(3)                        //中间操作(获取3个元素)  543
                .collect(Collectors.toList());   //终端操作(返回一个集合)
        System.out.println(list);                //输出结果：[5, 4, 3]

🏷️终端操作

---

 •  终端操作通常返回的是我们需要的结果（如数组、集合、单值）

▐ 常用操作有：

▐ 代码详细演示：

 •  forEach：遍历流中的元素

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        Arrays.stream(array)
                .forEach((e) -> {
                    System.out.print(e);//遍历：1234524
                });

 •  collect：     将流中的元素倒入一个集合, Collection或Map

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        List<Integer> list =Arrays.stream(array)
                .distinct()
                .collect(Collectors.toList());//将处理后的流元素重新导入一个集合中
        System.out.println(list);//[1, 2, 3, 4, 5]

 •    Min：     返回流中元素最小值

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        Integer min=Arrays.stream(array)
                .distinct()
                .max((o1,o2)->{
                    return o2-o1; //o2-o1返回min  o1-o2返回max
                })
                .get();           //.get不能忘
        System.out.println(min);     //结果输出：1

                                                                                                                    （ .get 不要忘记哦！） 

 •    Max        返回流中元素最大值

//模仿上述求最小值，只需将o2-o1改为o1-o2即可

 •   count：     返回流中元素的总个数

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        long count=Arrays.stream(array)
                .distinct()   //中间操作(去重) 12345
                .count();     //终端操作(流中元素个数)
        System.out.println(count);//结果输出：5

                                                                                                                           （ 返回值是long ）

 •  Reduce：   所有元素求和

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        Integer sum=Arrays.stream(array)
                .distinct()
                .reduce((o1,o2)->{
                    return o1+o2;
                })                   //去重后求和 1+2+3+4+5
                .get();
        System.out.println(sum);     //结果输出：15

                                                                                                                   （ .get 不要忘记哦！）   

 •  anyMatch：接收一个Predicate函数，只要流中有一个元素满足条件则返回true，否则返回false

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        boolean anyMatch=Arrays.stream(array)
                .anyMatch((e)->{
                    return e>4;   //流中只要有一个元素满足条件就返回true
                });
        System.out.println(anyMatch); //结果输出：true

 •  allMatch：  接收一个Predicate函数，当流中每个元素都符合条件时才返回true，否则返回false

       Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
        boolean allMatch=Arrays.stream(array)
                .allMatch((e)->{
                    return e>1;   //流中所有元素满足条件才返回true
                });
        System.out.println(allMatch); //结果输出：false

  •  findFirst：  返回流中第一个元素

        Integer[] array = new Integer[]{6, 2, 3, 4, 5, 2, 4};
        Integer first=Arrays.stream(array)
                .findFirst()
                .get();
        System.out.println(first); //结果输出：6

  •  toArray： 将流中的元素倒入一个数组

        Integer[] array = new Integer[]{1, 2, 3, 4, 5, 2, 4};
         Object[] a=Arrays.stream(array)
                .distinct()
                .toArray();     //将处理后的流元素重新导入一个数组中
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5]

---

▐ 结语：

       希望这篇关于java8中Stream流的介绍能对大家有所帮助，欢迎大佬们留言或私信与我交流~~学海漫浩浩,我亦苦作舟!大家一起学习,一起进步!

本人微信: g2279605572