Stream转map排序，分组，求和等

1.Map求和可分为两种情况：

    1.不需要转换value的数据类型，直接可以相加 ；

    2.需要转换value的数据类型，转换之后再相加

代码如下：

public class MapMerge {
    public static void main(String[] args) {
        // 1.不需要转换value的数据类型，直接可以相加
        Map<String, BigDecimal> map1 = new HashMap<>();
        map1.put("a", new BigDecimal("1"));
        map1.put("b", new BigDecimal("2"));
        Map<String, BigDecimal> map2 = new HashMap<>();
        map2.put("a", new BigDecimal("1"));
        map2.put("b", new BigDecimal("2"));
        // 将map1加到map2中
        map1.forEach((key, value) -> map2.merge(key, value, BigDecimal::add));
 
        System.out.println("map2：" + map2);
 
        // 2.需要转换value的数据类型，转换之后再相加
        Map<String, Object> map3 = new HashMap<>();
        map3.put("a", "1");
        map3.put("b", "2");
        Map<String, Object> map4 = new HashMap<>();
        map4.put("a", "1");
        map4.put("b", "2");
        // 将map3加到map4中
        map3.forEach((key, value) -> map4.merge(key,value, (v1, v2) ->
                new BigDecimal(v1.toString()).add(new BigDecimal(v2.toString()))));
 
        System.out.println("map4：" + map4);
    }
}
运行结果：

map2：{a=2, b=4}
map4：{a=2, b=4}

2、map 对象本身，重复的key，放入List。

代码如下：

Map<String, List<Working>> map =
                workings.stream().collect(Collectors.toMap(Working::getInvoicePage,
                        e -> {
                            ArrayList<Working> list = new ArrayList<>();
                            list.add(e);
                            return list;
                        },
                        (oldList, newList) -> {
                            oldList.addAll(newList);
                            return oldList;
                        }));
		// 或者使用groupBy
		// 存为List
        Map<String, List<BusinessSceneDetail>> collect0 =
                sceneDetailMap.values().stream().collect(
                        Collectors.groupingBy(BusinessSceneDetail::getDataSourceCode));
        // 存为set
        Map<String, Set<BusinessSceneDetail>> collect =
                sceneDetailMap.values().stream().collect(
                        Collectors.groupingBy(BusinessSceneDetail::getDataSourceCode, Collectors.toSet()));
        // 多层map
        Map<String, Map<String, Set<BusinessSceneDetail>>> collect1 = sceneDetailMap.values().stream().collect(
                Collectors.groupingBy(BusinessSceneDetail::getDataSourceCode, Collectors.groupingBy
                        (BusinessSceneDetail::getBusinessSceneCode, Collectors.toSet())));
        // 对象子属性 map
        Map<String, List<String>> collect2 = sceneDetailMap.values().stream().collect(Collectors.groupingBy
                (BusinessSceneDetail::getDataSourceCode, Collectors.mapping(BusinessSceneDetail::getRuleContent,
                        Collectors.toList())));
        // 对象按照规则获取一个
        Map<String, BusinessSceneDetail> collect3 =
                sceneDetailMap.values().stream().collect(Collectors.groupingBy
                        (
                                BusinessSceneDetail::getDataSourceCode,
                                Collectors.collectingAndThen(
                                        Collectors.maxBy(Comparator.comparingInt(BusinessSceneDetail::getCreatorId)),
                                        Optional::get
                                )
                        ));

        // 对象按照规则获取一个里面的值 p肯定存在
        Map<String, String> collect4 = sceneDetailMap.values().stream().collect(Collectors.groupingBy
                (
                        BusinessSceneDetail::getDataSourceCode,
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparingInt(BusinessSceneDetail::getCreatorId)),
                                p -> p.get().getRuleContent()
                        )
                ));
                
        // map的value进行排序
           Map<String, List<SysDictionary>> map = sysDictionaryList.stream().collect(
                Collectors.groupingBy(
                        SysDictionary::getSysCode,
                        Collectors.collectingAndThen(
                                Collectors.toCollection(() -> new TreeSet<>((Comparator<Object>) (o1, o2) -> 0)),
                                ArrayList::new
                        )
                )
        );
        // map的key进行排序
 		Map<String, List<SysDictionary>> map1 = sysDictionaryList.stream().collect(
                Collectors.groupingBy(
                        SysDictionary::getSysCode,
                        TreeMap::new,
                        Collectors.toList()
                )
        );
        

3、map 对象本身，重复的key，替换内容。

groupBy其他用法参考 https://blog.csdn.net/u014231523/article/details/102535902
代码如下：

Map<String, Working> map =
                workings.stream().collect(Collectors.toMap(Working::getInvoicePage,
                Function.identity(),
                (oldWorking, newWorking) -> newWorking));

4、map 对象成员变量，重复的key，放入List。

代码如下：

Map<String, List<String>> map =
                workings.stream().collect(Collectors.toMap(Working::getInvoicePage,
                        e -> {
                            ArrayList<String> list = new ArrayList<>();
                            list.add(e.getStatus());
                            return list;
                        },
                        (oldList, newList) -> {
                            oldList.addAll(newList);
                            return oldList;
                        }));

5、map 对象成员变量，重复的key，替换。

代码如下：

Map<String, String> map =
                workings.stream().collect(Collectors.toMap(Working::getInvoicePage,
                        Working::getStatus,
                        (oldWorking, newWorking) -> newWorking));

6、带排序

代码如下：

TreeMap<String, List<Working>> collect =
                workings.stream().collect(Collectors.toMap(Working::getInvoicePage,
                        e -> {
                            ArrayList<Working> list = new ArrayList<>();
                            list.add(e);
                            return list;
                        },
                        (oldList, newList) -> {
                            oldList.addAll(newList);
                            return oldList;
                        },
                        () -> new TreeMap<>(Comparator.comparing(Integer::valueOf))));