Home Java How to convert set to List in Java

How to convert set to List in Java

The java.util.Collection interface is extended by Java Set, which is part of the java.util package. It does not enable duplicate elements and can only hold a null component at a time.

The List is a Collection’s child interface. It’s a sorted collection of objects that can store duplicate values. Further, the list supports positional access and insertion of members because the insertion order is preserved. ArrayList, LinkedList, Vector, and Stack classes also implement the List Interface.

In Java, a list is an ordered collection of data, whereas a set is an unordered collection. A set cannot have duplicate entries, while a list can. Both data structures are helpful in a variety of situations. It’s helpful to know how to turn a set into a list. For example, it can convert data that isn’t in any particular order into data that is.

Creating a new set

Let’s start by creating a set and then adding some items to it.

import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        System.out.println(intList);
    }
}

HashSet’s add() method adds the components to the set. It’s important to note that the elements are distinct. Because the sets are unordered, there is no way to acquire the components in the order they were inserted.

Java Conversion of a Set to a List

Let’s make a list out of the set. There are several options for doing so. In fact, each method is distinct from the others. However, the distinctions are minor.

Constructor of a List with a Set argument

The simplest way to convert a set to a list is to use the set as an argument when building the list. The constructor is invoked due to this, and the constructor takes care of the rest. In Java, collections feature a constructor where the direct set is provided to produce a List.

Algorithm:

  • Obtain the set you intend to transform.
  • By supplying the set as an argument to the constructor, you can make a list.
  • Return the created List.
import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>(intList);
     System.out.println(arr);
     System.out.println(arr.get(1));
 
    }
}

The elements are now arranged because the set has been changed to a list. That means we can retrieve details by index using the get() method.

Example: Program for converting a Set to List in Java
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		List<T> list = new ArrayList<>(set);

		// return the list
		return list;
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> laptopHashSet = new HashSet<String>();

		// Add elements to set
		laptopHashSet.add("Geeks");
		laptopHashSet.add("For");
		laptopHashSet.add("Geeks");
		laptopHashSet.add("Example");
		laptopHashSet.add("Set");

		// Print the Set
		System.out.println("Set: " + laptopHashSet);

		// construct a new List from Set
		List<String> list = convertSetToList(laptopHashSet);

		// Print the List
		System.out.println("List: " + list);
	}
}
Example: Using a Constructor
import java.util.*;
import java.util.stream.*;
  
class example {
  
    // Generic function to convert set to list
    public static <T> List<T> convertSetToList(Set<T> set)
    {
        // create a list from Set
        List<T> list = new ArrayList<>(set);
  
        // return the list
        return list;
    }
  
    public static void main(String args[])
    {
  
        // Create a Set using HashSet
        Set<String> codeSet = new HashSet<String>();
  
        // Add elements to set
        codeSet.add("Code");
        codeSet.add("Underscored");
        codeSet.add("Set");
        codeSet.add("to");
        codeSet.add("list");
        codeSet.add("example");
  
        // Print the Set
        System.out.println("Set: " + codeSet);
  
        // construct a new List from Set
        List<String> list = convertSetToList(hash_Set);
  
        // Print the List
        System.out.println("List: " + list);
    }
}

Using a traditional loop

To explicitly copy the elements from the set to the list, we may use the good old for a loop. The brute force or naive method is making an empty list and then adding each element of the set to it.

Algorithm:

  • Obtain the set that will be transformed.
  • Make an empty list.
  • Fill in the list with each element from the set.
  • Return the resultant List created.
import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>(intList);
        for (int i : a)
            arr.add(i);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }   
}

The for loop iterates across the set, adding each element to the list.

Example: Program for converting a Set to List in Java 8
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create an empty list
		List<T> list = new ArrayList<>();

		// push each element in the set into the list
		for (T t : set)
			list.add(t);

		// return the list
		return list;
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> hash_Set = new HashSet<String>();

		// Add elements to set
		hash_Set.add("Code");
		hash_Set.add("For");
		hash_Set.add("Underscored");
		hash_Set.add("Python");
		hash_Set.add("Set");

		// Print the Set
		System.out.println("Set: " + hash_Set);

		// construct a new List from Set
		List<String> list = convertSetToList(hash_Set);

		// Print the List
		System.out.println("List: " + list);
	}
}
Example 3: Using a traditional loop
import java.util.*;
import java.util.stream.*;
  
class example {
    
    // Generic function to convert set to list
    public static <T> List<T> convertSetToList(Set<T> set)
    {
        // create an empty list
        List<T> list = new ArrayList<>();
  
        // push each element in the set into the list
        for (T t : set)
            list.add(t);
  
        // return the list
        return list;
    }
    public static void main(String args[])
    {
  
        // Create a Set using HashSet
        Set<String> codeSet = new HashSet<String>();
  
        // Add elements to set
        codeSet.add("Code");
        codeSet.add("Underscored");
        codeSet.add("Set");
        codeSet.add("to");
        codeSet.add("list");
        codeSet.add("example");
  
        // Print the Set
        System.out.println("Set: " + codeSet);
  
        // construct a new List from Set
        List<String> list = convertSetToList(codeSet);
  
        // Print the List
        System.out.println("List: " + list);
    }
}

