How to Convert ArrayList to LinkedHashSet in Java?

ArrayList is a data structure that overcomes the shortcomings of the common array in Java wherein the size has to be explicitly specified beforehand. The length of the array data structure cannot be modified which is taken care of the ArrayList data structure. This data structure is also known as the dynamic array and can grow or be modified as the need be. It is a class under the Collections framework and can be included in the java program by importing java.util package. 

LinkedHashSet is an enhanced version of the traditional HashSet class in Java by providing the added functionality of ordering which was missing in the HashSet. It maintains the order in which the elements were inserted into it, unlike the HashSet where the ordering was unpredictable. It is implemented using a doubly-linked list and can be iterated over using the iterator.

This article deals with the conversion of ArrayList to LinkedHashSet using 4 different approaches which are listed as follows :

1. Passing the ArrayList as a parameter during the initialization of the LinkedHashSet constructor.
2. Using the addAll() method of the LinkedHashSet class.
3. Using the add() method of the LinkedHashSet class while iterating over all the elements of the ArrayList.
4. Using stream to first convert the ArrayList to Set which is further converted to LinkedHashSet.

Approach 1

Using this approach we merely, pass the ArrayList as a parameter while initializing the LinkedHashSet class

Syntax

LinkedHashSet(Collection C): Used in initializing the HashSet with the elements of the collection C.

LinkedHashSet<E> hs = new LinkedHashSet<E>(Collection c);

Example

Java

// java program to convert ArrayList
// to LinkedHashSet

// importing the utils package
import java.util.*;

class GFG {

