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());