Converting Between a List and a Set in Java

1. Overview

In this quick tutorial, we’ll take a look at the conversion between a List and a Set, starting with Plain Java, using Guava and the Apache Commons Collections library, and finally with Java 10.

This article is part of the “Java – Back to Basic” series here on Baeldung.

2. Convert List to Set

2.1. With Plain Java – Using the Constructor

Let’s start with converting a List to a Set using Java:

public void givenUsingCoreJava_whenListConvertedToSet_thenCorrect() {
    List<Integer> sourceList = Arrays.asList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = new HashSet<>(sourceList);
}

As we can see, the conversion process is type-safe and straightforward since the constructors of each collection do accept another collection as a source.

2.2. With Plain Java – Using Loop

Alternatively, we can convert a List to Set using a loop:

public void givenUsingCoreJava_whenUsingLoopConvertToSet_thenCorrect() {
    List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = new HashSet<>();
    for (Integer element : sourceList) {
        targetSet.add(element);
    }
}

In this example, we first initialized a new Set and used a for-each loop to add() all List elements to it.

2.3. With Plain Java – Using the addAll() Method

Instead, we can add all elements from a List to a Set using the addAll() method:

public final void givenUsingCoreJava_whenUsingAddAllToSet_thenCorrect() {
    List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = new HashSet<>();
    targetSet.addAll(sourceList);
}

It’s worth mentioning that addAll() is a method from the Collection interface. Therefore, it can also be used to convert a List to a Set. We’ll see an example later.

2.4. With Plain Java – Using Stream API

Stream API was introduced in Java 8. It provides many handy methods that allow us to deal with collections easily. Next, let’s convert List to Set using Stream API:

public void givenUsingCoreJava_whenUsingStreamToSet_thenCorrect() {
    List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = sourceList.stream().collect(Collectors.toSet());
}

In this example, we use the standard toSet() Collector to convert the List to a Set.

2.5. With Guava

Let’s do the same conversion using Guava:

public void givenUsingGuava_whenListConvertedToSet_thenCorrect() {
    List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = Sets.newHashSet(sourceList);
}

2.6. With Apache Commons Collections

Next, let’s use the Commons Collections API to convert between a List and a Set:

public void givenUsingCommonsCollections_whenListConvertedToSet_thenCorrect() {
    List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set<Integer> targetSet = new HashSet<>(6);
    CollectionUtils.addAll(targetSet, sourceList);
}

2.7. With Java 10

One additional option is to use the Set.copyOf static factory method introduced in Java 10:

public void givenUsingJava10_whenListConvertedToSet_thenCorrect() {
    List sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
    Set targetSet = Set.copyOf(sourceList);
}

Note that a Set created this way is unmodifiable.

3. Convert Set to List

3.1. With Plain Java – Using the Constructor

Now let’s do the reverse conversion, from a Set to a List, using ArrayList‘s constructor:

public void givenUsingCoreJava_whenSetConvertedToList_thenCorrect() {
   Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
   List<Integer> targetList = new ArrayList<>(sourceSet);
}

3.2. With Plain Java – Using Loop

Similarly, we can convert a Set to List using a loop:

public void givenUsingCoreJava_whenUsingLoop_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = new ArrayList<>();
    for (Integer element : sourceSet) {
        targetList.add(element);
    }
}

As the code above shows, we loop through the given Set and add() each element to a pre-initialized List.

3.3. With Plain Java – Using the addAll() Method

As we’ve mentioned, since addAll() is a method from the Collection interface, and both Set and List are subtypes of Collection, addAll() is available for Set and List:

public void givenUsingCoreJava_whenUsingAddAll_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = new ArrayList<>();
    targetList.addAll(sourceSet);
}

As the code shows, addAll() is handy to fill all elements from one Collection to another.

3.4. With Plain Java – Using Stream API

Next, let’s convert Set to List using Stream API:

public void givenUsingCoreJava_whenUsingStream_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = sourceSet.stream().collect(Collectors.toList());
}

This time, we use the standard toList() Collector to convert the Set to a List.

3.5. With Guava

We can do the same using the Guava solution:

