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.

listinterfacejava

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:

  1. 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    import java.util.*;
    import java.util.function.Supplier;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // For ArrayList
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(3);
            System.out.println("ArrayList : " + list.toString());
      
            // For LinkedList
            List<Integer> llist = new LinkedList<Integer>();
            llist.add(2);
            llist.add(4);
            System.out.println("LinkedList : " + llist.toString());
      
            // For Stack
            List<Integer> stack = new Stack<Integer>();
            stack.add(3);
            stack.add(1);
            System.out.println("Stack : " + stack.toString());
        }
    }

    chevron_right

    
    

    Output:

    ArrayList : [1, 3]
    LinkedList : [2, 4]
    Stack : [3, 1]
    

    Double Brace Initialisation can also be used to do the above work.

    Syntax:

    List<Integer> list=new ArrayList<Integer>(){{
                            add(1);
                            add(2);
                            add(3);
                              }};
    

    Examples:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // For ArrayList
            List<Integer> list = new ArrayList<Integer>() {{
                add(1);
                add(3);
                } };
            System.out.println("ArrayList : " + list.toString());
      
            // For LinkedList
            List<Integer> llist = new LinkedList<Integer>() {{
                add(2);
                add(4);
                } };
            System.out.println("LinkedList : " + llist.toString());
      
            // For Stack
            List<Integer> stack = new Stack<Integer>() {{
                add(3);
                add(1);
                } };
            System.out.println("Stack : " + stack.toString());
        }
    }

    chevron_right

    
    

    Output:

    ArrayList : [1, 3]
    LinkedList : [2, 4]
    Stack : [3, 1]
    
  2. 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:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.Arrays;
      import java.util.List;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Instantiating List using Arrays.asList()
              List<Integer> list = Arrays.asList(1, 2, 3);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }

      chevron_right

      
      

      Output:

      List : [1, 2, 3]
      
    • Creating Mutable List

      Syntax:

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

      Examples:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.ArrayList;
      import java.util.Arrays;
      import java.util.List;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating a mutable list using Arrays.asList()
              List<Integer> list = new ArrayList<>(
                  Arrays.asList(1, 2, 3));
        
              // Print the list
              System.out.println("List : " + list.toString());
        
              list.add(5);
        
              // Print the list
              System.out.println("Modified list : " + list.toString());
          }
      }

      chevron_right

      
      

      Output:

      List : [1, 2, 3]
      Modified list : [1, 2, 3, 5]
      
  3. Using Collections class methods

    There are various methods in Collections class that can be used to instantiate a list. They are:

    1. 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:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Create an empty list
              List<Integer> list = new ArrayList<Integer>();
        
              // Instantiating list using Collections.addAll()
              Collections.addAll(list, 1, 2, 3, 4);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }

      chevron_right

      
      

      Output:

      List : [1, 2, 3, 4]
      
    2. 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:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating the list
              List<Integer> list = Collections.unmodifiableList(
                  Arrays.asList(1, 2, 3));
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }

      chevron_right

      
      

      Output:

      List : [1, 2, 3]
      

      Example 2:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              try {
                  // Creating the list
                  List<Integer> list = Collections.unmodifiableList(
                      Arrays.asList(1, 2, 3));
        
                  // Print the list
                  System.out.println("List : " + list.toString());
        
                  // Trying to modify the list
                  System.out.println("Trying to modify the list");
                  list.set(0, list.get(0));
              }
        
              catch (Exception e) {
                  System.out.println("Exception : " + e);
              }
          }
      }

      chevron_right

      
      

      Output:

      List : [1, 2, 3]
      Trying to modify the list
      Exception : java.lang.UnsupportedOperationException
      
    3. Using Collections.singletonList()

      Collections.singletonList() returns an immutable list consisting of one element only.

      Syntax:

      List<Integer> list = Collections.singletonList(2);

      Example 1:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating the list
              List<Integer> list = Collections.singletonList(2);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }

      chevron_right

      
      

      Output:

      List : [2]
      
  4. 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // Creating a List using Syntax 1
            List<Integer> list1 = Stream.of(1, 2, 3)
                                      .collect(Collectors.toList());
      
            // Printing the list
            System.out.println("List using Syntax 1: "
                               + list1.toString());
      
            // Creating a List using Syntax 2
            List<Integer> list2 = Stream
                                      .of(3, 2, 1)
                                      .collect(
                                          Collectors
                                              .toCollection(ArrayList::new));
      
            // Printing the list
            System.out.println("List using Syntax 2: "
                               + list2.toString());
      
            // Creating a List using Syntax 3
            List<Integer> list3 = Stream
                                      .of(1, 2, 3, 4)
                                      .collect(
                                          Collectors
                                              .collectingAndThen(
                                                  Collectors.toList(),
                                                  Collections::unmodifiableList));
      
            // Printing the list
            System.out.println("List using Syntax 3: "
                               + list3.toString());
        }
    }

    chevron_right

    
    

    Output:

    List using Syntax 1: [1, 2, 3]
    List using Syntax 2: [3, 2, 1]
    List using Syntax 3: [1, 2, 3, 4]
    
  5. 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    import java.util.List;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // Creating a list using List.of()
            List<Integer> unmodifiableList = List.of(1, 2, 3);
      
            // Printing the List
            System.out.println("List : "
                               + unmodifiableList.toString());
        }
    }

    chevron_right

    
    

    OUTPUT:

    [1, 2, 3]
    


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.