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 :
- Passing the ArrayList as a parameter during the initialization of the LinkedHashSet constructor.
- Using the addAll() method of the LinkedHashSet class.
- Using the add() method of the LinkedHashSet class while iterating over all the elements of the ArrayList.
- 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 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();
}
} |
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 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();
}
} |
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 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();
}
} |
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 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();
}
} |
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 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();
}
} |
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.