Obteniendo la diferencia entre dos conjuntos

Entonces, si tengo dos conjuntos:

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

¿Hay alguna manera de compararlos y solo devolver un conjunto de 4 y 5?

Prueba esto

test2.removeAll(test1);

Establecer # removeAll

Elimina de este conjunto todos sus elementos contenidos en la colección especificada (operación opcional). Si la colección especificada también es un conjunto, esta operación modifica efectivamente este conjunto para que su valor sea la diferencia de conjunto asimétrico de los dos conjuntos.

Si usa la biblioteca Guava (anteriormente Google Collections), hay una solución:

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

El resultado SetViewes un Set, es una representación en vivo que puede hacer inmutable o copiar a otro conjunto. test1y test2se dejan intactos.

Si:

test2.removeAll(test1)

Aunque esto va a mutar test2, cree una copia si necesita preservarla.

Además, probablemente quisiste decir en <Integer>lugar de <int>.

Java 8

Podemos hacer uso de removeIf que toma un predicado para escribir un método de utilidad como:

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

Y en caso de que todavía estemos en alguna versión anterior, podemos usar removeAll como:

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 está utilizando Java 8, puede intentar algo como esto:

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

Puede usar CollectionUtils.disjunctionpara obtener todas las diferencias o CollectionUtils.subtractpara obtener la diferencia en la primera colección.

Aquí hay un ejemplo de cómo hacerlo:

    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 para poner un ejemplo aquí (el sistema está en existingState, y queremos encontrar elementos para eliminar (elementos que no newStateestán pero están presentes existingState) y elementos para agregar (elementos que están dentro newStatepero no están presentes 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);

  }
}

daría como resultado esto:

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