Quelle est la meilleure façon d'obtenir le symétrique de la différence entre deux ensembles en java?

Je me demandais si il existe un moyen rapide/moyen propre pour obtenir le symétrique de la différence entre deux ensembles ?

J'ai:

Set<String> s1 = new HashSet<String>();
s1.add("a");
s1.add("b");
s1.add("c");

Set<String> s2 = new HashSet<String>();
s2.add("b");

J'ai besoin de quelque chose comme:

Set<String> diff = Something.diff(s1, s2);
//diff would contain ["a", "c"]

Juste pour préciser j'ai besoin de la symétrique différence.

Quick&facile: Vous pourriez écrire Set<String> diff = new HashSet<String>(s1); diff.removeAll(s2);
ce sera un échec pour S1={"a","b","c"},S2={"b","d"}. résultat devrait être {"a","c","d"}
Si par "différence" (cf. secure.wikimedia.org/wikipedia/en/wiki/...) les OP signifiait symétrique différence, alors vous avez raison. Cependant, vous pouvez obtenir ce que (A - B) + (B - A), ou (A + B) - (Un bouchon B). Je ne connais pas de moyen plus rapide en java pour le mettre en œuvre.
Java 8 et Java 11 : stackoverflow.com/a/52268640/1216775

InformationsquelleAutor Simeon | 2011-11-09

42

Vous pouvez utiliser certaines fonctions de la Google Goyave de la bibliothèque (qui est vraiment génial, je le recommande vivement!):
```
Sets.difference(s1, s2);
Sets.symmetricDifference(s1, s2);
```
Javadoc différence() et symmetricDifference()

symmetricDifference() fait exactement ce que vous demandez, mais difference() est également souvent utile.

