Ottenere la differenza tra due set

Quindi se ho due set:

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'è un modo per confrontarli e restituire solo un set di 4 e 5?

Prova questo

test2.removeAll(test1);

Set # removeAll

Rimuove da questo set tutti i suoi elementi contenuti nella raccolta specificata (operazione opzionale). Se anche la raccolta specificata è un set, questa operazione modifica efficacemente questo set in modo che il suo valore sia la differenza del set asimmetrico dei due set.

Se usi la libreria Guava (ex Google Collections) c'è una soluzione:

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

Il reso SetViewè a Set, è una rappresentazione dal vivo che puoi rendere immutabile o copiare su un altro set. test1e test2rimangono intatti.

Sì:

test2.removeAll(test1)

Anche se questo cambierà test2, quindi creane una copia se devi conservarlo.

Inoltre, probabilmente intendevi <Integer>invece di <int>.

Java 8

Possiamo usare removeIf che richiede un predicato per scrivere un metodo di utilità come:

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

E nel caso in cui siamo ancora in una versione precedente, possiamo usare removeAll come:

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

Se stai usando Java 8, potresti provare qualcosa del genere:

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

È possibile utilizzare CollectionUtils.disjunctionper ottenere tutte le differenze oCollectionUtils.subtract per ottenere la differenza nella prima raccolta.

Ecco un esempio di come farlo:

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

Solo per fare un esempio qui (il sistema è in existingStatee vogliamo trovare elementi da rimuovere (elementi che non sono in newStatema sono presenti in existingState) ed elementi da aggiungere (elementi che sono in newStatema non sono presenti 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);

  }
}

produrrebbe questo come risultato:

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