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.
As always, the complete source code for the tutorial is available over on GitHub.