    // defining the method
    void arrayListToLinkedHashSet()
    {

        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();

        // adding values in the ArrayList
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");

        // printing the list
        System.out.println("The array list : " + arrayList);

        // initializing the LinkedHashSet class
        // passing the ArrayList as parameter
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<String>(arrayList);

        // printing the LinkedHashSet
        System.out.println("The converted "
                           + "Linked Hash Set : "
                           + linkedHashSet);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // instantiating the class
        GFG ob = new GFG();

        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

Output

The array list : [Geeks, For, Geeks]
The converted Linked Hash Set : [Geeks, For]

Explanation:
The ArrayList contains three entries which are [Geeks, For, Geeks]. This is converted to an ordered set and only contains two values: Geeks and For. Since Set don’t allow multiple similar values.

Approach 2

Using this approach, we use the predefined method addAll() of the LinkedHashSet class after initializing it to populate the LinkedHashSet.

Syntax:

LinkedHashSet.addAll(Collection C)

Parameters: Parameter C is a collection of any type that is to be added to the set.

Return Value: The method returns true if it successfully appends the elements of the collection C to this Set otherwise it returns False.

Example

Java

// java program to convert ArrayList
// to LinkedHashSet

// importing the java.utils package
import java.util.*;

class GFG {

    // defining the method
    void arrayListToLinkedHashSet()
    {

        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();

        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");

        // printing the list
        System.out.println("The Array List : " + arrayList);

        // initializing the LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>();

        // using the addAll() to
        // fill the HashSet
        linkedHashSet.addAll(arrayList);

        // printing the LinkedHashSet
        System.out.println("The Linked "
                           + "Hash Set : " + linkedHashSet);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // instantiating the class
        GFG ob = new GFG();

        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

Output

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Approach 3

Using this approach, we iterate over the ArrayList and in each iteration fill the LinkedHashSet with the value using the predefined add() method of the LinkedHashSet class.

Syntax:

Hash_Set.add(Object element)

Parameters: The parameter element is of the type LinkedHashSet and refers to the element to be added to the Set.

Return Value: The function returns True if the element is not present in the LinkedHashSet otherwise False if the element is already present in the LinkedHashSet.

Example

Java

// java program to convert ArrayList
// to LinkedHashSet

// importing the java.utils package
import java.util.*;

class GFG {

    // defining the method
    void arrayListToHashSet()
    {

        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();

        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");

        // printing the list
        System.out.println("The Array List : " + arrayList);

        // declaring the iterator
        Iterator<String> itr = arrayList.iterator();

        // initializing the LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>();

        // loop to iterate through the ArrayList
        while (itr.hasNext())

            // using the add()
            // to fill the HashSet
            linkedHashSet.add(itr.next());

        // printing the LinkedHashSet
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // instantiating the class
        GFG ob = new GFG();

        // calling the method
        ob.arrayListToHashSet();
    }
}

Output

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Approach 4

Under this approach, we first convert the ArrayList to a stream which is then converted to a Set. This Set is finally converted to a LinkedHashSet. Stream class is only available for JDK versions 8 or above.

Example

Java

// java program to convert ArrayList
// to LinkedHashSet

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

class GFG {

    // defining the method
    void arrayListToLinkedHashSet()
    {

        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();

        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");

        // printing the list
        System.out.println("The Array List : " + arrayList);

        // creating a stream from the ArrayList
        Stream<String> stream = arrayList.stream();

        // creating a set from the Stream
        // using the predefined toSet()
        // method of the Collectors class
        Set<String> set
            = stream.collect(Collectors.toSet());

        // converting the Set to
        // LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>(set);

        // printing the LinkedHashSet
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // instantiating the class
        GFG ob = new GFG();

        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

Output

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Converting ArrayList Of Custom Class Objects To LinkedHashSet

The above examples illustrate the procedure to convert ArrayList of primitive data types such as Integer, String, and so on. Here, we are going to use the above approaches to convert an ArrayList of custom class objects to LinkedHashSet. An interesting feature of the conversion is that this allows duplication of objects which was not allowed in the above scenarios. The reason for the same being that each time a new object of the same class is created and the equals() method which is used to check elements before entering them in the set when compares the objects, finds unique references since each new object holds a new reference. This allows for the same data to be present in the LinkedHashSet in more than one places.

Example

Java

// java code to convert an ArrayList
// of custom class objects to
// LinkedHashSet

// importing the libraries
import java.util.*;

// the custom class
class Sports {

    // global variable name of type String
    // to hold the name of the sport
    private String name;

    // constructor
    public Sports(String name)
    {

        // initializing the name
        this.name = name;
    }

    // method to return the string
    public String returnString()
    {
        return name + " is a great sport";
    }
}

// primary class
class GFG {

    // declaring the method
    static void arrayListToLinkedHashSet()
    {

        // creating an array list of type
        // class Sports
        ArrayList<Sports> listOfSports
            = new ArrayList<Sports>();

        // adding the new instances of Sports
        // in the array list
        listOfSports.add(new Sports("Football"));
        listOfSports.add(new Sports("Basketball"));
        listOfSports.add(new Sports("Football"));

        // printing the list
        System.out.println("The Array List : "
                           + listOfSports);

        // declaring an iterator of type Sports
        // to iterate over the list
        Iterator<Sports> itr = listOfSports.iterator();

        // iterating over the list
        while (itr.hasNext())

            // printing the contents
            // by calling the returnString()
            System.out.println(itr.next().returnString());

        // initializing the linkedhashset
        // of type Sports
        LinkedHashSet<Sports> linkedHashSet
            = new LinkedHashSet<Sports>(listOfSports);

        // printing the contents of the
        // linked hash set
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);

        // declaring an iterator to iterate
        // over linkedhashset
        Iterator<Sports> itr1 = linkedHashSet.iterator();

        // iterating over the linkedhashset
        while (itr1.hasNext()) {

            // calling the returnString()
            // of Sports
            System.out.println(itr1.next().returnString());
        }
    }

    // Driver Code
    public static void main(String[] args)
    {

        // calling the method
        arrayListToLinkedHashSet();
    }
}

Output

The Array List : [Sports@4e50df2e, Sports@1d81eb93, Sports@7291c18f]
Football is a great sport
Basketball is a great sport
Football is a great sport
The Linked Hash Set : [Sports@4e50df2e, Sports@1d81eb93, Sports@7291c18f]
Football is a great sport
Basketball is a great sport
Football is a great sport

Explanation:
In the first line, the contents of ArrayList are printed which as can be seen are references to class Sports. In the following three lines, the contents of the returnString() method of Sports class are printed. It should be noted that all references are unique and hence the LinkedHashSet allows them even though the contents might be the same. In the following line, the contents of LinkedHashSet is printed which are again references to the class Sports. The lines following that are the returnString() method calls.