Get Unique Values From an ArrayList in Java

Last updated: March 7, 2025

Written by: Kai Yuan

Reviewed by: Eric Martin

Java List

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

We know that an ArrayList can contain duplicate values in Java.

In this quick tutorial, we’ll explore a few techniques for obtaining unique values from an ArrayList in Java.

2. Introduction to the Problem

Sometimes, we need to extract unique values from an ArrayList — for example, to enhance data analysis, improve efficiency, or simplify further processing.

Let’s say we have a list carrying some operating system names:

List<String> MY_LIST = Arrays.asList(new String[]{
  "Microsoft Windows",
  "Mac OS",
  "GNU Linux",
  "Free BSD",
  "GNU Linux",
  "Mac OS"});

In the code above, we’ve initialized the MY_LIST ArrayList from an Array. We aim to get a list of unique operating system names from MY_LIST.

We’ll discuss two different approaches to solving the problem. So, for simplicity, we’ll use unit tests and AssertJ assertions to verify if each approach produces the expected result.

Next, let’s see them in action.

3. Using a Set to Eliminate Duplicate Elements

One important difference between the Set and List interfaces is that a Set cannot hold duplicate elements. Therefore, to get MY_LIST‘s unique elements, we can first convert MY_LIST to a Set and then convert the Set back to a List.

Let’s create a test to see how this works:

List<String> result = new ArrayList<>(new HashSet<>(MY_LIST));
assertThat(result).containsExactlyInAnyOrder("Free BSD", "Microsoft Windows", "Mac OS", "GNU Linux");

Sharp eyes may have spotted that we’ve used AssertJ’s containsExactlyInAnyOrder() method for the verification. This is because we converted MY_LIST to a HashSet, and HashSet doesn’t maintain insertion order.

When the insertion order should be preserved, we can convert the list to a LinkedHashSet instead:

result = new ArrayList<>(new LinkedHashSet<>(MY_LIST));
assertThat(result).containsExactly("Microsoft Windows", "Mac OS", "GNU Linux", "Free BSD");

As we can see, this time, we used the containsExactly() method to verify the result. It checks not only the element values but also their orders.

4. Using the Stream API

The Stream API is one significant new feature of Java 8. It allows us to handle a collection of elements.

To remove duplicates from a stream, we can simply call the distinct() method:

List<String> result = MY_LIST.stream()
  .distinct()
  .collect(toList());
assertThat(result).containsExactly("Microsoft Windows", "Mac OS", "GNU Linux", "Free BSD");

The test passes when we give it a run.

It’s worth mentioning that Collectors.toList() always preserves the stream’s origin order unless we turn the stream into the unordered mode, for example, by calling unordered() or converting it to a HashSet using Collectors.toSet(). Therefore, we verify the result list using the containsExactly() method.

5. Conclusion

Obtaining unique values from a list is a common requirement in Java development. In this article, we’ve delved into two approaches to solving this problem: