得出两组之间的差异

因此，如果我有两套：

Set<Integer> test1 = new HashSet<Integer>();
test1.add(1);
test1.add(2);
test1.add(3);

Set<Integer> test2 = new HashSet<Integer>();
test2.add(1);
test2.add(2);
test2.add(3);
test2.add(4);
test2.add(5);

有没有一种方法可以比较它们，并且只返回一组4和5？

试试这个

test2.removeAll(test1);

设置#removeAll

从该集合中删除所有包含在指定集合中的元素（可选操作）。如果指定的集合也是一个集合，则此操作将有效地修改此集合，以使其值为两个集合的非对称集合差异。

如果您使用Guava（以前的Google Collections）库，则有一个解决方案：

SetView<Number> difference = com.google.common.collect.Sets.difference(test2, test1);

返回的SetView是Set，它是实时表示，您可以将其设为不可变或复制到另一个集合。test1并test2保持原样。

是：

test2.removeAll(test1)

尽管这会发生变异test2，但如果需要保留副本，请创建一个副本。

另外，您可能<Integer>不是<int>。

Java 8

我们可以使用removeIf，它使用一个谓词将实用程序方法编写为：

// computes the difference without modifying the sets
public static <T> Set<T> differenceJava8(final Set<T> setOne, final Set<T> setTwo) {
     Set<T> result = new HashSet<T>(setOne);
     result.removeIf(setTwo::contains);
     return result;
}

如果我们仍旧使用某些早期版本，则可以将removeAll用作：

public static <T> Set<T> difference(final Set<T> setOne, final Set<T> setTwo) {
     Set<T> result = new HashSet<T>(setOne);
     result.removeAll(setTwo);
     return result;
}

如果您使用的是Java 8，则可以尝试执行以下操作：

public Set<Number> difference(final Set<Number> set1, final Set<Number> set2){
    final Set<Number> larger = set1.size() > set2.size() ? set1 : set2;
    final Set<Number> smaller = larger.equals(set1) ? set2 : set1;
    return larger.stream().filter(n -> !smaller.contains(n)).collect(Collectors.toSet());
}

您可以CollectionUtils.disjunction用来获取所有差异或CollectionUtils.subtract在第一个集合中获取差异。

这是如何执行此操作的示例：

    var collection1 = List.of(1, 2, 3, 4, 5);
    var collection2 = List.of(2, 3, 5, 6);
    System.out.println(StringUtils.join(collection1, " , "));
    System.out.println(StringUtils.join(collection2, " , "));
    System.out.println(StringUtils.join(CollectionUtils.subtract(collection1, collection2), " , "));
    System.out.println(StringUtils.join(CollectionUtils.retainAll(collection1, collection2), " , "));
    System.out.println(StringUtils.join(CollectionUtils.collate(collection1, collection2), " , "));
    System.out.println(StringUtils.join(CollectionUtils.disjunction(collection1, collection2), " , "));
    System.out.println(StringUtils.join(CollectionUtils.intersection(collection1, collection2), " , "));
    System.out.println(StringUtils.join(CollectionUtils.union(collection1, collection2), " , "));

仅在此处举一个示例（系统在中existingState，我们想找到要删除的元素（不在中newState但存在的existingState元素）和要添加的元素（在中newState但不存在的元素existingState）：

public class AddAndRemove {

  static Set<Integer> existingState = Set.of(1,2,3,4,5);
  static Set<Integer> newState = Set.of(0,5,2,11,3,99);

  public static void main(String[] args) {

    Set<Integer> add = new HashSet<>(newState);
    add.removeAll(existingState);

    System.out.println("Elements to add : " + add);

    Set<Integer> remove = new HashSet<>(existingState);
    remove.removeAll(newState);

    System.out.println("Elements to remove : " + remove);

  }
}

结果将输出：

Elements to add : [0, 99, 11]
Elements to remove : [1, 4]