Initializing a List in Java

One of Collection's derived interfaces is Java.util.List. It is an ordered group of objects that allows for the storing of duplicate values. List enables positional access and element insertion since it maintains the insertion order. The Vector, Stack, LinkedList, and ArrayList classes to implement the List Interface.

Initializing a list in Java is a crucial step in the development process as it defines the initial state of the list and prepares it for further operations. There are various ways to initialize a list in Java, and the choice depends on the specific requirements of the project.

List is an interface, and the following methods can be used to create instances of List:

List l1 = new ArrayList();
List l2 = new LinkedList();
List l3 = new Vector(); 
List l4 = new Stack();

The following are the different approaches to initialize list.

Using List.add() method
Using Arrays.asList()
Using Collections class methods
Using Java 8 Stream
Using Java 9 List.of()

Approach: Using List.add() method

List cannot be instantiated directly because it is an interface. On the other hand, objects of the classes that have defined this interface can be created and instantiated.

Add(): The add() method is a commonly used method in Java that is used to add elements to a collection or list. This method is available for several types of collections in Java, including List, Set, and Map.

A few examples of classes that have implemented the List interface include Vector, LinkedList, Stack, and ArrayList.

Syntax:

List<Integer> array_list1=new ArrayList<Integer>();
List<Integer> linked_list1 =new LinkedList<Integer>();
List<Integer> stack_1 =new Stack<Integer>();

There are two cases in this approach.

General method
Double brace initialization

Case 1: General method

Implementation:

FileName: GeneralMethod.java

import java.io.*;
import java.util.*; 
import java.util.function.Supplier; 
public class GeneralMethod 
{ 
      public static void main(String args[]) 
      { 
	// creation of  ArrayList 
	List<Integer> array_list1 = new ArrayList<Integer>(); 
	array_list1.add(10); 
	array_list1.add(30); 
	System.out.println("The ArrayList is : " + array_list1.toString()); 
	// Creation of LinkedList 
	List<Integer> linked_list1 = new LinkedList<Integer>(); 
	linked_list1.add(20); 
	linked_list1.add(40); 
	System.out.println("The LinkedList is : " + linked_list1.toString()); 
	// Creation of Stack 
	List<Integer> Stack_1 = new Stack<Integer>(); 
	Stack_1.add(30); 
	Stack_1.add(10); 
	System.out.println("The Stack is : " + Stack_1.toString()); 
      } 
}

Output:

The ArrayList is : [10, 30]
The LinkedList is : [20, 40]
The Stack is : [30, 10]

Case 2: Double Brace Initialization

Implementation:

FileName: Doublebrace.java

import java.io.*;
import java.util.*; 
public class Doublebrace 
{ 
	public static void main(String args[]) 
	{ 
		// creating of a ArrayList 
		List<Integer> array_list1 = new ArrayList<Integer>() {{ 
			add(10); 
			add(30); 
			} }; 
		System.out.println("The ArrayList is : " + array_list1 .toString()); 
		// creating of a LinkedList 
		List<Integer> linked_list1 = new LinkedList<Integer>() {{ 
			add(20); 
			add(40); 
			} }; 
		System.out.println("The LinkedList is : " + linked_list1.toString()); 
		// Creating of a Stack 
		List<Integer> stack_1 = new Stack<Integer>() {{ 
			add(30); 
			add(10); 
			} }; 
		System.out.println("The Stack is : " + stack_1.toString()); 
	} 
}

Output:

The ArrayList is : [10, 30]
The LinkedList is : [20, 40]
The Stack is : [30, 10]

Approach: Using Arrays.asList()

There are mainly two cases present in this approach.

By creating an Immutable List
By creating a Mutable List

Case 1: By creating an Immutable List

We can use Arrays.asList() to convert an array into an immutable list. So, it is possible to utilise an array to instantiate a list.

Implementation:

FileName: ImmutableList.java

import java.util.Arrays; 
import java.util.List; 
import java.io.*;
public class ImmutableList 
{ 
     public static void main(String args[]) 
     { 
        // Arrays.asList() is used to instantiate a list. 
	List<Integer> immutable_list1 = Arrays.asList(10, 20, 30); 
	System.out.println("The List is : " + immutable_list1.toString()); 
           List<Integer> immutable_list2 = Arrays.asList(60, 20, 50); 
	System.out.println("The List is : " + immutable_list2.toString());
       } 
}

Output:

The List is : [10, 20, 30]
The List is : [60, 20, 50]

Case 2: By creating a Mutable List

Syntax:

List<Integer> list_1=new ArrayList<>(Arrays.asList(element 1, element 2, element 3));

Implementation:

FileName: Mutablelist.java

import java.io.*;
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 
public class Mutablelist 
{ 
     public static void main(String args[]) 
     { 
	// here an Arrays.asList() is used to create mutable lists.
	List<Integer> array_list1 = new ArrayList<>( 
	Arrays.asList(10, 20, 30)); 
	System.out.println("The first created List : " + array_list1.toString());
	array_list1.add(50); 
	array_list1.add(40);
	System.out.println("The Modified list is given by : " + array_list1.toString()); 
      } 
}

Output:

