1. Overview
In this quick tutorial, we’ll introduce various methods of initializing the HashSet with values, at the time of its construction.
If you’re instead looking to explore the features of HashSet, refer to this core article here.
We’ll dive into Java built-in methods since Java 5 and before followed by new mechanism introduced since Java 8. We’ll also see a custom utility method and finally explore the features provided by 3rd party collection libraries, Google Guava in particular.
If you’re lucky to have migrated to JDK9+ already, you can simply use collection factory methods.
2. Java Built-in Methods
Let’s begin by examining three built-in mechanisms available since the Java 5 or before.
2.1. Using Another Collection Instance
We can pass an existing instance of another collection to initialize the Set. In below example, we are using an inline created List:
Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
2.2. Using Anonymous Class
In yet another approach, we can use the anonymous class to add an element to HashSet.
Note the use of double curly braces. This approach is technically very expensive as it creates an anonymous class each time it’s called.
So depending on how frequently we need to initialize Set we can try to avoid using this approach:
Set<String> set = new HashSet<String>(){{
add("a");
add("b");
add("c");
}};
2.3. Using Collections Utility Method Since Java 5
The Java’s Collections utility class provides the method named singleton to create a Set with a single element. The Set instance created with the singleton method is immutable meaning that we cannot add more values to it.
There are situations especially in unit testing where we need to create a Set with a single value:
Set<String> set = Collections.singleton("a");
3. Defining Custom Utility Method
We can define a static final method as below. The method accepts variable arguments.
Using Collections.addAll which accepts the collection object and an array of values is best among others because of the low overhead of copying values.
The method is using generics so we can pass values of any type:
public static final <T> Set<T> newHashSet(T... objs) {
Set<T> set = new HashSet<T>();
Collections.addAll(set, objs);
return set;
}
The utility method can be used in our code as below.
Set<String> set = newHashSet("a","b","c");
4. Using Stream since Java 8
With the introduction of Stream API in Java 8, we have additional options. We can use Stream with Collectors as shown in below code:
Set<String> set = Stream.of("a", "b", "c")
.collect(Collectors.toCollection(HashSet::new));
5. Using 3rd Party Collection Library
There are multiple 3rd party collections libraries including Google Guava, Apache Commons Collections, and Eclipse Collections just to name a few.
These libraries provide convenient utility methods to initialize collections like Set. Since Google Guava is one of the most commonly used here we have an example from it. The Guava has convenient methods for mutable and immutable Set objects:
Set<String> set = Sets.newHashSet("a", "b", "c");
Similarly, Guava has a utility class for creating immutable Set instances, as we can see in the example below.
Set<String> set = ImmutableSet.of("a", "b", "c");
6. Conclusion
In conclusion, we saw multiple ways in which a HashSet can be initialized while it is constructed. These approaches don’t necessarily cover all possible ways by any means. It was just an attempt to showcase most common ways.
One such approach not covered here could be using the object builder to construct a Set.
As always working code example is available over on GitHub.