public void givenUsingGuava_whenSetConvertedToList_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = Lists.newArrayList(sourceSet);
}

This is very similar to the java approach, only with a little less duplicated code.

3.6. With Apache Commons Collections

Now let’s see the Commons Collections solution to convert between a Set and a List:

public void givenUsingCommonsCollections_whenSetConvertedToList_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = new ArrayList<>(6);
    CollectionUtils.addAll(targetList, sourceSet);
}

3.7. With Java 10

Finally, we can use the List.copyOf that’s been introduced in Java 10:

public void givenUsingJava10_whenSetConvertedToList_thenCorrect() {
    Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = List.copyOf(sourceSet);
}

We need to keep in mind that the resulting List is unmodifiable.

4. How to Convert Between List and TreeSet

We can convert between a List and a TreeSet similar to converting between a List and a HashSet. However, we need to take into account that elements in TreeSet are sorted according to the elements’ natural ordering.

Let’s demonstrate with an example how to convert between a List and a TreeSet using a collection, each element of which is an object (instance of a class). We use an example class, Employee. This class should implement the Comparable interface so that elements are ordered using a criterion that we define. Accordingly, we should override the compareTo(Object) method in Comparable to compare two Employee objects based on their IDs:

public class Employee implements Comparable<Employee> {
    private int employeeId;
    private String employeeName;

    Employee(int employeeId, String employeeName) {
        this.employeeId = employeeId;
        this.employeeName = employeeName;
    }

    int getEmployeeId() {
        return employeeId;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    @Override
    public String toString() {
        return employeeId + " " + employeeName;
    }

    @Override
    public int compareTo(Employee o) {
        if (this.employeeId == o.employeeId) {
            return 0;
        } else if (this.employeeId < o.employeeId) {
            return 1;
        } else {
            return -1;
        }
    }
}

4.1. How to Convert a List to a TreeSet

Having defined an object class Employee, let’s create an ArrayList from it. Afterward, we use the class constructor TreeSet(Collection<? extends E> c) to create a new TreeSet object containing the elements in the ArrayList passed to it, sorted according to the elements’ natural ordering.

Let’s use a JUnit 5 integration test that includes an assertDoesNotThrow() assertion to verify the conversion doesn’t throw an exception:

@Test
public void givenComparableObject_whenConvertingToTreeSet_thenNoExceptionThrown() {

    ArrayList<Employee> arrayList = new ArrayList<Employee>();

    arrayList.add(new Employee(3, "John"));
    arrayList.add(new Employee(5, "Mike"));
    arrayList.add(new Employee(2, "Bob"));
    arrayList.add(new Employee(1, "Tom"));
    arrayList.add(new Employee(4, "Johnny"));
        
    assertDoesNotThrow(()->{
        TreeSet<Employee> treeSet=new TreeSet<Employee>(arrayList);
    });
}

The JUnit integration test should pass when we use the Employee class that implements the Comparable interface.

4.2. How to Convert a TreeSet to a List

We can use the same object class, Employee, to convert a TreeSet to an ArrayList. This time, let’s create a TreeSet with each of its elements as an instance of the Employee class. Further, we use the class constructor ArrayList(Collection<? extends E> c) to create a new ArrayList object containing the elements in the TreeSet passed to it.

Again, let’s use a JUnit 5 integration test that includes an assertDoesNotThrow() assertion to verify the conversion doesn’t throw an exception:

@Test
public void givenTreeSet_whenConvertingToList_thenNoExceptionThrown() {

    TreeSet<Employee> treeSet = new TreeSet<Employee>();

    treeSet.add(new Employee(3, "John"));
    treeSet.add(new Employee(5, "Mike"));
    treeSet.add(new Employee(2, "Bob"));
    treeSet.add(new Employee(1, "Tom"));
    treeSet.add(new Employee(4, "Johnny"));
        
    assertDoesNotThrow(()->{
        ArrayList<Employee> arrayList=new ArrayList<Employee>(treeSet);
    });
}

The JUnit integration test should pass when we use the Employee class that implements the Comparable interface.

5. Conclusion