Existe-t-il un meilleur moyen de combiner deux ensembles de chaînes en java?

J'ai besoin de combiner deux ensembles de chaînes tout en filtrant les informations redondantes, c'est la solution que j'ai trouvée, y a-t-il une meilleure façon que quelqu'un puisse suggérer? Peut-être quelque chose de construit que j'ai négligé? Je n'ai pas eu de chance avec Google.

Set<String> oldStringSet = getOldStringSet();
Set<String> newStringSet = getNewStringSet();

for(String currentString : oldStringSet)
{
    if (!newStringSet.contains(currentString))
    {
        newStringSet.add(currentString);
    }
}

Comme a Setne contient pas d'entrées en double, vous pouvez donc combiner les deux en:

newStringSet.addAll(oldStringSet);

Ce n'est pas grave si vous ajoutez des choses deux fois, l'ensemble ne contiendra l'élément qu'une seule fois ... par exemple, il n'est pas nécessaire de vérifier en utilisant la containsméthode.

Vous pouvez le faire en utilisant ce one-liner

Set<String> combined = Stream.concat(newStringSet.stream(), oldStringSet.stream())
        .collect(Collectors.toSet());

Avec une importation statique, c'est encore plus joli

Set<String> combined = concat(newStringSet.stream(), oldStringSet.stream())
        .collect(toSet());

Une autre façon consiste à utiliser la méthode flatMap :

Set<String> combined = Stream.of(newStringSet, oldStringSet).flatMap(Set::stream)
        .collect(toSet());

De plus, toute collection pourrait facilement être combinée avec un seul élément

Set<String> combined = concat(newStringSet.stream(), Stream.of(singleValue))
        .collect(toSet());

La même chose avec la goyave :

Set<String> combinedSet = Sets.union(oldStringSet, newStringSet)

Du jeu de définition contient uniquement des éléments uniques.

Set<String> distinct = new HashSet<String>(); 
 distinct.addAll(oldStringSet);
 distinct.addAll(newStringSet);

Pour améliorer votre code, vous pouvez créer une méthode générique pour cela

public static <T> Set<T> distinct(Collection<T>... lists) {
    Set<T> distinct = new HashSet<T>();

    for(Collection<T> list : lists) {
        distinct.addAll(list);
    }
    return distinct;
}

Si vous utilisez Guava, vous pouvez également utiliser un constructeur pour obtenir plus de flexibilité:

ImmutableSet.<String>builder().addAll(someSet)
                              .addAll(anotherSet)
                              .add("A single string")
                              .build();

Utilisez juste newStringSet.addAll(oldStringSet). Pas besoin de vérifier les doublons car l' Setimplémentation le fait déjà.

http://docs.oracle.com/javase/7/docs/api/java/util/Set.html#addAll(java.util.Collection )

Puisque les ensembles ne peuvent pas avoir de doublons, le simple ajout de tous les éléments de l'un à l'autre génère l'union correcte des deux.

 newStringSet.addAll(oldStringSet);

Cela produira l'union de s1 et s2

Utiliser boolean addAll(Collection<? extends E> c)
Ajoute tous les éléments de la collection spécifiée à cet ensemble s'ils ne sont pas déjà présents (opération facultative). Si la collection spécifiée est également un ensemble, l'opération addAll modifie effectivement cet ensemble afin que sa valeur soit l'union des deux ensembles. Le comportement de cette opération n'est pas défini si la collection spécifiée est modifiée pendant que l'opération est en cours.

newStringSet.addAll(oldStringSet)

Si vous vous souciez des performances, et si vous n'avez pas besoin de conserver vos deux ensembles et que l'un d'eux peut être énorme, je vous suggère de vérifier quel ensemble est le plus grand et d'ajouter les éléments du plus petit.

Set<String> newStringSet = getNewStringSet();
Set<String> oldStringSet = getOldStringSet();

Set<String> myResult;
if(oldStringSet.size() > newStringSet.size()){
    oldStringSet.addAll(newStringSet);
    myResult = oldStringSet;
} else{
    newStringSet.addAll(oldStringSet);
    myResult = newStringSet;
}

De cette façon, si votre nouvel ensemble comporte 10 éléments et votre ancien ensemble en contient 100 000, vous ne faites que 10 opérations au lieu de 100 000.

Si vous utilisez Apache Common, utilisez la SetUtilsclasse deorg.apache.commons.collections4.SetUtils;

SetUtils.union(setA, setB);

Set.addAll()

Ajoute tous les éléments de la collection spécifiée à cet ensemble s'ils ne sont pas déjà présents (opération facultative). Si la collection spécifiée est également un ensemble, l'opération addAll modifie effectivement cet ensemble afin que sa valeur soit l'union des deux ensembles

newStringSet.addAll(oldStringSet)