Stream (四)之Collectors集合类常用方法

Stream (四)之Collectors集合类常用方法

package com.zy.stream.collect;

import com.zy.stream.model.Apple;
import com.zy.stream.model.Person;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Stream流中关于Collectors集合类中的相关方法，详解
 **/

public class StreamCollectTest {

 //实体类 
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
     class Apple {

        private String color;
        private Integer weight;


    }
  
    @Data
    @Builder(toBuilder = true)
    @AllArgsConstructor
    @NoArgsConstructor
     class Person {

        private String firstName, lastName, job, gender;
        private int salary,age;

    }


    List<Person> listPerson1= new ArrayList<Person>() {
        {
            add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 2000, 18));
            add(new Person("Tamsen", "Brittany", "Java programmer", "female", 2371, 55));
            add(new Person("Floyd", "Donny", "Java programmer", "male", 3322, 25));
            add(new Person("Sindy", "Jonie", "Java programmer", "female", 35020, 15));
            add(new Person("Vere", "Hervey", "Java programmer", "male", 2272, 25));
            add(new Person("Maude", "Jaimie", "Java programmer", "female", 2057, 870));
            add(new Person("testMaude", null, "Java programmer", "female", 2057, 870));
            add(new Person("Maude", "Jaimie", "Java programmer", "female", 2057, 87));
            add(new Person("Shawn", "Randall", "Java programmer", "male", 3120, 99));
            add(new Person("Jayden", "Corrina", "Java programmer", "female", 345, 25));
            add(new Person("Palmer", "Dene", "Java programmer", "male", 3375, 14));
            add(new Person("Addison", "Pam", "Java programmer", "female", 3426, 20));
        }
    };
    List<Person> listPerson2= new ArrayList<Person>() {
        {
            add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 2000, 18));
            add(new Person("Tamsen", "Brittany", "Java programmer", "female", 2371, 55));
            add(new Person("testFloyd", "Donny", "Java programmer", "male", 3322, 25));
            add(new Person("Sindy", "Jonie", "Java programmer", "female", 35020, 15));
            add(new Person("testVere", "Hervey", "Java programmer", "male", 2272, 25));
            add(new Person("Maude", "Jaimie", "Java programmer", "female", 2057, 87));
            add(new Person("testShawn", "Randall", "Java programmer", "male", 3120, 99));
            add(new Person("Jayden", "Corrina", "Java programmer", "female", 345, 25));
            add(new Person("testPalmer", "Dene", "Java programmer", "male", 3375, 14));
            add(new Person("Addison", "Pam", "Java programmer", "female", 3426, 20));
        }
    };


    @Test
    public void testAll(){

        List<Integer> collect = listPerson1.stream().map(Person::getSalary).collect(Collectors.toList());


        //交集 (list1 + list2)
        System.out.println("test=======交集[firstName中不含有test] ========>：");
        listPerson1.stream()
                    .filter(listPerson2::contains)
                    .collect(Collectors.toList())
                    .forEach(System.out::println);

        //差集 取差集是注意以那个集合为主
        System.out.println("test=======listPerson2差集[firstName中含有test] ========>：");
        listPerson2.stream()
                    .filter(e-> !listPerson1.contains(e))
                    .collect(Collectors.toList())
                    .forEach(System.out::println);

        //并集
        System.out.println("test=======并集[两个集合的所有元素] ========>：");
        List<Person> collect1 = listPerson1.parallelStream().collect(Collectors.toList());
        collect1.addAll(listPerson2.parallelStream().collect(Collectors.toList()));
        collect1.stream().forEach(System.out::println);
        System.out.println("test=======并集[两个集合的所有元素] 去重========>：");
        collect1.stream().distinct().forEach(System.out::println);


        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apple1",30);
        map.put("Apple2",20);
        map.put("Apple3",10);
        map.put("Apple6",51);
        map.put("Apple4",99);

        System.out.println("test=======Map集合转 List[注意数据类型]按照key值排序========>：");
        //Map集合转 List
        map.entrySet().stream().sorted(Comparator.comparing(e -> e.getKey()))
                .map(e -> new Apple(e.getKey(), e.getValue())).collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("test=======Map集合转 List[注意数据类型]按照value值排序========>：");
        map.entrySet()
                .stream()
                .sorted(Comparator.comparing(Map.Entry::getValue)).map(e -> new Apple(e.getKey(), e.getValue()))
                .collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("test=======Map集合转 List[注意数据类型]按照key值排序Entry.comparingByKey()========>：");
        map.entrySet()
            .stream()
            .sorted(Map.Entry.comparingByKey())
            .map(e -> new Apple(e.getKey(), e.getValue()))
            .collect(Collectors.toList())
            .forEach(System.out::println);


        //toList（）方法
        List<Integer> collectList = Stream.of(1, 2, 3, 4)
                .collect(Collectors.toList());
        System.out.println("test=======Collectors.toList()========》: " + collectList);



        HashMap<String, Object> objMap = new HashMap<>();
        //List转map集合    Collectors.toMap方法的第三个参数为键值重复处理策略，如果不传入第三个参数，当有相同的键时，会抛出一个IlleageStateException。
        System.out.println("test=======List元素对象转map集合[方式一]========>：");
        /*  toMap()参数一：key值，参数二：value值 参数三：当两个key值相同时，决定保留前一个value值还是后一个value值
             key为null    可以为null
            字典查询和数据转换 toMap时，如果value为null,会报空指针异常,需要校验
         */
        listPerson1.stream()
                .collect(Collectors.toMap(p -> p.getFirstName(), p -> Optional.ofNullable(p.getLastName()).orElse("value为null加非空检验"), (k1, k2) -> k1))
                .forEach(
                        (key, value) -> {
                        //map集合forEach（）循环时传两个参数，key，value值，
                        System.out.println("key: " + key + "    value: " + value);
                }
        );

        /*下面这种形式，通过方法的引用也可以去取重复的key，保证不抛出异常，但是只能保证出现的第一个key的数据（Map::putAll）
            key为null    可以为null
            value为null，不会报空指针异常
         */
        System.out.println("test=======List元素对象转map集合[方式二]========>：");
        listPerson1.stream()
                    .collect(HashMap::new,(maps,p)->maps.put(p.getFirstName(),p.getLastName()),Map::putAll)
                    .forEach(
                        (key, value) -> {
                            //map集合forEach（）循环时传两个参数，key，value值，
                            //如果value为null 打印：key: testMaude    value: null
                            System.out.println("++key: " + key + "    ++value: " + value);
                    }
        );
        System.out.println("test=======List元素对象转map集合[方式三]========>：");
        Stream<Apple> appleStream = Stream.of(new Apple("白色", 18),
                                            new Apple("红色", 180),
                                            new Apple("绿色", 187),
                                            new Apple("银色", 19));

        Map<String , Apple> appleMap = appleStream.collect(Collectors.toMap(Apple::getColor, i -> i));
        appleMap.forEach(
                (key, value) -> {
                    System.out.println("appleKey: " + key + "    appleValue: " + value);
                }
        );

        System.out.println("test========假设要得到按年龄分组的Map<Integer,List>：=======>：");
        Map<Integer, List<Person>> ageMap = listPerson1.stream().collect(Collectors.toMap(Person::getAge, Collections::singletonList, (a, b) -> {
            List<Person> resultList = new ArrayList<>(a);
            resultList.addAll(b);
            return resultList;
        }));
        ageMap.forEach(
                (key, value) -> {
                    System.out.println("ageKey: " + key + "   personValue: " + value);
                }
        );

        //List<String> 转String
        System.out.println("test========List<String> 转String使用Collectors.joining（）：=======>：");
        String str = Arrays.asList("voidcc.com", "voidmvn.com", "voidtool.com").stream().collect(Collectors.joining(","));
        System.out.println(str);

        //排序
        System.out.println("test=======排序sorted()========>：");
        //按照自然顺序进行排序 如果要自定义排序sorted 传入自定义的 Comparator
        listPerson1.stream().map(Person::getAge).sorted((x,y)->x.compareTo(y)).forEach(System.out::println);


        //比较
        System.out.println("test=======比较sorted()========>：");
        Comparator<Person> comparator = (p1, p2) -> p1.getFirstName().compareTo(p2.getFirstName());

        Person p1 = new Person("Addison", "Pam", "Java programmer", "female", 3426, 20);
        Person p2 = new Person("Addison", "Pam", "Java programmer", "female", 3426, 20);

        comparator.compare(p1, p2);             // > 0
        comparator.reversed().compare(p1, p2);  // < 0


        //分组
        System.out.println("test=======按照薪资分组Collectors.groupingBy（）=====返回map===>：");
        listPerson1.stream().collect(Collectors.groupingBy(Person::getSalary)).forEach(
                (key, value) -> {System.out.println("key: " + key + "    value: " + value);}
        );
        /*
         * groupingBy 分组后操作
                //Collectors中还提供了一些对分组后的元素进行downStream处理的方法：
                //counting方法返回所收集元素的总数；
                //summing方法会对元素求和；
                //maxBy和minBy会接受一个比较器，求最大值，最小值；
                //mapping函数会应用到downstream结果上，并需要和其他函数配合使用；
         */

        Map<Integer, Long> count = listPerson1.stream().collect(Collectors.groupingBy(Person::getSalary,Collectors.counting()));
        count.forEach((key, value) -> {System.out.println("counting方法返回所收集元素的总数:--->key: " + key + "    value: " + value);});

        Map<Integer, Integer> ageCount = listPerson1.stream().collect(Collectors.groupingBy(Person::getSalary,Collectors.summingInt(Person::getAge)));
        ageCount.forEach((key, value) -> {System.out.println("summing方法会对元素求和:--->key: " + key + "    value: " + value);});

        Map<Integer, Optional<Person>> ageMax =  listPerson1.stream().collect(Collectors.groupingBy(Person::getSalary,Collectors.maxBy(Comparator.comparing(Person::getAge))));
        ageMax.forEach((key, value) -> {System.out.println("maxBy和minBy会接受一个比较器，求最大值，最小值:--->key: " + key + "    value: " + value);});

        Map<Integer, List<String>> nameMap =  listPerson1.stream().collect(Collectors.groupingBy(Person::getSalary,Collectors.mapping(Person::getFirstName,Collectors.toList())));
        nameMap.forEach((key, value) -> {System.out.println("mapping函数会应用到downstream结果上，并需要和其他函数配合使用: " + key + "    value: " + value);});

        /*
         *1.    Collectors partitioningBy
         *      Collectors中还提供了partitioningBy方法，接受一个Predicate函数，该函数返回boolean值，用于将内容分为两组。
         *
         *2.    Collectors joining
         *      Collectors.joining 收集Stream中的值，该方法可以方便地将Stream得到一个字符串。joining函数接受三个参数，分别表示允（用以分隔元素）、前缀和后缀
         *
         *  Collectors分别提供了求平均值averaging、总数couting、最小值minBy、最大值maxBy、求和suming等操作。
         *  但是假如你希望将流中结果聚合为一个总和、平均值、最大值、最小值，
         *  那么Collectors.summarizing(Int/Long/Double)就是为你准备的，
         *  它可以一次行获取前面的所有结果，其返回值为(Int/Long/Double)SummaryStatistics。
         *
         *
         * 使用collect可以将Stream转换成值。maxBy和minBy允许用户按照某个特定的顺序生成一个值。
                averagingDouble:求平均值，Stream的元素类型为double
                averagingInt:求平均值，Stream的元素类型为int
                averagingLong:求平均值，Stream的元素类型为long
                counting:Stream的元素个数
                maxBy:在指定条件下的，Stream的最大元素
                minBy:在指定条件下的，Stream的最小元素
                reducing: reduce操作
                summarizingDouble:统计Stream的数据(double)状态，其中包括count，min，max，sum和平均。
                summarizingInt:统计Stream的数据(int)状态，其中包括count，min，max，sum和平均。
                summarizingLong:统计Stream的数据(long)状态，其中包括count，min，max，sum和平均。
                summingDouble:求和，Stream的元素类型为double
                summingInt:求和，Stream的元素类型为int
                summingLong:求和，Stream的元素类型为long
         *
         */


    }
}