Stream 相关的使用

说实话现在 写stream 这博客有点 low 因为现在的jdk 已经更新到11这样了，而stream 却是在 jdk8的时候被标注为新特性，说实话习惯了 思维的定势，但是好东西还是应该被拿出来分享，况且 stream的使用加速了代码的创造。

Stream 的简述：

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
特点：
         1 .不是数据结构，不会保存数据。
         2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（
         保留意见：毕竟peek方法可以修改流中元素）
         3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，
         需要等到执行终止操作的时候才会进行实际的计算。
 咱们就开始一些具体的操作吧，jdk8有对应的说明文档

filter：过滤流中的某些元素
limit(n)：获取n个元素
skip(n)：跳过n元素，配合limit(n)可实现分页
distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：定制排序，自定义Comparator排序器  
peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，
allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false

noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
findFirst：返回流中第一个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最大值
min：返回流中元素最小值

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        boolean allMatch = list.stream().allMatch(e -> e > 10); //false
        boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
        boolean anyMatch = list.stream().anyMatch(e -> e > 4);  //true

        Integer findFirst = list.stream().findFirst().get(); //1
        Integer findAny = list.stream().findAny().get(); //1

        long count = list.stream().count(); //5
        Integer max = list.stream().max(Integer::compareTo).get(); //5
        Integer min = list.stream().min(Integer::compareTo).get(); //1
        System.out.println("--"+allMatch+"----"+"noneMatch:"+noneMatch+"----"+"anyMatch:"+anyMatch+"----"+"findFirst:"+"----"+findFirst+"----"+"findAny:"+"----"+findAny+"----"
                +"count:"+"----"+count+"----"
                +"max:"+"----"+max+"----"+"min"+"----"+min);

Collector 相关操作

 Student s1 = new Student("aa", 10, 1);
        Student s2 = new Student("bb", 20, 2);
        Student s3 = new Student("cc", 10, 3);
        List<Student> list = Arrays.asList(s1, s2, s3);

        //装成list
        List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList()); // [10, 20, 10]
        ageList.forEach(System.out::println);
        //转成set
        Set<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 10]
        ageSet.forEach(System.out::println);
        //转成map,注:key不能相同，否则报错
        Map<String, Integer> studentMap = list.stream().collect(Collectors.toMap(Student::getName, Student::getAge)); // {cc=10, bb=20, aa=10}

        //字符串分隔符连接
        String joinName = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)

       //聚合操作
       //1.学生总数
        Long count = list.stream().collect(Collectors.counting()); // 3
       //2.最大年龄 (最小的minBy同理)
        Integer maxAge = list.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get(); // 20
       //3.所有人的年龄
        Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40
       //4.平均年龄
        Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334
       // 带上以上所有方法
        DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
        System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());

       //分组
        Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
       //多重分组,先根据类型分再根据年龄分
        Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getType, Collectors.groupingBy(Student::getAge)));

       //分区
       //分成两部分，一部分大于10岁，一部分小于等于10岁
        Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));

       //规约
        Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40

交集/并集

 //库里面数据
 List<Integer> integerList= list.stream().map(对象::get对象属性).collect(Collectors.toList());
//传参数据
 List<Integer> typeList = Arrays.asList(typeIds);

 // 差集 (integerList - typeList) 
 List<Integer> reduce1 = integerList.stream().filter(item -> !typeList.contains(item)).collect(Collectors.toList());

 // 差集 (typeList - integerList) 
 List<Integer> reduce2 = typeList.stream().filter(item -> !integerList.contains(item)).collect(Collectors.toList());
 
//交集
List<String> intersection = integerList.stream().filter(item -> typeList .contains(item)).collect(toList());

//并集就是普通的add  

//去重并集

List<String> listAllDistinct = intersection.stream().distinct().collect(toList());

大概使用到的就这些