List多种方式分组以及多Map之间的各种操作

//根据某个属性作为key分组到Map中
Map<String, List<实体>> personByGender = 集合.stream().collect(Collectors.groupingBy(实体::get属性));

//List<实体>根据某个属性作为key， 把另一个属性作为值，转换成  ---》Map<某属性， 某属性>
Map<String, String> map = 集合.stream().collect(Collectors.toMap(实体::get属性, 实体::get属性))

//List<实体>根据某个属性作为key， 把整个实体作为值(可能有多个相同相同属性值的实体，所以是List的值)，转换成  ---》Map<某属性， List<实体>>
Map<String, List<实体>> listMap = list.stream().collect(Collectors.groupingBy(实体::get属性));

//使用hutool工具把实体日期字段根据时间月份格式
Map<String, List<实体>> monthMap = list.stream().collect(Collectors.groupingBy(实体 -> cn.hutool.core.date.DateUtil.format(实体.getOrderTime(), "yyyy-MM")));


Map<String, 实体> map = new HashMap();
Map<String, 实体> map1 = new HashMap();
 
//Set set = new HashSet();
//set.addAll(map1.keySet());//把map中所有的key的集合放到nextSet中

Set set= new HashSet<>(map1.keySet()); //与前两行创建Set等同
map.keySet().removeAll(set);//map中删除map1中所有相同的key的数据

nextSet.forEach(k->{
	System.out.println("nextSet : " + k); //输出Set中所有的值
});

map.forEach((k,v) -> {
	System.out.println("key : " + k); //输出排除相同key之后的map
});

2. 两个简单List交集，并集，差集

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
//简单两个List<String> 交、并、差集
public class Show1Stream {
    /**
     * 简单类型的处理
     */
    public static void showSimpleDeal() {
        List<String> list1 = new ArrayList<>();
        list1.add("1111");
        list1.add("2222");
        list1.add("3333");

        List<String> list2 = new ArrayList<>();
        list2.add("3333");
        list2.add("4444");

        Set<String> list1Set = new HashSet<>(list1);

        Set<String> list2Set = new HashSet<>(list2);

        // 交集
        List<String> intersection = list1.stream().filter(list2Set::contains).collect(Collectors.toList());
        System.out.println("---得到交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(Collectors.toList());
        System.out.println("---得到差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(Collectors.toList());
        System.out.println("---得到差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
        List<String> listAll = list1.parallelStream().collect(Collectors.toList());
        List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
        listAll.addAll(listAll2);
        System.out.println("---得到并集 listAll---");
        listAll.parallelStream().forEach(System.out::println);

        // 去重并集
        list1Set.addAll(list2Set);
        List<String> listDistinctAll = new ArrayList<>(list1Set);
        System.out.println("---得到去重并集 listDistinctAll---");
        listDistinctAll.parallelStream().forEach(System.out::println);

        System.out.println("---原来的List1---");
        list1.parallelStream().forEach(System.out::println);
        System.out.println("---原来的List2---");
        list2.parallelStream().forEach(System.out::println);
    }


    public static void main(String[] args) {
        showSimpleDeal();
    }
}

3. 两个相同类型List 交集、并集、差集

import lombok.AllArgsConstructor;
import lombok.Data;

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

public class Show3Stream {
    public static void main(String[] args) {
        showObjectDeal();
    }

    /**
     * 对象类型的处理
     */
    public static void showObjectDeal() {
        List<User> list1 = new ArrayList<>();
        list1.add(new User("name1",11));
        list1.add(new User("name2",22));
        list1.add(new User("name3",33));
        list1.add(new User("name3",33));

        List<User> list2 = new ArrayList<>();
        list2.add(new User("name3",33));
        list2.add(new User("name4",44));

        Set<User> list1Set = new HashSet<>(list1);
        Set<User> list2Set = new HashSet<>(list2);

        // 交集
        List<User> intersection = list1.stream().filter(list2Set::contains).collect(Collectors.toList());
        System.out.println("---得到交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<User> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(Collectors.toList());
        System.out.println("---得到差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<User> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(Collectors.toList());
        System.out.println("---得到差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
        List<User> listAll = list1.parallelStream().collect(Collectors.toList());
        List<User> listAll2 = list2.parallelStream().collect(Collectors.toList());
        listAll.addAll(listAll2);
        System.out.println("---得到并集 listAll---");
        listAll.parallelStream().forEach(System.out::println);

        // 去重并集
        list1Set.addAll(list2Set);
        List<User> listDistinctAll = new ArrayList<>(list1Set);
        System.out.println("---得到去重并集 listDistinctAll---");
        listDistinctAll.parallelStream().forEach(System.out::println);

        System.out.println("---原来的List1---");
        list1.parallelStream().forEach(System.out::println);
        System.out.println("---原来的List2---");
        list2.parallelStream().forEach(System.out::println);

        //List去重
        List<User> userList = list1.stream() .collect(
                Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(user -> user.getName()))), ArrayList::new));
        System.out.println("---List去重---");
		
		userList.forEach(u-> System.out.println(u.getName()));
    }



    @AllArgsConstructor
    @Data
    public static class User{
        private String name;
        private int age;
    }
}