Existe uma maneira melhor de combinar dois conjuntos de strings em java?

Preciso combinar dois conjuntos de strings ao filtrar as informações redundantes. Essa é a solução que encontrei. Existe uma maneira melhor que alguém possa sugerir? Talvez algo embutido que eu esqueci? Não tive sorte com o google.

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

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

Como a Setnão contém entradas duplicadas, você pode combinar os dois:

newStringSet.addAll(oldStringSet);

Não importa se você adiciona coisas duas vezes, o conjunto conterá o elemento apenas uma vez ... por exemplo, não é necessário verificar usando o containsmétodo.

Você pode fazer isso usando este one-liner

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

Com uma importação estática, fica ainda melhor

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

Outra maneira é usar o método flatMap :

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

Além disso, qualquer coleção pode ser facilmente combinada com um único elemento

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

O mesmo com a goiaba :

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

Da definição, o conjunto contém apenas elementos únicos.

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

Para aprimorar seu código, você pode criar um método genérico para que

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 você estiver usando Guava, também pode usar um construtor para obter mais flexibilidade:

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

Basta usar newStringSet.addAll(oldStringSet). Não há necessidade de verificar se há duplicatas, pois a Setimplementação já faz isso.

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

Como os conjuntos não podem ter duplicatas, apenas adicionar todos os elementos de um ao outro gera a união correta dos dois.

 newStringSet.addAll(oldStringSet);

Isso produzirá União de s1 e s2

Use boolean addAll(Collection<? extends E> c)
Adiciona todos os elementos da coleção especificada a este conjunto se eles ainda não estiverem presentes (operação opcional). Se a coleção especificada também for um conjunto, a operação addAll modifica efetivamente esse conjunto para que seu valor seja a união dos dois conjuntos. O comportamento desta operação é indefinido se a coleção especificada for modificada enquanto a operação estiver em andamento.

newStringSet.addAll(oldStringSet)

Se você se preocupa com o desempenho e não precisa manter seus dois conjuntos e um deles pode ser enorme, sugiro verificar qual conjunto é o maior e adicionar os elementos dos menores.

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

Dessa forma, se o seu novo conjunto tiver 10 elementos e o antigo tiver 100.000, você só fará 10 operações em vez de 100.000.

Se você estiver usando o Apache Common, use a SetUtilsclasse deorg.apache.commons.collections4.SetUtils;

SetUtils.union(setA, setB);

Set.addAll()

Adiciona todos os elementos da coleção especificada a este conjunto, se ainda não estiverem presentes (operação opcional). Se a coleção especificada também for um conjunto, a operação addAll modifica efetivamente esse conjunto para que seu valor seja a união dos dois conjuntos

newStringSet.addAll(oldStringSet)