Use the addAll() function to add all items to a list.

AddAll() is a list method that adds multiple values to the list at once. This operation may be familiar to you from its use in merging two lists. addAll() can also add a set’s elements to a list.

import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>();
        arr.addAll(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

}

The collect() method of the Stream API

From Java 8, Stream.collect() is supported. All Stream elements are collected into a List object via the ToList collector. In Java 8, you can convert a set to a list by using Set.stream() to convert the set to a sequential Stream, then using a Collector to gather the input elements into a new List.

// This is Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return set.stream().collect(Collectors.toList());
}

We can use Collectors.toCollection() to specify the desired Collection because Collectors.toList() does not guarantee the type of the List returned:

// This a Generic method to convert a set to `ArrayList`
public static <T> List<T> convertToList(T[] arr) {
    return set.stream().collect(Collectors.toCollection(ArrayList::new));
}

Algorithm:

  • Obtain the HashMap that will be transformed.
  • Make a stream out of the Set
  • Convert the set to a list and add it to your collection.
  • Return the List that was collected.
import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
        arr = intList.stream().collect(Collectors.toList());
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

The type, mutability, serializability, and thread safety of the List returned are not guaranteed. That is according to the documentation for stream.collect(). Use toCollection(Supplier) if you need greater control over the returned List.

Use toCollection(ArrayList::new) to specify the list type

pubimport java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
  arr = intList.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Example: Program for converting a HashMap to TreeMap in Java

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		return set

			// Create stream from the Set
			.stream()

			// Convert the set to list and collect it
			.collect(Collectors.toList());
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> languageSet = new HashSet<String>();

		// Add elements to set
		languageSet.add("Java");
		languageSet.add("Python");
		languageSet.add("HTML");
		languageSet.add("JavaScript");
		languageSet.add("Kotlin");

		// Print the Set
		System.out.println("Set: " + languageSet);

		// construct a new List from Set
		List<String> list = convertSetToList(languageSet);

		// Print the List
		System.out.println("List: " + list);
	}
}

Using the List.copyOf() function

The copyOf() method is available in Java 10 and later. The method returns an immutable List containing the elements of the supplied Collection in the order in which they were iterated. There can’t be any null elements in the list. If the set includes ‘ null, ‘the method throws a null pointer exception.

import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
        arr = List.copyOf(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Attempting to convert a set to a list after adding a null:

import java.util.*;
import java.util.stream.Collectors;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList  = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        intList.add(null);
 
     List<Integer> arr;
 
        arr = List.copyOf(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

If you try to add a new element to an immutable list, you’ll get an error similar to this. To convert a set with a null element to a list, use the addAll() method:

import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        intList.add(null);
 
     List<Integer> arr = new ArrayList<>();
     arr.addAll(intList);
 
      //  arr = List.copyOf(intList);
        System.out.println(intList);
        System.out.println(arr.get(1));
    }
}

It’s worth noting that the null is at the top of the list.

Example: Using the List.copyOf() function

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

Using Guava Library List.newArrayList(set)

Lists.newArrayList(set) generates a mutable ArrayList instance using the supplied set’s elements. If we need to add or remove elements later, or if some of the components are null, this is better.

// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return Lists.newArrayList(set);
}

ImmutableList.copyOf is another option that returns an immutable list containing the set of elements supplied. When mutability isn’t required, you should use this.

// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return ImmutableList.copyOf(set);
}

Algorithm:

  • Obtain the Set that will be transformed.
  • Using Lists, create a new List.
  • You can create an array list by supplying the set as an argument to the Guava library’s newArrayList() function.
  • Return the List that was created.
Example: Program for converting HashMap to TreeMap in Java
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		return Lists.newArrayList(set);
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> languageSet = new HashSet<String>();

		// Add elements to set
		languageSet.add("Java");
		languageSet.add("Python");
		languageSet.add("HTML");
		languageSet.add("JavaScript");
		languageSet.add("Kotlin");

		// Print the Set
		System.out.println("Set: " + languageSet);

		// construct a new List from Set
		List<String> list = convertSetToList(languageSet);

		// Print the List
		System.out.println("List: " + list);
	}
}
Example: Conversion using Guava

public void usingGuavaToConvertSetToList() {

    Set<Integer> positionList = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = Lists.newArrayList(positionList);
}

It is pretty similar to the java technique but with less code duplication.

Using the Apache Commons Collections

Then, to convert between a List and a Set, we’ll utilize the Commons Collections API:

public void usingCommonsCollectionsToConvertSetToList() {

Set<Integer> positionSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
List<Integer> targetList = new ArrayList<>(6);
CollectionUtils.addAll(targetList, positionSet);

}

Conclusion

The java.util.Collection interface is extended by a Java set, which is part of java.util package. There can be no duplicate items in a Java set, and only one null element is allowed. Further, a Java list is a collection of things arranged in a specific order. In fact, a Java list, unlike a Java Set, can have duplicate values.

We saw some highly creative approaches to converting a set to a list. It’s crucial to pay attention to each technique’s type of list. The copyOf() method, for example, creates an immutable list that cannot include null elements. Stream.collect(), on the other hand, makes no guarantees. Nevertheless, the constructor and addAll() functions are the most reliable of the batch.

You may also like

Leave a Comment