The first created List : [10, 20, 30]
The Modified list is given by : [10, 20, 30, 50, 40]

Approach: Using Collections class methods

A list can be instantiated using a variety of methods in the Collections class. They are as follows:

By using Collections.addAll()
By using Collections.unmodifiableList()
By using Collections.singletonList()

Case 1: Using Collections.addAll()

The static function addAll() in the Collections class can be used to initialise a list. Any amount of elements can be entered into Collections.addAll() once the Collection in which the elements are to be inserted is defined.

Syntax:

List<Integer> Linked_list1 = Collections.EMPTY_LIST;
Collections.addAll(Linked_list1 = new ArrayList<Integer>(), 10, 20, 30, 40);

Implementation:

FileName: CollectionsAddAll.java

import java.io.*;
import java.util.*; 
public class CollectionsAddAll 
{ 
     public static void main(String args[]) 
     { 
	// Creation of an Empty list
	List<Integer> Linked_list = new ArrayList<Integer>(); 
	// Using Collections to instantiate the list.AddAll. 
	Collections.addAll(Linked_list, 10, 20, 30, 40); 
	System.out.println("The List is given by : " + Linked_list.toString()); 
     } 
}

Output:

The List is given by : [10, 20, 30, 40]

Case 2: By using Collections.unmodifiableList()

The list returned by Collections.unmodifiableList() cannot be changed; that is, no element can be added or removed. An UnsupportedOperationExample will be generated if there is any attempt to alter the list.

Syntax:

List<Integer> list = Collections
       .unmodifiableList(Arrays.asList(10, 20, 30, 40));

Implementation:

FileName: UnmodifableList.java

import java.io.*;
import java.util.*; 
public class UnmodifableList 
{ 
      public static void main(String args[]) 
      { 
	// Create the list 
	List<Integer> Linked_list = Collections.unmodifiableList( 
	Arrays.asList(10, 20, 30)); 
	System.out.println("The List is given by : " + Linked_list.toString()); 
      } 
}

Output:

The List is given by : [10, 20, 30]

Case 3: By using Collections.singletonList()

Collections.singletonList() returns back an unchangeable list with just one element.

Syntax:

Implementation:

FileName: SingletonList.java

import java.util.*; 
import java.io.*;
public class SingletonList 
{ 
     public static void main(String args[]) 
     { 
	// Create the list 
	List<Integer> Linked_list = Collections.singletonList(10); 
	System.out.println("The List is given by : " + Linked_list.toString()); 
     } 
}

Output:

The List is given by : [10]

Approach: Using Java 8 Stream

As of Java 8, one can create any stream of objects and then compile them into a list by using the addition of Stream and functional programming.

The Stream interface offers the toList() method, which is an abstraction to collect the Stream elements in the form of an immutable Java List. The toList() method returns a new List containing all Stream elements. Alternatively, we can use toCollection() method of the Collectors class to provide a List instance. The toCollection() collects all Stream elements into the given List and returns it.

Syntax:

List<Integer> Linked_list  = Stream.of(10, 20, 30, 40) .collect(Collectors.toList());
List<Integer> Linked_list  = Stream.of(10, 20, 30, 40).collect(Collectors.toCollection(ArrayList::new));
List<Integer> list = Stream.of(10, 20, 30, 40).collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));

Implementation:

FileName: java8Stream.java

import java.util.*; 
import java.util.stream.Collectors; 
import java.util.stream.Stream; 
import java.io.*;
public class java8Stream 
{ 
     public static void main(String args[]) 
     { 
	// Creating the List by using Syntax 1 
	List<Integer> list1 = Stream.of(10, 20, 30, 40) .collect(Collectors.toList()); 
	System.out.println("The List using Syntax 1 is given by : "
+ list1.toString()); 
	// Creating the List by using Syntax 2
	List<Integer> list2 = Stream .of(10, 20, 30, 40) .collect(Collectors .toCollection(ArrayList::new)); 
	System.out.println("The List using Syntax 2 is given by : "
	+ list2.toString()); 
	// Creating the List by using Syntax 3
	List<Integer> list3 = Stream .of(10, 20, 30, 40) .collect(Collectors .collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); 
	System.out.println("The List using Syntax 3 is given by : "
	+ list3.toString()); 
     } 
}

Output:

The List using Syntax 1 is given by : [10, 20, 30, 40]
The List using Syntax 2 is given by : [10, 20, 30, 40]
The List using Syntax 3 is given by : [10, 20, 30, 40]

Approach: Using Java 9 List.of()

The introduction of Java 9 The List.of() function creates a reduced to, immutable list from any number of arguments it receives.

Java 9 introduced a factory method in the List class that returns an instance of an immutable ArrayList containing the given element. This is the most straightforward way of creating and initiating an ArrayList in the same line.

Syntax:

Implementation:

FileName: Java9Example.java

import java.io.*;
import java.util.List; 
public class Java9Example 
{ 
      public static void main(String args[]) 
      { 
	// Creating a list using List.of() 
	List<Integer> unmodifiableList = List.of(10, 20, 30, 40); 
	System.out.println("The List is given by : " + unmodifiableList.toString()); 
     } 
}

Output: