Initializing HashSet at the Time of Construction

1. Overview

In this quick tutorial, we’ll introduce various methods of initializing the HashSet with values, at the time of its construction.

To instead 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 mechanisms introduced since Java 8.

We’ll also see a custom utility method and finally explore the features provided by third-party collection libraries, Google Guava in particular.

If we’ve already migrated to JDK9+, we can simply use collection factory methods.

2. Java Built-In Methods

Let’s begin by examining three built-in mechanisms available since Java 5 or before.

2.1. Using Another Collection Instance

We can pass an existing instance of another collection to initialize the Set.

Here 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 because 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 uses 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;
}

Here’s how we can use the utility method in our code:

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 such as Stream with Collectors:

Set<String> set = Stream.of("a", "b", "c")
  .collect(Collectors.toCollection(HashSet::new));

5. Using Third-Party Collection Library

There are multiple third-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, we’ve included an example from it.

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:

Set<String> set = ImmutableSet.of("a", "b", "c");

6. Conclusion

In this article, 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. This article is just an attempt to showcase the most common ways.

For example, one approach not covered here could be using the object builder to construct a Set.