Converting an int[] to HashSet in Java

1. Overview

Arrays and HashSet have a common characteristic – they’re both used to store a collection of elements. However, they differ in their underlying implementation and applicable use cases. Further, one of the differences is that we can store primitive types in arrays, but not in a HashSet.

In this tutorial, we’ll learn how to convert an int[] to a HashSet<Integer> in Java using multiple approaches.

2. Understanding the Scenario

Let’s start by initializing an int[], arr with a few elements:

int[] arr = { 1, 2, 3, 4, 5 };

Now, let’s define our expected result in the expected variable of type HashSet<Integer>:

HashSet<Integer> expected = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));

Now, let’s see if we can use the Arrays.asList() method to create a list and pass it to the constructor of HashSet:

HashSet<Integer> result = new HashSet<>(Arrays.asList(arr));

Unfortunately, the compiler won’t allow it and gives us an error:

java: incompatible types: cannot infer type arguments for java.util.HashSet<>
    reason: inference variable E has incompatible bounds
      equality constraints: java.lang.Integer
      lower bounds: T,int[]

We can see that it failed to infer the type correctly.

Lastly, let’s confirm that this approach gives us a HashSet of int[] instead of HashSet<Integer>:

HashSet<int[]> result = new HashSet<>(Arrays.asList(arr));
assertEquals(1, result.size());
assertNotEquals(expected, result);

It’s worth noting that we got a single element of int[] type in the HashSet.

3. Using Loop

The most straightforward approach to solving this use case is to write a for loop that iterates over the array and adds each member in the result HashSet:

HashSet<Integer> result = new HashSet<>();
for (int num : arr) {
    result.add(num);
}

Further, we can verify our approach by asserting that result is equal to the expected HashSet:

assertEquals(expected, result);

Great! It works as expected.

4. Using Java Streams

With Java 8 or later, we can achieve our goal using streams.

Let’s use the Arrays.stream() method to create a stream of integers from our int array and collect each integer in a HashSet after intermediate processing:

HashSet<Integer> result = Arrays.stream(arr)
  .boxed()
  .collect(Collectors.toCollection(HashSet::new));

It’s important to note that we used the boxed() method to convert the int type into an Integer type.

Lastly, let’s verify our implementation:

assertEquals(expected, result);

Perfect! It gives us the correct outcome.

5. Using Commons Lang Library

In this section, we’ll learn how to solve our use case with the Commons Lang library.

5.1. Maven Dependency

Let’s start by adding the dependency for the commons-lang3 artifact in the pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

Great! We’re ready to use this library.

5.2. Using the ArrayUtils.toObject() Method

Now, let’s use the ArrayUtils.toObject() method to convert the array from an int type to an Integer type.

Further, we can pass the object types to the Arrays.asList() method and create the HashSet object:

HashSet<Integer> result = new HashSet<>(Arrays.asList(ArrayUtils.toObject(arr)));

Like earlier, it’s a good practice to gain confidence in our code with a simple test:

assertEquals(expected, result);

Fantastic! It looks like we nailed this one.

6. Using Guava Library

Moving on, let’s explore how to tackle this problem using the Guava library.

6.1. Maven Dependency

Before we can use the library methods, let’s add the dependency for the guava artifact in our project’s pom.xml file:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.2-jre</version>
</dependency>

We’re ready to use this library now.

6.2. Using the Ints.asList() Method

We can use the Ints.asList() method to get a list of Integer containing all members from the int array. As a result, we won’t need the Arrays.asList() method in this approach.

So, let’s go ahead and create the result HashSet by passing the list of Integer types:

HashSet<Integer> result = new HashSet<>(Ints.asList(arr));

Additionally, let’s not forget to test our approach:

assertEquals(expected, result);

It works as expected.

7. Conclusion

In this article, we learned how to convert an int[] to a HashSet collection for improved data handling.

On the one hand, we used native approaches, such as loop constructs and Java streams, to solve the use case. On the other hand, we also explored popular libraries such as Apache Commons Lang and Google Guava to tackle the problem.