Faire la différence entre deux ensembles

Donc, si j'ai deux ensembles:

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

Existe-t-il un moyen de les comparer et de ne renvoyer qu'un ensemble de 4 et 5?

Essaye ça

test2.removeAll(test1);

Définir # removeAll

Supprime de cet ensemble tous ses éléments contenus dans la collection spécifiée (opération facultative). Si la collection spécifiée est également un ensemble, cette opération modifie effectivement cet ensemble afin que sa valeur soit la différence d'ensemble asymétrique des deux ensembles.

Si vous utilisez la bibliothèque Guava (ancienne Google Collections), il existe une solution:

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

Le rendu SetViewest a Set, c'est une représentation en direct que vous pouvez soit rendre immuable, soit copier dans un autre ensemble. test1et test2sont laissés intacts.

Oui:

test2.removeAll(test1)

Bien que cela mute test2, créez une copie si vous devez la conserver.

En outre, vous vouliez probablement dire <Integer>au lieu de <int>.

Java 8

Nous pouvons utiliser removeIf qui prend un prédicat pour écrire une méthode utilitaire comme:

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

Et au cas où nous en serions encore à une version antérieure, nous pouvons utiliser removeAll comme:

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

Si vous utilisez Java 8, vous pouvez essayer quelque chose comme ceci:

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

Vous pouvez utiliser CollectionUtils.disjunctionpour obtenir toutes les différences ou CollectionUtils.subtractpour obtenir la différence dans la première collection.

Voici un exemple de comment procéder:

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

Juste pour mettre un exemple ici (le système est dedans existingState, et nous voulons trouver des éléments à supprimer (éléments qui ne sont pas dedans newStatemais qui sont présents dans existingState) et des éléments à ajouter (éléments qui sont dedans newStatemais ne sont pas présents dans 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);

  }
}

produirait ceci comme résultat:

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