Deux méthodes retournent une vue en direct, mais vous pouvez par exemple faire appel .immutableCopy() sur l'ensemble résultant d'obtenir un non-changeant. Si vous ne voulez pas d'un point de vue, mais besoin d'un ensemble d'instance, vous pouvez les modifier, de les appeler .copyInto(s3). Voir SetView pour ces méthodes.
- Ayant tout juste de lire la javadoc de symetricDifference(), je suis un peu préoccupé par cette déclaration que "les Résultats ne sont pas définis si set1 et set2 sont des jeux basés sur différentes relations d'équivalence (comme HashSet, TreeSet, et le clavier d'un IdentityHashMap sont tous)." Qui le fait ressembler le résultat n'est pas défini pour l'OP du cas (et le Définit.symmetricDifference() la méthode ne semble pas si utile.
- La JavaDoc veut dire que les résultats ne sont pas définis, si vous utilisez la méthode avec deux jeux différents qui utilisent différentes relations d'équivalence, par exemple, calculer la différence entre un HashSet et un TreeSet peut être problématique. À l'aide de la méthode avec deux HashSets, ou deux TreeSets, etc. est fine.
- En outre, il est également très bien si vous utilisez la méthode avec un HashSet et un TreeSet, si le compareTo() méthode et la equals() méthode des éléments d'accord les uns avec les autres (ce qui est fortement recommandé par leur documentation). De sorte que dans certains cas, la méthode ne peut pas garantir que la différence est calculée correctement, dans la plupart des cas pratiques, il fonctionnera très bien.
- J'ai eu la même inquiétude à ce sujet "les résultats sont undefined" déclaration. Merci @PhilippWendler de clarifier cette!
InformationsquelleAutor Philipp Wendler
32

Vous voulez le symétrique différence.
```
public static <T> Set<T> diff(final Set<? extends T> s1, final Set<? extends T> s2) {
    Set<T> symmetricDiff = new HashSet<T>(s1);
    symmetricDiff.addAll(s2);
    Set<T> tmp = new HashSet<T>(s1);
    tmp.retainAll(s2);
    symmetricDiff.removeAll(tmp);
    return symmetricDiff;
}
```
Si vous voulez une bibliothèque, Apache Commons CollectionUtils a
```
CollectionUtils.disjunction(s1, s2)
```
qui renvoie à un non-générique Collection.

et Jeux De Goyave a
```
Sets.symmetricDifference(s1, s2)
```
qui retourne un inmodifiable Set comme un générique Sets.SetView.

Goyave est un peu plus moderne, en soutenant les génériques, mais l'une de ces travaux.
- merci, en fait j'ai été à la recherche pour une lib qui le fait pour moi, car c'est ce que j'ai actuellement
- CollectionUtils à partir de Apache Commons Collections v4 le soutien des génériques
InformationsquelleAutor Don Roby
5

Si vous pouvez utiliser "Apache Commons Collections, vous êtes à la recherche pour CollectionUtils.la disjonction(Collection de, Collection de b). Il retourne la différence symétrique de deux Collections.

Si non, il suffit de soustraire (removeAll) l'intersection (retainAll) des deux ensembles à l'union des deux (addAll):
```
Set<String> intersection = new HashSet<String>(set1);
intersection.retainAll(set2);

Set<String> difference = new HashSet<String>();
difference.addAll(set1);
difference.addAll(set2);
difference.removeAll(intersection);
```
InformationsquelleAutor Xavi López says GoFundMonica
4

Boucle à travers un ensemble et de les comparer.

C'est seulement O(n) d'une boucle sur l'un des ensembles. Considérer ce code:
```
for (String key: oldSet) {
    if (newSet.contains(key))
        newSet.remove(key);
    else
        newSet.add(key);
}
```
Et la newSet va maintenant contenir uniquement les entrées uniques à partir de deux ensembles. C'est rapide, parce que vous avez seulement besoin d'une boucle sur les éléments de l'un des ensembles et vous n'avez pas à créer des ensembles, sauf si vous explicitement besoin d'une copie.
- Notez que c'est O(n) pour HashSet sans collision seulement. Pour TreeSets, tous les trois opérations add(key), contains(key) et remove(key) nécessiterait la recherche de l'arbre une fois, soit un ajout de O(n log n).
InformationsquelleAutor Erick Robertson

public class Practice {
    public static void main(String[] args) {
        Set<Integer> set1 = new HashSet<Integer>();
        Set<Integer> set2 = new HashSet<Integer>();
        set1.add(1);
        set1.add(4);
        set1.add(7);
        set1.add(9);

        set2.add(2);
        set2.add(4);
        set2.add(5);
        set2.add(6);
        set2.add(7);

        symmetricSetDifference(set1, set2);
    }

    public static void symmetricSetDifference(Set<Integer>set1, Set<Integer>set2){
        //creating a new set
        Set<Integer> newSet = new HashSet<Integer>(set1);
        newSet.removeAll(set2);
        set2.removeAll(set1);
        newSet.addAll(set2);
        System.out.println(newSet);
    }

}

Bien que ce code peut répondre à la question, en fournissant plus de contexte sur pourquoi et/ou comment il répond à la question permettrait d'améliorer de manière significative sa valeur à long terme. Veuillez modifier votre réponse à ajouter quelques explications.

InformationsquelleAutor Suraj Upreti

Java 8 Solution

On peut écrire deux méthodes d'utilitaire (pour java 8 et avant) dans une classe SetUtils (say) comme:

public static <T> Set<T> symmetricDifferenceJava8(final Set<T> setOne, final Set<T> setTwo) {
    Set<T> result = new HashSet<>(setOne);
    setTwo.stream().filter(not(resultSet::add)).forEach(resultSet::remove);
    return result;
}

public static <T> Set<T> symmetricDifference(final Set<T> setOne, final Set<T> setTwo) {
    Set<T> result = new HashSet<T>(setOne);
    for (T element : setTwo) {
        if (!result.add(element)) {
            result.remove(element);
        }
    }
    return result;
}

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

La méthode add renvoie false si l'élément existe déjà et méthode nier est utilisé pour nier le prédicat.

Java 11

Nous avons un Prédicat#pas méthode de prédicat en Java 11 et pouvez l'utiliser comme:

public static <T> Set<T> symmetricDifferenceJava11(final Set<T> setOne, final Set<T> setTwo) {
    Set<T> result = new HashSet<>(setOne);
    setTwo.stream().filter(Predicate.not(resultSet::add)).forEach(resultSet::remove);
    return result;
}

InformationsquelleAutor i_am_zero

-4
```
s1.addAll(s2);
s1.removeAll(s2);
```
Devrait fonctionner.
- Cela ne fonctionne pas pour S1={"a","b","c"},S2={"b","d"}. Résultat devrait être {"a","c","d"}.
- C'est une asymétrie de différence. Il veut que la différence symétrique.
InformationsquelleAutor Ravi Bhatt

Vous devez vous connecter pour publier un commentaire.