一、Stream流介绍

        stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。
        同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是 惰性取值 ，只有等到用户真正需要结果的时候才会执行。 并且对于现在调用的方法，本身都是一种高层次构件，与线程模型无关。因此在并行使用中，开发者们无需再去操 心线程和锁了。Stream内部都已经做好了 。
        关于对Stream流的理解，你可以把他当成工厂中的流水线，每个stream流的操作过程遵循着创建 -->操作 -->获取结果的过程，就像流水线上的节点一样组成一个个链条。除此之外你还可以把他理解成sql的视图，集合就相当于数据表中的数据，获取stream流的过程就是确定数据表的属性和元数据的过程，元数据的每一个元素就是表中的数据，对stream流进行操作的过程就是通过sql对这些数据进行查找、过滤、组合、计算、操作、分组等过程，获取结果就是sql执行完毕之后获取的结果视图一样，深入理解stream流可以让我们使用更加简洁的代码获取自己想要的数据。

二、Stream流的基本用法

 List<String> strList = Arrays.asList("1", "2", "3", "4", "5","5","4");
        System.out.println(strList);

        //过滤
        List<String> filter = strList.stream().filter(s -> 
        s.equals("3")||s.equals("4")).collect(Collectors.toList());
        System.out.println(filter);

        //去重
        List<String> distinct = strList.stream().distinct().collect(Collectors.toList());
        System.out.println(distinct);

        //获取第一个元素
        String any = strList.stream().findAny().get();
        String first = strList.stream().findFirst().get();

        System.out.println(any);
        System.out.println(first);
        //此方法值不确定
        for (int i = 0; i < 100; i++) {
            String findAny = strList.parallelStream().findAny().get();
            System.out.println(findAny);
        }

        //获取最长的字符串
        List<String> stringList = Arrays.asList("xiao", "xiaobu", "xiaobudian");
        Optional<String> max = stringList.stream().max(Comparator.comparing(String::length));
        System.out.println(max);

        //获取最短的字符串
        Optional<String> strMin = stringList.stream().min(Comparator.comparing(String::length));
        System.out.println(strMin);
        Optional<String> min = stringList.stream().min(String::compareToIgnoreCase);
        System.out.println(min);

        //获取int最大值
        List<Integer> integers = Arrays.asList(1, 2, 3, 6, 51, 45);
        Optional<Integer> integerMax = integers.stream().max(Integer::compareTo);
        System.out.println(integerMax);

        //获取int最小值
        Optional<Integer> minInt = integers.stream().min(Comparator.comparingInt(Integer::shortValue));
        Optional<Integer> minInt1 = integers.stream().min(Comparator.comparing(Integer::intValue));
        System.out.println(minInt);
        System.out.println(minInt1);

三、Stream流的对象值比较

        //对象值比较
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("小明",15));
        personList.add(new Person("大强",18));
        personList.add(new Person("小泽玛利亚",22));
        //获取名字最长的对象
        Person person = personList.stream().max(Comparator.comparing(Person::getName)).get();
        System.out.println(person);
        //获取年龄最小的
        Person person1 = personList.stream().min(Comparator.comparing(Person::getAge)).get();
        System.out.println(person1);

