Czy jest lepszy sposób na połączenie dwóch zestawów ciągów w java?

Muszę połączyć dwa zestawy ciągów, odfiltrowując zbędne informacje, to jest rozwiązanie, które wymyśliłem, czy jest lepszy sposób, który każdy może zasugerować? Może coś wbudowanego, co przeoczyłem? Nie miałem szczęścia z Google.

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

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

Ponieważ a Setnie zawiera zduplikowanych wpisów, możesz więc połączyć je w następujący sposób:

newStringSet.addAll(oldStringSet);

Nie ma znaczenia, czy dodasz rzeczy dwa razy, zestaw będzie zawierał element tylko raz… np. Nie ma potrzeby sprawdzania containsmetodą.

Możesz to zrobić za pomocą tej jednej linijki

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

Z importem statycznym wygląda jeszcze ładniej

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

Innym sposobem jest użycie metody flatMap :

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

Również każdą kolekcję można było łatwo połączyć z jednym elementem

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

To samo z guawą :

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

Z definicji Zestaw zawiera tylko unikalne elementy.

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

Aby ulepszyć swój kod, możesz stworzyć w tym celu ogólną metodę

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

Jeśli używasz guawy, możesz również użyć kreatora, aby uzyskać większą elastyczność:

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

Po prostu użyj newStringSet.addAll(oldStringSet). Nie ma potrzeby sprawdzania duplikatów, ponieważ Setimplementacja już to robi.

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

Ponieważ zestawy nie mogą mieć duplikatów, po prostu dodanie wszystkich elementów jednego do drugiego generuje poprawną sumę tych dwóch.

 newStringSet.addAll(oldStringSet);

Spowoduje to utworzenie sumy s1 i s2

Użyj boolean addAll(Collection<? extends E> c)
Dodaje wszystkie elementy w określonej kolekcji do tego zestawu, jeśli nie są one jeszcze obecne (operacja opcjonalna). Jeśli określona kolekcja jest również zbiorem, operacja addAll skutecznie modyfikuje ten zestaw, tak aby jego wartość była sumą dwóch zestawów. Zachowanie tej operacji jest niezdefiniowane, jeśli określona kolekcja zostanie zmodyfikowana w trakcie trwania operacji.

newStringSet.addAll(oldStringSet)

Jeśli zależy Ci na wydajności, a nie musisz trzymać swoich dwóch zestawów, a jeden z nich może być ogromny, proponuję sprawdzić, który zestaw jest największy i dodać elementy z najmniejszego.

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

W ten sposób, jeśli twój nowy zestaw ma 10 elementów, a stary zestaw 100 000, wykonujesz tylko 10 operacji zamiast 100 000.

Jeśli używasz Apache Common, użyj SetUtilsklasy zorg.apache.commons.collections4.SetUtils;

SetUtils.union(setA, setB);

Set.addAll()

Dodaje wszystkie elementy w określonej kolekcji do tego zestawu, jeśli nie są jeszcze obecne (operacja opcjonalna). Jeśli określona kolekcja jest również zbiorem, operacja addAll skutecznie modyfikuje ten zestaw, tak aby jego wartość była sumą dwóch zestawów

newStringSet.addAll(oldStringSet)