什么是并集/交集/差集 ？
- 并集
对于两个给定集合A、B，由两个集合所有元素构成的集合，叫做A和B的并集。
记作：AUB 读作“A并B”
例： {3,5}U{2,3,4,6}= {2,3,4,5,6} - 交集
对于两个给定集合A、B，由属于A又属于B的所有元素构成的集合，叫做A和B的交集。
记作： A∩B 读作“A交B”
例： A={1,2,3,4,5}，B={3,4,5,6,8}，A∩B={3,4,5} - 差集
记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B(或集合A与集合B之差)，类似地，对于集合A、B，把集合{x∣x∈A,且x∉B}叫做A与B的差集。
记作：B-A
JAVA8处理
数组集合：此处省略获取数据赋值过程（实际情况根据自己的需求变更即可）
List<String> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
// 交集
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
System.out.println("---交集 intersection---");
intersection.parallelStream().forEach(System.out::println);
// 差集 (list1 - list2)
List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
System.out.println("---差集 reduce1 (list1 - list2)---");
reduce1.parallelStream().forEach(System.out::println);
// 差集 (list2 - list1)
List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
System.out.println("---差集 reduce2 (list2 - list1)---");
reduce2.parallelStream().forEach(System.out::println);
// 并集
List<String> listAll = list1.parallelStream().collect(toList());
List<String> listAll2 = list2.parallelStream().collect(toList());
listAll.addAll(listAll2);
System.out.println("---并集 listAll---");
listAll.parallelStream().forEachOrdered(System.out::println);
// 去重并集
List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
System.out.println("---得到去重并集 listAllDistinct---");
listAllDistinct.parallelStream().forEachOrdered(System.out::println);
对象集合：此处省略获取数据赋值过程（tips：此处举例为User对象，user.getUsername()为对象属性 / 实际情况根据自己的需求变更即可）
List<User> list1=new ArrayList<>();
List<User> list2=new ArrayList<>();
// 计算并集
list1.addAll(list2); // 先合体
List<User> list3 = list1.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(
() -> new TreeSet<>(Comparator.comparing(User::getUsername))), ArrayList::new)); // 再去重
// 计算交集
List<User> list4=list1.stream().filter(item->
list2.stream().map(e -> e.getUsername())
.collect(Collectors.toList()).contains(item.getUsername())).collect(Collectors.toList());
// 计算差集 谁在前面就获取的谁差集的部分（以下为获取list1中有，但list2没有的数据， 反之可取list2有，但list1没有的数据）
List<User> list5=list1.stream().filter(item ->
!list2.stream().map(e -> e.getUsername())
.collect(Collectors.toList()).contains(item.getUsername())).collect(Collectors.toList());
JS处理
以下操作针对数组集合，如果集合为对象集合,需要在函数后面追加一个参数（对象属性名）,并修订其函数。（实际情况根据自己的需求变更即可）
function array_remove_repeat(a) { // 去重
var r = [];
for(var i = 0; i < a.length; i ++) {
var flag = true;
var temp = a[i];
for(var j = 0; j < r.length; j ++) {
if(temp === r[j]) {
flag = false;
break;
}
}
if(flag) {
r.push(temp);
}
}
return r;
}
function array_intersection(a, b) { // 交集
var result = [];
for(var i = 0; i < b.length; i ++) {
var temp = b[i];
for(var j = 0; j < a.length; j ++) {
if(temp === a[j]) {
result.push(temp);
break;
}
}
}
return array_remove_repeat(result);
}
function array_union(a, b) { // 并集
return array_remove_repeat(a.concat(b));
}
function array_difference(a, b) { // 差集 a - b
//clone = a
var clone = a.slice(0);
for(var i = 0; i < b.length; i ++) {
var temp = b[i];
for(var j = 0; j < clone.length; j ++) {
if(temp === clone[j]) {
//remove clone[j]
clone.splice(j,1);
}
}
}
return array_remove_repeat(clone);
}