四、Stream流的缩减

        List<Integer> integerList = Arrays.asList(1, 2, 3, 6, 51, 45);
        //求和
        Integer reduce = integerList.stream().reduce(0,Integer::sum);
        System.out.println(reduce);
        //在求和的值上加10
        Integer reduce1 = integerList.stream().reduce(10,Integer::sum);
        System.out.println(reduce1);

        //其他写法
        Integer reduce2 = integerList.stream().reduce(10, (x, y) -> x + y);
        System.out.println(reduce2);
        //相乘并乘10
        Integer reduce3 = integerList.stream().reduce(10, (x, y) -> x * y);
        System.out.println(reduce3);

        //求最大值
        Optional<Integer> reduce4 = integerList.stream().reduce(Integer::max);
        System.out.println(reduce4);


        List<Person> personList = new ArrayList<>();
        personList.add(new Person("小明",15));
        personList.add(new Person("小泽玛利亚",22));
        personList.add(new Person("大强",18));
        personList.add(new Person("光头强",12));
        //对象中求年龄的和
        Optional<Integer> ageSum = personList.stream().map(p -> p.getAge()).reduce(Integer::sum);
        System.out.println(ageSum);
        //对象中年龄最大的
        Optional<Integer> reduce5 = personList.stream().map(p -> p.getAge()).reduce(Integer::max);
        personList.stream().max(Comparator.comparing(Person::getAge));
        //对比后获得年龄最大的对象
        Person person = personList.stream().reduce((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2).get();
        System.out.println(person);
        System.out.println(reduce5);

五、Stream流的Collect用法

 List<Person> personList = new ArrayList<>(4);
        personList.add(new Person("小明",15));
        personList.add(new Person("小明",18));
        personList.add(new Person("小明",18));
        personList.add(new Person("小泽玛利亚",22));
        personList.add(new Person("大强",18));
        personList.add(new Person("光头强",12));
        // 获取平均年龄 averaging
        Double avg = personList.stream().collect(Collectors.averagingInt(Person::getAge));
        System.out.println(avg);
        //同时计算长度 和 最大值 最小值 平均值
        DoubleSummaryStatistics doubleCollect = personList.stream().collect(Collectors.summarizingDouble(Person::getAge));
        System.out.println(doubleCollect);

        //获取姓名组合为字符串，以,分割
        String pName = personList.stream().map(Person::getName).collect(Collectors.joining(","));
        System.out.println(pName);

        //求年龄的和
        Integer sum = personList.stream().map(Person::getAge).reduce(0, (x, y) -> x + y);
        Integer sum1 = personList.stream().map(Person::getAge).reduce(Integer::sum).get();
        System.out.println(sum);
        System.out.println(sum1);

        //分组
        //以名字进行分组
        Map<String, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(Person::getName));
        System.out.println(collect);

        //先以名字分组，再以年龄分组
        Map<String, Map<Integer, List<Person>>> collect1
                = personList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getAge)));
        System.out.println(collect1);

        // toList、toSet、toMap
        List<Person> collect2 = personList.stream().collect(Collectors.toList());
        System.out.println(collect2);

六、Stream流的映射

 //转换为大写
        String[] strArr = { "abcd", "bcdd", "defde", "ftr" };
        Arrays.stream(strArr).map(String::toUpperCase).forEach(System.out::print);
        //转化list
        List<String> collect = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(collect);

七、Stream流的排序

        //自然排序并转换为list
        String[] strArr = { "ab", "bcdd", "defde", "ftr" };
        List<String> collect = Arrays.stream(strArr).sorted().collect(Collectors.toList());
        System.out.println(collect);
        //自定义排序
        // 按照字符串的长度 从小到大
        List<String> collect1 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length)).collect(Collectors.toList());
        System.out.println(collect1);
        //倒序
        List<String> collect2 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());
        System.out.println(collect2);

        // 首字母倒序
        List<String> collect3 = Arrays.stream(strArr).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println(collect3);

        List<String> collect4 = Arrays.stream(strArr).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        System.out.println(collect4);

八、Stream流的提取流和组合流

 String[] arr1 = {"a","b","c","d"};
        String[] arr2 = {"d","e","f","g"};
        String[] arr3 = {"i","j","k","l"};

        Stream<String> stream1 = Arrays.stream(arr1);
        Stream<String> stream2 = Arrays.stream(arr2);
        Stream<String> stream3 = Arrays.stream(arr3);

        //合并去重
        List<String> collect = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        System.out.println(collect);


        // limit，限制从流中获得前n个数据
        List<String> collect1 = collect.stream().limit(3).collect(Collectors.toList());
        System.out.println(collect1);

        // skip，跳过前n个数据
        List<String> collect2 = collect.stream().skip(3).collect(Collectors.toList());
        System.out.println(collect2);