Java中的Stream流

小例子证明Stream流的优势

减小代码量，增强了代码的阅读性。

//筛选姓戴并且名字为3个字的同学

        ArrayList<String> list = new ArrayList<>(List.of("戴狗蛋","戴超人","傅好好","戴爱傅","戴屁","傅傅"));

        //将姓戴的同学筛选出来
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list) {
            if(s.startsWith("戴")){
                list2.add(s);
            }
        }
        //将姓戴并且三个字的名字的同学筛选出来
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3){
                list3.add(s);
            }
        }
        System.out.println(list3);

        System.out.println("------------------------");
        //使用Stream流方式
        list.stream().filter(s->s.startsWith("戴"))
                .filter(s -> s.length() == 3)
                .forEach(s-> System.out.println(s));

Stream流思想特点：

流：流水线，类似流水线，一层一层筛选和过滤。

Stream流的三类方法：

• 获取方法：创建流水线，并将数据放到流水线上准备操作
• 中间方法：流水线上的操作，可以进行多次操作
• 终结方法：一个Stream流只能有一个

---

①Stream流的获取方法

Stream流的获取方法：（只有以下四种情况可以使用Stream流）

• 单列集合：集合对象.Stream();
• 双列集合：不能直接获取，需要间接获取
•                   集合对象.keySet().Stream();              
•                   集合对象.entrySet().Stream();
• 数组：Arrays.Stream(数组名);
• 同种数据类型的多个数据：Stream.of(数据1,2,3,4......);

Stream流的获取案例：

    public static void main(String[] args) {
        method1();
        method2();
        method3();
        method4();

    }

    private static void method4() {
        //同种数据类型的多个数据
        Stream.of(8,3,3,3,5,6).forEach(s-> System.out.println(s));
    }

    private static void method3() {
        //数组
        int[] arr= {1,2,3,4,5,6};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
    }

    private static void method2() {
        HashMap<String,String> hm = new HashMap<>();
        hm.put("001","a");
        hm.put("002","b");
        hm.put("003","c");
        hm.put("004","d");
        //通过获取键keySet->输出键
        hm.keySet().stream().forEach(s-> System.out.println(s));
        //通过entrySet获取键值对从而输出键和值
        hm.entrySet().stream().forEach(s-> System.out.println(s));
    }

    private static void method1() {
        ArrayList<String> list = new ArrayList<>(List.of("xd", "xf", "df"));
        list.add("xiaodai");
        list.stream().forEach(s -> System.out.println(s));
        System.out.println(list);
    }

---

②Stream流的中间方法

1. Stream<T> filter(Predicate predicate): 用于对流中的数据进行过滤Predicate接口中的方法
2. boolean test(T t):对给定的参数进行判断，返回一个布尔值

• filter方法可以进行数据的过滤
• 其中s依次表示流中的每一个数据
• s->后面的内容是过滤的条件（如果满足就留下，如果不满足就将其抛弃）

案例：

        ArrayList<String> list = new ArrayList<>(List.of("戴狗蛋","戴超人","傅好好","戴爱傅","戴屁","傅傅"));

//        method1(list);
//        method2(list);
        //最终简化结果
        list.stream().filter(s->s.startsWith("戴")).forEach(s-> System.out.println(s));


    }

    private static void method2(ArrayList<String> list) {
        //使用Lambda表达式
        list.stream().filter(
                (String s)->{
                    boolean result = s.startsWith("戴");
                    return result;
                }
        ).forEach(s-> System.out.println(s));
    }

    private static void method1(ArrayList<String> list) {
        //使用匿名内部类的形式
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean result = s.startsWith("戴");
                return result;
            }
        }).forEach(s-> System.out.println(s));
    }

其他中间方法：

Stream<T>limit(long maxSize):截取指定参数个数的数据
Stream<T>skip(longn): 跳过指定参数个数的数据
static<T> Stream<T>concat(Streama Stream b):合井a和b两个流为一个流
Stream<T>distinct0:去除流中重复的元素。依赖(hashCode和equals方法)

        ArrayList<String> list = new ArrayList<>();
        list.add("傅");
        list.add("X");
        list.add("Y");
        list.add("俺");
        list.add("耐");
        list.add("你");



        //只截取前两个数据
        list.stream().limit(3).forEach(s-> System.out.println(s));
        System.out.println("---------------------------------------------------");
        //跳过前三个数据
        list.stream().skip(3).forEach(s-> System.out.println(s));
        System.out.println("---------------------------------------------------");
        //合并集合数据
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("傅");
        list2.add("X");
        list2.add("Y");
        list2.add("俺");
        list2.add("耐");
        list2.add("你");

        Stream<String> stream1 = list.stream();
        Stream<String> stream2 = list2.stream();
        Stream.concat(stream1,stream2).forEach(s-> System.out.println(s));
        System.out.println("---------------------------------------------------");
        //消除重复数据
        ArrayList<String> list3 = new ArrayList<>();
        list3.add("傅");
        list3.add("X");
        list3.add("Y");
        list3.add("俺");
        list3.add("耐");
        list3.add("你");
        list3.add("你");
        list3.add("你");
        list3.add("你");
        list3.add("你");
        list3.stream().distinct().forEach(s-> System.out.println(s));

---

③Stream流的终结方法

• void forEach(Consumeraction): 对此流的每个元素执行操作Consumer接口中的方法
• void accept(Tt):对给定的参数执行此操作
• long count0:返回此流中的元素数

案例：

        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");

        //void forEach (Consumer action): 对此流的每个元素执行操作
        //Consumer接口中的方法 void accept (T t): 对给定的参数执行此操作
        //在forEach方法的底层，会循环获取到流中的每一个数据。
        //并循环调用accept方法，并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据。

        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        //最终简化后形式
        list.stream().forEach(s-> System.out.println(s));

        System.out.println("==========================");
        //返回此流中的元素个数
        long count = list.stream().count();
        System.out.println(count);
    }

注：在Stream流中只能更改到流中的数据，
无法直接修改集合，数组等数据源中的数据。

此时会出现问题：
如果使用Stream流操作后还想保存流中的数据，应该如何操作？

Stream流的收集方法
R collect(Collector collector)

工具类Collectors提供了具体的收集方式

• publicstatic <T> Collector toList0:把元素收集到List集合中
• publicstatic <T> Collector toSet0 : 把元素收集到Set集合中
• public static CollectortoMap(Function keyMapper,FunctionvalueMapper):把元素收集到Map集合中

例子：

        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.add(10);
        list.add(10);
        list.add(10);

//        list.stream().filter(num->num%2==0).forEach(s-> System.out.println(s));//获取集合中1-10的偶数
//        System.out.println(list);//但集合中的数据未被更改，只更改了流中的数据

        //创建一个List集合并把所有数据添加到List集合中
        List<Integer> ls = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
        System.out.println(ls);

        //List和Set最大区别：重复性
        Set<Integer> st = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toSet());
        System.out.println(st);