Stream流

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作

1.创建流

        //方法一.Collection.stream() 方法用集合创建流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        HashSet<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        HashMap<String, String> map = new HashMap<>();
        Stream<String> stream3 = map.keySet().stream();
        Stream<String> stream4 = map.values().stream();
        Stream<Map.Entry<String, String>> stream5 = map.entrySet().stream();

        //方法二.Arrays.stream(T[] array)方法用数组创建流
        String[] array={"aa","bb","cc"};//注意：基本数据类型的数组会将整个数组看做一个元素进行操作
        Stream<String> stream6 = Arrays.stream(array);

        //方法三.stream中的静态方法of获取流
        Stream<String> stream7 = Stream.of("aa", "bb", "cc");

        String[] strings={"aa","bb","cc"};
        Stream<String> stream8 = Stream.of(strings);

2.stream流常用方法
注意：一个流只能操作一遍

数据：

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"如来佛主","猪八戒","孙悟空","沙僧","唐僧");

forEach方法

        list.stream().forEach((String str)->{
            System.out.println(str);
        });
        //简化Lambda
        list.stream().forEach(str-> System.out.println(str) );
        //再简化，转化为方法引用
        list.stream().forEach(System.out::println);

count方法

        long count = list.stream().count();
        System.out.println(count);

filter方法

 //得到名字长度为3的人
        list.stream().filter((String s)->{
            return s.length()==3;
        }).forEach(System.out::println);
        //简化lambda表达式
        list.stream().filter(s->s.length()==3).forEach(System.out::println);

limit方法

list.stream().limit(3).forEach(System.out::println);//获取前三个

skip方法

list.stream().skip(2).forEach(System.out::println);//跳过前两个

map方法：将一种类型的流转化为另一种类型的流

        Stream<String> stream = Stream.of("11", "12", "13");
       stream.map((String s)->{
            return Integer.parseInt(s);
        }).forEach(System.out::println);
        //简化lambda
        stream.map(s->(Integer.parseInt(s))).forEach(System.out::println);
        //再简化
        stream.map(Integer::parseInt).forEach(System.out::println);

sorted方法

Stream<Integer> stream2 = Stream.of(12, 11, 16);
        //默认排序规则，升序
        stream2.sorted().forEach(System.out::println);
        //指定排序规则，指定降序
        Stream<Integer> stream3 = Stream.of(12, 11, 16);
/*        stream3.sorted((Integer i1,Integer i2)->{
            return i2-i1;
        }).forEach(System.out::println);*/
        //简化
        stream3.sorted((i1,i2)->i2-i1).forEach(System.out::println);

distinct方法：去除重复
注意：自定义对象去除重复需重写equals方法和hashCode方法

        Stream<Integer> stream4 = Stream.of(12,16, 11, 16);
        stream4.distinct().forEach(System.out::println);

match方法

        Stream<Integer> stream5 = Stream.of(12, 11, 16);
        //boolean b1 = stream5.allMatch(i -> i > 0);//所有元素都满足田间
        //boolean b2 = stream5.anyMatch(i -> i > 12);//只要有一个元素满足条件
        boolean b3 = stream5.noneMatch(i -> i < 0);//所有元素都不满足条件

find方法:找到第一个元素

        Stream<Integer> stream6 = Stream.of(12, 11, 16);
        Optional<Integer> optional = stream6.findFirst();
        //Optional<Integer> optional1 = stream5.findAny();
        System.out.println(optional.get());

min,max方法

        Stream<Integer> stream7 = Stream.of(12, 11, 16);
/*        Optional<Integer> max = stream7.max((i1, i2) -> i1 - i2);
        System.out.println("max = " + max.get());*/
        Optional<Integer> min = stream7.min((i1, i2) -> i1 - i2);
        System.out.println("min = " + min.get());

reduce方法：将所有数据归纳得到一个数据

        //举例一：求和
        Stream<Integer> stream8 = Stream.of(12, 11, 16);
        int reduce = stream8.reduce(0, (x, y) -> {
            return x + y;
        });
        System.out.println("reduce = " + reduce);
        //举例二：求最大值
/*        int reduce2 = stream8.reduce(0, (x, y) -> {
            return x > y ? x : y;
        });
        System.out.println("reduce2 = " + reduce2);*/

concat方法：合并为一个流

        Stream<Integer> streamA = Stream.of(1, 2);
        Stream<Integer> streamB = Stream.of(3, 4);
        Stream.concat(streamA, streamB).forEach(System.out::println);