Initializing a List in Java
The Java.util.List is a child interface of Collection. It is an ordered collection of objects in which duplicate values can be stored. Since List preserves the insertion order, it allows positional access and insertion of elements. List Interface is implemented by ArrayList, LinkedList, Vector and Stack classes.
List is an interface, and the instances of List can be created in the following ways:
List a = new ArrayList(); List b = new LinkedList(); List c = new Vector(); List d = new Stack();
Below are the following ways to initialize a list:
-
Using List.add() method
Since list is an interface, one can’t directly instantiate it. However, one can create objects of those classes which have implemented this interface and instantiate them.
Few classes which have implemented the List interface are Stack, ArrayList, LinkedList, Vector etc.
Syntax:
List<Integer> list=new ArrayList<Integer>(); List<Integer> llist=new LinkedList<Integer>(); List<Integer> stack=new Stack<Integer>();
Examples:
importjava.util.*;importjava.util.function.Supplier;publicclassGFG {publicstaticvoidmain(String args[]){// For ArrayListList<Integer> list =newArrayList<Integer>();list.add(1);list.add(3);System.out.println("ArrayList : "+ list.toString());// For LinkedListList<Integer> llist =newLinkedList<Integer>();llist.add(2);llist.add(4);System.out.println("LinkedList : "+ llist.toString());// For StackList<Integer> stack =newStack<Integer>();stack.add(3);stack.add(1);System.out.println("Stack : "+ stack.toString());}}Output:ArrayList : [1, 3] LinkedList : [2, 4] Stack : [3, 1]
Double Brace Initialization can also be used to do the above work.
Syntax:
List<Integer> list=new ArrayList<Integer>(){{ add(1); add(2); add(3); }};Examples:
importjava.util.*;publicclassGFG {publicstaticvoidmain(String args[]){// For ArrayListList<Integer> list =newArrayList<Integer>() {{add(1);add(3);} };System.out.println("ArrayList : "+ list.toString());// For LinkedListList<Integer> llist =newLinkedList<Integer>() {{add(2);add(4);} };System.out.println("LinkedList : "+ llist.toString());// For StackList<Integer> stack =newStack<Integer>() {{add(3);add(1);} };System.out.println("Stack : "+ stack.toString());}}Output:ArrayList : [1, 3] LinkedList : [2, 4] Stack : [3, 1]
-
Using Arrays.asList()
- Creating Immutable List
Arrays.asList() creates an immutable list from an array. Hence it can be used to instantiate a list with an array.
Syntax:
List<Integer> list=Arrays.asList(1, 2, 3);
Examples:
importjava.util.Arrays;importjava.util.List;publicclassGFG {publicstaticvoidmain(String args[]){// Instantiating List using Arrays.asList()List<Integer> list = Arrays.asList(1,2,3);// Print the listSystem.out.println("List : "+ list.toString());}}Output:List : [1, 2, 3]
- Creating Mutable List
Syntax:
List<Integer> list=new ArrayList<>(Arrays.asList(1, 2, 3));
Examples:
importjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;publicclassGFG {publicstaticvoidmain(String args[]){// Creating a mutable list using Arrays.asList()List<Integer> list =newArrayList<>(Arrays.asList(1,2,3));// Print the listSystem.out.println("List : "+ list.toString());list.add(5);// Print the listSystem.out.println("Modified list : "+ list.toString());}}Output:List : [1, 2, 3] Modified list : [1, 2, 3, 5]
- Creating Immutable List
-
Using Collections class methods
There are various methods in Collections class that can be used to instantiate a list. They are:
-
Using Collections.addAll()
Collections class has a static method addAll() which can be used to initialize a list. Collections.addAll() take in any number of elements after it is specified with the Collection in which the elements are to be inserted.
Syntax:
List<Integer> list = Collections.EMPTY_LIST; Collections.addAll(list = new ArrayList<Integer>(), 1, 2, 3, 4);
Examples:
importjava.util.*;publicclassGFG {publicstaticvoidmain(String args[]){// Create an empty listList<Integer> list =newArrayList<Integer>();// Instantiating list using Collections.addAll()Collections.addAll(list,1,2,3,4);// Print the listSystem.out.println("List : "+ list.toString());}}Output:List : [1, 2, 3, 4]
-
Using Collections.unmodifiableList()
Collections.unmodifiableList() returns a list which can’t be altered i.e. it can neither add or delete an element. Any attempt to modify the list will result in an UnsupportedOperationExample.
Syntax:
List<Integer> list = Collections .unmodifiableList(Arrays.asList(1, 2, 3));Example 1:
importjava.util.*;publicclassGFG {publicstaticvoidmain(String args[]){// Creating the listList<Integer> list = Collections.unmodifiableList(Arrays.asList(1,2,3));// Print the listSystem.out.println("List : "+ list.toString());}}Output:List : [1, 2, 3]
Example 2:
importjava.util.*;publicclassGFG {publicstaticvoidmain(String args[]){try{// Creating the listList<Integer> list = Collections.unmodifiableList(Arrays.asList(1,2,3));// Print the listSystem.out.println("List : "+ list.toString());// Trying to modify the listSystem.out.println("Trying to modify the list");list.set(0, list.get(0));}catch(Exception e) {System.out.println("Exception : "+ e);}}}Output:List : [1, 2, 3] Trying to modify the list Exception : java.lang.UnsupportedOperationException
-
Using Collections.singletonList()
Collections.singletonList() returns an immutable list consisting of one element only.
Syntax:
List<Integer> list = Collections.singletonList(2);
Example 1:
importjava.util.*;publicclassGFG {publicstaticvoidmain(String args[]){// Creating the listList<Integer> list = Collections.singletonList(2);// Print the listSystem.out.println("List : "+ list.toString());}}Output:List : [2]
-
-
Using Java 8 Stream
With the introduction of Stream and functional programming in Java 8, now one can construct any stream of objects and then collect them as a list.
Syntax:
1. List<Integer> list = Stream.of(1, 2, 3) .collect(Collectors.toList()); 2. List<Integer> list = Stream.of(1, 2, 3) .collect(Collectors.toCollection(ArrayList::new)); 3. List<Integer> list = Stream.of(1, 2, 3, 4) .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));Examples:
importjava.util.*;importjava.util.stream.Collectors;importjava.util.stream.Stream;publicclassGFG {publicstaticvoidmain(String args[]){// Creating a List using Syntax 1List<Integer> list1 = Stream.of(1,2,3).collect(Collectors.toList());// Printing the listSystem.out.println("List using Syntax 1: "+ list1.toString());// Creating a List using Syntax 2List<Integer> list2 = Stream.of(3,2,1).collect(Collectors.toCollection(ArrayList::new));// Printing the listSystem.out.println("List using Syntax 2: "+ list2.toString());// Creating a List using Syntax 3List<Integer> list3 = Stream.of(1,2,3,4).collect(Collectors.collectingAndThen(Collectors.toList(),Collections::unmodifiableList));// Printing the listSystem.out.println("List using Syntax 3: "+ list3.toString());}}Output:List using Syntax 1: [1, 2, 3] List using Syntax 2: [3, 2, 1] List using Syntax 3: [1, 2, 3, 4]
-
Using Java 9 List.of()
Java 9 introduced List.of() method which takes in any number of arguments and constructs a compact and unmodifiable list out of them.
Syntax:
List<Integer> unmodifiableList = List.of(1, 2, 3);
Examples:
importjava.util.List;publicclassGFG {publicstaticvoidmain(String args[]){// Creating a list using List.of()List<Integer> unmodifiableList = List.of(1,2,3);// Printing the ListSystem.out.println("List : "+ unmodifiableList.toString());}}OUTPUT:
[1, 2, 3]
