C'è un modo migliore per combinare due set di stringhe in java?

Ho bisogno di combinare due set di stringhe mentre filtra le informazioni ridondanti, questa è la soluzione che ho trovato, c'è un modo migliore che chiunque possa suggerire? Forse qualcosa di incorporato che ho trascurato? Non ho avuto fortuna con Google.

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

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

Poiché a Setnon contiene voci duplicate, puoi quindi combinare i due in base a:

newStringSet.addAll(oldStringSet);

Non importa se aggiungi le cose due volte, l'insieme conterrà l'elemento solo una volta ... ad es. Non è necessario controllare usando il containsmetodo.

Puoi farlo usando questo one-liner

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

Con un'importazione statica sembra ancora più bello

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

Un altro modo è utilizzare il metodo flatMap :

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

Inoltre qualsiasi collezione potrebbe essere facilmente combinata con un singolo elemento

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

Lo stesso con Guava :

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

Dalla definizione Set contengono solo elementi unici.

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

Per migliorare il tuo codice puoi creare un metodo generico per questo

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

Se stai usando Guava puoi anche usare un builder per ottenere maggiore flessibilità:

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

Basta usare newStringSet.addAll(oldStringSet). Non è necessario controllare i duplicati poiché l' Setimplementazione lo fa già.

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

Poiché gli insiemi non possono avere duplicati, la semplice aggiunta di tutti gli elementi di uno all'altro genera l'unione corretta dei due.

 newStringSet.addAll(oldStringSet);

Questo produrrà l'unione di s1 e s2

Usa boolean addAll(Collection<? extends E> c)
Aggiunge a questo set tutti gli elementi nella raccolta specificata se non sono già presenti (operazione facoltativa). Se la raccolta specificata è anche un set, l'operazione addAll modifica efficacemente questo set in modo che il suo valore sia l'unione dei due set. Il comportamento di questa operazione non è definito se la raccolta specificata viene modificata mentre l'operazione è in corso.

newStringSet.addAll(oldStringSet)

Se ti interessano le prestazioni e se non hai bisogno di mantenere i tuoi due set e uno di essi può essere enorme, ti suggerirei di controllare quale set è il più grande e aggiungere gli elementi dal più piccolo.

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

In questo modo, se il tuo nuovo set ha 10 elementi e il tuo vecchio set ne ha 100.000, fai solo 10 operazioni invece di 100.000.

Se stai usando Apache Common, usa la SetUtilsclasse daorg.apache.commons.collections4.SetUtils;

SetUtils.union(setA, setB);

Set.addAll()

Aggiunge tutti gli elementi nella raccolta specificata a questo set se non sono già presenti (operazione facoltativa). Se anche la raccolta specificata è un set, l'operazione addAll modifica efficacemente questo set in modo che il suo valore sia l'unione dei due set

newStringSet.addAll(oldStringSet)