Java List的交集、并集、差集、补集

一、List<String>与List<String>形式

　　1. 测试数据

// A系统账号
List<String> accountList1 = Arrays.asList("11111111111", "22222222222", "33333333333", "44444444444", "77777777777");
// B系统账号
List<String> accountList2 = Arrays.asList("55555555555", "11111111111", "22222222222", "66666666666");

　　2. 交集

// 账号交集
List<String> intersectionAccount = accountList1.stream().filter(accountList2::contains).collect(Collectors.toList());
System.out.println("交集:" + intersectionAccount.toString());

　　3. 去重并集

// 账号去重并集
List<String> deduplicationUnionAccount = Stream.of(accountList1, accountList2).flatMap(List::stream).distinct().collect(Collectors.toList());
System.out.println("去重并集:" + deduplicationUnionAccount.toString());

　　4. 差集

// A系统账号账号差集(accountList1 - accountList2)
List<String> subtractionAccount1 = accountList1.stream().filter(account -> !accountList2.contains(account)).collect(Collectors.toList());
System.out.println("A系统账号差集:" + subtractionAccount1.toString());

// B系统账号差集(accountList2 - accountList1)
List<String> subtractionAccount2 = accountList2.stream().filter(account -> !accountList1.contains(account)).collect(Collectors.toList());
System.out.println("B系统账号差集:" + subtractionAccount2.toString());

 　　5. 补集

// 账号去重并集
List<String> deduplicationUnionAccount = Stream.of(accountList1, accountList2).flatMap(List::stream).distinct().collect(Collectors.toList());
// 账号交集
List<String> intersectionAccount = accountList1.stream().filter(accountList2::contains).collect(Collectors.toList());
// 账号补集(并集-交集)
List<String> complementAccount = deduplicationUnionAccount.stream().filter(account -> !intersectionAccount.contains(account)).collect(Collectors.toList());
System.out.println("补集：" + complementAccount.toString());

 

二、List<User>与List<User>形式，以其中一个字段作为比较对象

　　A. 测试数据

// A系统账号
List<User> user1List = Arrays.asList(new User(1L, "11111111111", "张三"), new User(2L, "22222222222", "李四"), new User(3L, "33333333333", "王五"), new User(4L, "44444444444", "小六"));
// B系统账号
List<User> user2List = Arrays.asList(new User(5L, "55555555555", "谢凡"), new User(6L, "11111111111", "归一"), new User(7L, "66666666666", "知了"));

　　B. 交集

// A系统账号交集(以account为主)
List<String> user2AccountList = user2List.stream().map(User::getAccount).collect(Collectors.toList());
List<User> intersectionUser1List = user1List.stream().filter(user -> user2AccountList.contains(user.getAccount())).collect(Collectors.toList());
System.out.println("A系统账号差集:" + intersectionUser1List.toString());

// B系统账号交集(以account为主)
List<String> user1AccountList = user1List.stream().map(User::getAccount).collect(Collectors.toList());
List<User> intersectionUser2List = user2List.stream().filter(user -> user1AccountList.contains(user.getAccount())).collect(Collectors.toList());
System.out.println("B系统账号差集:" + intersectionUser2List.toString());

　　C. 并集

// 账号并集
List<User> unionUserList = Stream.of(user1List, user2List).flatMap(List::stream).collect(Collectors.toList());
System.out.println("并集:" + unionUserList.toString());

　　D. 差集

// A系统账号差集(user1List - user2List)
List<String> user2AccountList = user2List.stream().map(User::getAccount).collect(Collectors.toList());
List<User> subtractionUser1List = user1List.stream().filter(user -> !user2AccountList.contains(user.getAccount())).collect(Collectors.toList());
System.out.println("A系统账号差集:" + subtractionUser1List.toString());

// B系统账号差集(user2List - user1List)
List<String> user1AccountList = user1List.stream().map(User::getAccount).collect(Collectors.toList());
List<User> subtractionUser2List = user2List.stream().filter(user -> !user1AccountList.contains(user.getAccount())).collect(Collectors.toList());
System.out.println("B系统账号差集:" + subtractionUser2List.toString());