Lấy sự khác biệt giữa hai bộ

Vì vậy, nếu tôi có hai bộ:

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

Có cách nào để so sánh chúng và chỉ có một bộ 4 và 5 được trả về không?

Thử cái này

test2.removeAll(test1);

Đặt # remove ALL

Xóa khỏi bộ này tất cả các thành phần của nó được chứa trong bộ sưu tập đã chỉ định (thao tác tùy chọn). Nếu bộ sưu tập được chỉ định cũng là một tập hợp, thao tác này sẽ sửa đổi hiệu quả bộ này sao cho giá trị của nó là chênh lệch tập không đối xứng của hai bộ.

Nếu bạn sử dụng thư viện Guava (Bộ sưu tập Google cũ), có một giải pháp:

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

Trả về SetViewlà một Set, nó là một đại diện trực tiếp mà bạn có thể thực hiện bất biến hoặc sao chép sang bộ khác. test1và test2được giữ nguyên.

Đúng:

test2.removeAll(test1)

Mặc dù điều này sẽ đột biến test2, vì vậy hãy tạo một bản sao nếu bạn cần bảo quản nó.

Ngoài ra, bạn có thể có nghĩa là <Integer>thay vì <int>.

Java 8

Chúng ta có thể sử dụng remove If trong đó có một biến vị ngữ để viết một phương thức tiện ích như:

// 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;
}

Và trong trường hợp chúng tôi vẫn ở một số phiên bản trước thì chúng tôi có thể sử dụng remove ALL như:

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;
}

Nếu bạn đang sử dụng Java 8, bạn có thể thử một cái gì đó như thế này:

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

Bạn có thể sử dụng CollectionUtils.disjunctionđể có được tất cả sự khác biệt hoặcCollectionUtils.subtract để có được sự khác biệt trong bộ sưu tập đầu tiên.

Đây là một ví dụ về cách làm điều đó:

    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), " , "));

Chỉ cần đặt một ví dụ ở đây (hệ thống đang ở trong existingStatevà chúng tôi muốn tìm các phần tử để loại bỏ (các phần tử không có trong newStatenhưng hiện diện existingState) và các phần tử để thêm (các phần tử có trong newStatenhưng không có trong 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);

  }
}

sẽ tạo ra kết quả này:

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