Convert Set to List in Java

Both Set and List are commonly used collection classes in Java that offer different functionalities. There are situations where you might need to convert a Set to a List to perform specific operations or leverage the features and methods offered by the List interface. In this article, we will explore various approaches to convert a Set to a List in Java, providing detailed explanations and examples with complete code.

1. Using the ArrayList Constructor

The most straightforward approach to converting a Set to a List is utilising the ArrayList constructor that accepts a Collection as a parameter. Here's an example:

SetToListConversion.java

import java.util.*;
public class SetToListConversion {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        List<String> list = new ArrayList<>(set);
        // Displaying the converted List
        for (String item : list) {
            System.out.println(item);
        }
    }
}

Output:

Apple
Orange
Banana

Explanation

In this example, we create a Set of strings named set and add some elements to it. We then create an ArrayList named list by passing the set as a parameter to the ArrayList constructor. This constructor automatically converts the Set to a List, preserving the order of elements. Finally, we iterate over the list and display its contents.

2. Using the addAll() Method

The addAll() method provided by the List interface allows us to append all elements of a Set to an existing List. Here's an example:

SetToListConversion.java

import java.util.*;
public class SetToListConversion {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        List<Integer> list = new ArrayLst<>();
        list.addAll(set);
        // Displaying the converted List
        for (Integer item : list) {
            System.out.println(item);
        }
    }
}

Output:

20
10
30

In this example, we create a Set of integers named set and add some elements to it. We then create an empty ArrayList named list. Using the addAll() method, we append all elements of the set to the list, effectively converting the Set to a List. Finally, we iterate over the list and display its contents.

3. Java 8 Stream API

Java 8 introduced the Stream API, which provides a powerful way to perform operations on collections. We can utilise the Stream API to convert a Set to a List. Here's an example:

SetToListConversion.java

import java.util.*;
import java.util.stream.Collectors;
public class SetToListConversion {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Red");
        set.add("Green");
        set.add("Blue");
        List<String> list = set.stream().collect(Collectors.toList());
        // Displaying the converted List
        for (String item : list) {
            System.out.println(item);
        }
    }
}

Output:

Red
Blue
Green

Explanation

In this example, we create a Set of strings named set and add some elements to it. Using the stream() method, we convert the set to a Stream. We then use the collect() method along with Collectors.toList() to collect the elements of the Stream into a List. The result is stored in the list variable. Finally, we iterate over the list and display its contents.

4. Retaining the Order:

When converting a Set to a List, it's important to consider whether the order of elements needs to be preserved. In the examples provided earlier, we used HashSet as the Set implementation. However, if you require a specific order, such as insertion order or natural ordering, you can use classes like LinkedHashSet or TreeSet for the Set implementation. Here's an example:

SetToListConversion.java

import java.util.*;
public class SetToListConversion {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        List<String> list = new ArrayList<>(set);
        // Displaying the converted List
        for (String item : list) {
            System.out.println(item);
        }
    }
}

Output:

Apple
Banana
Orange

Explanation

In this example, we use a LinkedHashSet as the Set implementation. The elements are added in the order of insertion. By passing this LinkedHashSet to the ArrayList constructor, we ensure that the converted List retains the same order.

5. Performance Considerations

Converting a Set to a List involves creating a new List object and copying the elements. Depending on the size of the Set and the specific implementation of Set and List, the performance of the conversion process can vary. Using the ArrayList constructor or the addAll() method generally provides efficient performance. However, it's worth noting that if you have a large Set and you only need to iterate over the elements without modifying them, using the Stream API approach (set.stream().collect(Collectors.toList())) can offer better performance due to its lazy evaluation nature.

SetToListConversion.java

import java.util.*;
import java.util.stream.Collectors;
public class SetToListConversion {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Red");
        set.add("Green");
        set.add("Blue");
        List<String> list = set.stream().collect(Collectors.toList());
        // Displaying the converted List
        for (String item : list) {
            System.out.println(item);
        }
    }
}

Output:

Red
Blue
Green

Conclusion

Converting a Set to a List in Java is a common requirement when you need to transform a collection while considering order and performance factors. By utilising constructors, methods like addAll(), or the Stream API, you can seamlessly convert a Set to a List, enabling you to leverage the rich functionality the List interface provides. Remember to choose the appropriate approach based on your specific needs, ensuring the preservation of order and considering performance implications.

Next TopicFloyd Triangle in Java

← prev next →