Collectors常用方法

import org.junit.Test;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author W
 * @date 2022/4/18
 */
public class StreamTest {
    /**
     * 返回List集合
     * toList
     */
    @Test
    public void stream1(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        List<Integer> collect = integers.stream().map(x -> x * x).collect(Collectors.toList());
        System.out.println(collect);
    }
    /**
     * 返回Set集合
     * toSet
     */
    @Test
    public void stream3(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        Set<Integer> collect = integers.stream().filter(value -> value > 2).collect(Collectors.toSet());
        System.out.println(collect);
    }

    /**
     * counting
     * 计算元素数量
     */
    @Test
    public void stream4(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        Long collect = integers.stream().collect(Collectors.counting());
        System.out.println(collect);
        System.out.println(integers);
    }

    /**
     * maxBy
     * 取最大值【naturalOrder自然排序】
     */
    @Test
    public void stream5(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        Integer integer = integers.stream().collect(Collectors.maxBy(Comparator.naturalOrder())).get();
        System.out.println(integer);
        System.out.println(integers);
    }
    /**
     * minBy
     * 取最小值【naturalOrder自然排序】
     */
    @Test
    public void stream6(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        Integer integer = integers.stream().collect(Collectors.minBy(Comparator.naturalOrder())).get();
        System.out.println(integer);
        System.out.println(integers);
    }

    /**
     * partitioningBy
     * 用于将一个集合划分为2个集合并将其添加到映射中集合中，
     * 满足给定条件的划分一个集合，并以true为key
     * 不满足给定条件的划分一个集合，并以false为key
     */
    @Test
    public void stream7(){
        List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6);
        System.out.println(integers);
        Map<Boolean, List<Integer>> collect = integers.stream().collect(Collectors.partitioningBy(v -> (int) v > 3));
        System.out.println(collect);
        System.out.println(integers);
    }

    /**
     * joining
     * 连用指定的字符串连接集合内的元素
     * 结合内元素须为String类型
     */
    @Test
    public void stream8(){
        List<String> integers = Arrays.asList("1","2");
        String collect = integers.stream().collect(Collectors.joining(","));
        System.out.println(collect);
        //用指定的字符串连接集合内的元素，并在首尾加上指定字符
        String collect2 = integers.stream().collect(Collectors.joining(",","《","》"));
        System.out.println(collect2);
        //用指定的字符串连接int类型集合内的元素
        List<Integer> integers3 = Arrays.asList(1,1);
        String collect3 = integers3.stream().map(a-> String.valueOf(a) ).collect(Collectors.joining(","));
        System.out.println(collect3);
    }

    /**
     * 集合的平均值
     * averagingLong
     * averagingInt
     * averagingDouble
     */
    @Test
    public void stream9(){
        //long类型求平均值
        List<Long> longValues = Arrays.asList(100l,200l,300l);
        Double d1 = longValues
                .stream()
                .collect(Collectors.averagingLong(x -> x * 2));
        System.out.println("long类型求平均值:"+d1);
        //int类型求平均值
        List<Integer> intValues = Arrays.asList(12,30,45);
        Double d2 = intValues
                .stream()
                .collect(Collectors.averagingInt(x->x));
        System.out.println("int类型求平均值:"+d2);
        //double类型求平均值
        List<Double> doubleValues = Arrays.asList(1.1,2.0,3.0,4.0,5.0,5.0);
        Double d3 = doubleValues
                .stream()
                .collect(Collectors.averagingDouble(x->x));
        System.out.println("double类型求平均值:"+d3);
    }

    /**
     * 求和
     * summingLong
     * summingInt
     * summingDouble
     */
    @Test
    public void stream10(){
        //long类型求平均值
        List<Long> longValues = Arrays.asList(100l,200l,300l);
        Long d1 = longValues
                .stream()
                .collect(Collectors.summingLong(x -> x));
        System.out.println("long类型求和:"+d1);
        //int类型求平均值
        List<Integer> intValues = Arrays.asList(12,30,45);
        Integer d2 = intValues
                .stream()
                .collect(Collectors.summingInt(x->x));
        System.out.println("int类型求和:"+d2);
        //double类型求平均值
        List<Double> doubleValues = Arrays.asList(1.1,2.0,3.0,4.0,5.0,5.0);
        Double d3 = doubleValues
                .stream()
                .collect(Collectors.summingDouble(x->x));
        System.out.println("double类型求求和:"+d3);
    }

    /**
     * 汇总整数
     * 得到平均值、最小值、最大值、所有值的计数和总和。
     */
    @Test
    public void stream11(){
        List<Integer> intValues = Arrays.asList(12,30,45);
        IntSummaryStatistics collect = intValues
                .stream()
                .collect(Collectors.summarizingInt(x -> x));
        System.out.println(collect);
    }

    /**
     *
     * 创建Map
     * toMap
     * Function.identity()指向集合中的值
     */
    @Test
    public void stream12(){
        List<String> integers = Arrays.asList("dsf","sfsf");
        Map<String, Integer> collect = integers.stream().collect(Collectors.toMap(item -> item, String::length));
        System.out.println(collect);
        Map<String, Integer> collect2 = integers.stream().collect(Collectors.toMap(Function.identity(), String::length));
        System.out.println(collect2);
        //去重创建map【map中key唯一，不可重复】
        List<String> strings = Arrays.asList("dsf","sfsf","ggfdd","sfsf");
        Map<String, Integer> collect3 = strings.stream().collect(Collectors.toMap(item -> item, String::length,(i1,i2)->i1));
        System.out.println(collect3);
    }
 	/**
     * 分组函数
     * GroupingBy
     */
    @Test
    public void stream13(){
        //分组
        List<String> strings = Arrays.asList("alpha","beta","gamma");
        final Map<Integer, List<String>> collect = strings.stream().collect(Collectors.groupingBy(String::length));
        System.out.println(collect);
        //分组求和
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map =  new HashMap<>();
        map.put("name","张三");
        map.put("money","25");
        Map<String, String> map2 =  new HashMap<>();
        map2.put("name","张四");
        map2.put("money","50");
        Map<String, String> map3 =  new HashMap<>();
        map3.put("name","张三");
        map3.put("money","30");
        list.add(map);
        list.add(map2);
        list.add(map3);
        Map<String, Integer> name = list.stream().collect(Collectors.groupingBy(item -> item.get("name"), Collectors.summingInt(item -> Integer.parseInt(item.get("money")))));
        System.out.println(name);
    }

}