How to merge multiple (arbitrary number of) Set<String> into one in Java?

Question

I have multiple Set<String> that I need to merge into one Set<String>. How do I do this operation in Java? Note, I am using using the guava API as best as I can to help out. For example, I have 3 classes as follows.

public class One {
 public static Set<String> SET = Sets.newHashSet("a","b","c");
}
public class Two {
 public static Set<String> SET = Sets.newHashSet("a","d","e","f");
}
public class Three {
 public static Set<String> SET = Sets.newHashSet("w","x","y","f");
}

Now, I need to merge any combination of these sets into one. For, example, I may need to merge

One.SET + Two.SET + Three.SET into one to produce { "a","b","c","d","e","f","w","x","y" },
One.SET + Three.SET into one to produce { "a","b","c","w","x","y","f" },
Two.SET + Three.SET into one to produce { "a","d","e","f","w","x","y" },
and so on

I created a method to merge an array of sets, Set<String>[], but that doesn't work (explained here by this SO post Creating an array of Sets in Java). Here's the code to merge. It works (compiles).

public static Set<String> immutableSetOf(Set<String>[] sets) {
 Set<String> set = new HashSet<String>();
 for(Set<String> s : sets) {
  set.addAll(s);
 }
 return ImmutableSet.copyOf(set);
}

Here's the calling code; it doesn't work (doesn't compile).

Set<String> set = Utils.immutableSetOf(new Set<String>[] { One.SET, Two.SET });

So, I modified my merging method to operate on List<Set<String>> instead of Set<String>[]. Only the argument type changed, but I put it here for completeness.

public static Set<String> immutableSetOf(List<Set<String>> sets) {
 Set<String> set = new HashSet<String>();
 for(Set<String> s : sets) {
  set.addAll(s);
 }
 return ImmutableSet.copyOf(set);
}

So, now my calling code looks like the following.

Set<String> set = Utils.immutableSetOf(
 Lists.newArrayList(
  One.SET, Two.SET));

This code does not compile, since Lists.newArrayList(...) is returning Set<String> and not List<Set<String>>. The method Lists.newArrayList(...) is overloaded, and the signature of the method that is used when I pass in sets is, List.newArrayList(Iterable<? extends E> elements).

So, the question is, how do I define a method to merge an arbitrary number of Set<String> while considering the calling code? I note that the compilation problems are on the calling code (not the merging method), but perhaps the solution also relates to the merging code?

Update: I also tried varargs but that produces its own warning (Is it possible to solve the "A generic array of T is created for a varargs parameter" compiler warning?). The merging method signature is now the following.

public static Set<String> immutableSetOf(Set<String>... sets)

The calling code is now the following, and I get "Type safety: A generic array of Set is created for a varargs parameter".

Set<String> set = Utils.immutableSetOf(One.SET, Two.SET);

Update: For the accepted answer, I did the following.

@SuppressWarnings("unchecked")
Set<String> set = Utils.immutableSetOf(Set[] { One.SET, Two.SET });

卢声远 Shengyuan Lu · Accepted Answer · 2014-12-03 05:05:05Z

6

Recommend com.google.common.collect.Sets#union(set1, set2) to get the merge instead of Set.addAll under hood, since Guava is already in your dependencies.

Reason: it's view which is memory effective, and also unmodifiable.

plus: I should have post it as a comment, sorry.

edited Dec 3, 2014 at 5:05

answered Dec 3, 2014 at 4:59

卢声远 Shengyuan Lu

32.1k23 gold badges90 silver badges134 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Shannon S · Accepted Answer · 2018-03-28 21:08:20Z

6

How about creating a collection of your input sets, then using flatMap?

Set<String> allElements = ImmutableSet.of(
        One.SET,
        Two.SET,
        Three.SET
).stream().flatMap(Collection::stream).collect(Collectors.toSet());

answered Mar 28, 2018 at 21:08

Shannon S

2004 silver badges3 bronze badges

1 Comment

M. Justin Over a year ago

I'd do Stream.of(One.SET, Two.SET, Three.SET) rather than ImmutableSet.of().stream() to avoid unnecessarily creating the interim ImmutableSet.

MJSG · Accepted Answer · 2014-12-03 04:36:35Z

2

In your previous attempt, you had written

Set<String> set = Utils.immutableSetOf(new Set<String>[] { One.SET, Two.SET });

This does not work because, generics array creation is not allowed in java

Try this:

@SuppressWarnings("unchecked")
Set<String>[] mySet = new Set[] { One.SET, Two.SET };
Set<String> set = Utils.immutableSetOf(mySet);

The reason this works is because, we create a new Set[] without specifying the generics type and assign it to the reference Set[] mySet (since this is an unchecked operation, we have to add @SuppressWarnings("unchecked") to it)

answered Dec 3, 2014 at 4:36

MJSG

1,1259 silver badges12 bronze badges

3 Comments

Jane Wayne Over a year ago

That definitely works, but is there a way while specifying the generic type?

MJSG Over a year ago

From what i know, the java does not allow it. Also, there is no need for it, as at the end of the day, we need to have a reference with the specified type, which can be accomplished.

卢声远 Shengyuan Lu Over a year ago

Recommend com.google.common.collect.Sets#union(set1, set2) to get the merge instead of Set.addAll under hood, since Guava is already in your dependencies. Reason: it's view which is memory effective, and also unmodifiable.

clstrfsck · Accepted Answer · 2014-12-03 04:53:13Z

1

You could use:

Set<String> set = immutableSetOf(Arrays.asList(One.SET, Two.SET));

Using your definition of immutableSetOf(List<Set<String>> sets). No warnings or suppressed warnings.

answered Dec 3, 2014 at 4:53

clstrfsck

14.9k5 gold badges48 silver badges62 bronze badges

Comments

Makoto · Accepted Answer · 2014-12-03 04:58:01Z

1

I'm thinking that FluentIterable (in 18.0 and above) can help here, specifically the append method.

With that, we need to define a convenient helper method - and yes, we're going to use varargs for this.

public <T extends Comparable<T>> Set<T> mergeSets(Set<T> initial,
                                                 Set<T>... rest) {
    FluentIterable<T> result =  FluentIterable.from(initial);
    for(Set<T> set : rest) {
        result = result.append(set);
    }
    return new TreeSet<>(result.toSet());
}

The resultant set here is in natural order. If you don't want a TreeSet and you don't want to mutate your collection afterwards, then omit the new TreeSet<> piece, and loosen the bound on T.

answered Dec 3, 2014 at 4:58

Makoto

107k29 gold badges200 silver badges236 bronze badges

1 Comment

fukanchik Over a year ago

warning: [unchecked] Possible heap pollution from parameterized vararg type Set<T>

Laurel · Accepted Answer · 2023-03-29 20:59:42Z

0

This should help. One liner in Java 8:

Stream.of(sets).flatMap(Set::stream).collect(Collectors.toSet())

edited Mar 29, 2023 at 20:59

Laurel

6,23114 gold badges35 silver badges60 bronze badges

answered Mar 26, 2023 at 18:30

mohit gupta

1

Collectives™ on Stack Overflow

How to merge multiple (arbitrary number of) Set<String> into one in Java?

6 Answers 6

Comments

1 Comment

3 Comments

Comments

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

1 Comment

3 Comments

Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related