Java List Interface with Example

In this tutorial, we will discuss the List interface in Java and see the methods provided by the List interface, its implementations, and usage scenarios.

👉 What is List Interface in Java?

List is a part of the Java Collections Framework. It was introduced in the JDK 1.2 version and is available in the java.util package. The List interface extends the Collection interface, inheriting its methods and adding specific ones for list operations.

A List is an ordered collection of elements that allows us to store and access elements sequentially by their index. A List also allows us to insert null and duplicate elements.

The List interface provides a special iterator, called a ListIterator, that allows element insertion and replacement and bidirectional access in addition to the normal operations that the Iterator interface provides.

The implementation classes of the List interface are ArrayList, LinkedList, Stack, and Vector. The ArrayList and LinkedList are widely used in Java programming. The Vector class has been deprecated since Java 5.

👉 List Interface important features:

👉 Java List Interface Hierarchy

The complete List interface hierarchy can be seen in the previous section; the List interface extends the Collection interface, which in turn extends the Iterable interface.

👉 Java List Interface Declaration

The List interface is implemented by ArrayList, LinkedList, Vectors and Stack classes in Java.

All the concrete classes of List Interface can access all the methods of List Interface.

Sun Microsystems kept all the common functionality in the List Interface to prevent duplicate methods and better control functionality.

👉 Uses of List Interface with concrete classes

  
  List<Integer> arrayList = new ArrayList<>();
  
  List<Integer> linkedList = new LinkedList<>();
  
  List<Integer> vector = new Vector<>();
  
  List<Integer> stack = new Stack<>();

As we already mentioned we cannot create an object of List Interface so here we are creating the reference object of List.

👉 Example : A sample program of List Interface using ArrayList

  
  import java.util.ArrayList;
  import java.util.List;
  class ListExample {
    public static void main(String[] args){
      // Creating a list
      List<String> countries = new ArrayList<>();
      // Adding elements in the list
      countries.add("India");
      countries.add("Canada");
      countries.add("US");
      countries.add("England");
      System.out.println("List Elements: " + countries);
    }
  }

👉 Methods in List Interface

Java List Interface Methods Examples

The Java List interface provided methods are implemented in the below given examples. Let's go through the examples one by one and understand the uses for each method.

Method	Description
boolean add ( E e)	Adds the specified element to the end of the list.
void add(int index, E element)	Inserts the specified element at the specified index in the list.
boolean addAll(Collection<? extends E> c)	Adds all the elements in the specified collection to the end of the list, in the order returned by the iterators of the specified collection
boolean addAll(int index, Collection<? extends E> c)	Inserts all elements in the specified collection at the specified position in the list.
void clear()	Remove all elements from the list.
boolean contains(Object o)	Returns true if the specified element is included in the list.
boolean containsAll(Collection<?> c)	Returns true if all elements of the specified collection are included in the list.
boolean equals(Object o)	Compares whether the specified object is equal to the list.
E get(int index)	Returns the element at the specified position in the list.
int hashCode()	Returns the hash code value for this list.
int indexOf(Object o)	Returns the index of the position where the specified element was first found in this list. Returns -1 if the specified element is not in the list.
boolean isEmpty()	Returns true if there are no elements in the list.
Iterator<E> iterator()	Returns an iterator that iterates the elements in the list in the proper order.
int lastIndexOf(Object o)	Returns the index of the position where the specified element was last found in this list. Returns -1 if the specified element is not in the list.
ListIterator<E> listIterator()	Returns a list iterator that iterates through the elements in the list (in the proper order).
ListIterator<E> listIterator(int index)	Returns a list iterator that iterates (in the proper order) the elements in the list, starting at the specified position in the list.
E remove(int index)	Deletes the element at the specified position in the list.
boolean remove(Object o)	If the specified element is in this list, remove the first one from the list.
boolean removeAll(Collection<?> c)	Removes all elements from the specified collection from the list.
default void replaceAll(UnaryOperator<E> operator)	Replace each element in the list with the result of applying the operator to that element.
boolean retainAll(Collection<?> c)	Keeps only the elements contained in the specified collection in the list.
E set(int index, E element)	Replaces the element at the specified position in the list with the specified element.
int size()	Returns the number of elements in the list.
default void sort(Comparator<? super E> c)	It has been designated Comparatorin accordance with, but the order shown, and then sort the list.
default Spliterator <E> spliterator ()	SpliteratorCreate for the elements in this list .
List<E> subList(int fromIndex, int toIndex)	Returns a view of the part of the list from the specified fromIndex (included) to toIndex (not included).
Object[] toArray()	Returns an array containing all the elements in the list in the proper order (first element to last element).
<T> T[] toArray(T[] a)	Returns an array containing all the elements in the list in the proper order (first element to last element). The run-time type of the returned array will be the type of the specified array.

  
  import java.util.List;
  import java.util.ArrayList;
  import java.util.Arrays;
  public class ListAddElements {
    public static void main(String[] args) {
      // Creating a list
      List<Integer> list = new ArrayList<>();
      
      // Adding elements in the list
      list.add(100);
      list.add(200);
      list.add(400);
      list.add(500);
      System.out.println("List elements: " + list);
      
      // Adding element at the required index position in the list
      list.add(2, 300);
      System.out.println("List elements after adding elements at index 2 : " + list);
      
      // Creating another list
      List<Integer> childList = new ArrayList<>();
      childList.add(600);
      childList.add(700);
      
      // Appends all of the elements in the specified collection to end of the list
      list.addAll(childList);
      
      // Appends all of the elements in the specified collection into the list
      list.addAll(3, childList);
      
      // Printing the value
      System.out.println("List elements after adding another list : " + list);
      
      // Adding the elements through array
      list.addAll(Arrays.asList(1000, 2000, 3000, 4000));
      
      // List Declaration, Instantiation and Initialization in a single statement
      List<Character> ls = new ArrayList<>(Arrays.asList('A', 'B', 'C', 'D'));
      
      // Printing list values
      System.out.println("List elements : " + ls);
    }
  }

List elements: [100, 200, 400, 500]
List elements after adding elements at index 2 : [100, 200, 300, 400, 500]
List elements after adding another list : [100, 200, 300, 600, 700, 400, 500, 600, 700]
List elements : [A, B, C, D]

  
  import java.util.List;
  import java.util.ArrayList;
  public class ListGetMethodExample {
    public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      
      list.add("India");
      list.add("USA");
      list.add("Canada");
      list.add("South Africa");
      list.add("Sri Lanka");
      
      // Returns the element at the specified position in the list.
      System.out.println("List element at index 3 : " + list.get(3));
    }
  }

  
  import java.util.List;
  import java.util.ArrayList;
  public class UpdateElementsInList {
    public static void main(String[] args) {
      
      // Creating a list
      List<Integer> list = new ArrayList<>();
        
      // Adding elements in the list
      list.add(100);
      list.add(200);
      list.add(400);
      list.add(400);
      System.out.println("List elements: " + list);
      // Replaces the element at the specified position in this list.
      list.set(2, 300);
      System.out.println("List after update the element: " + list);
    }
  }

List elements: [100, 200, 400, 400]
List after update the element: [100, 200, 300, 400]

  
  import java.util.List;
  import java.util.ArrayList;
  public class RemoveElementsFromList {
    public static void main(String[] args) {
      // Creating a list
      List<String> list = new ArrayList<>();
        
      list.add("Java");
      list.add("Hibernate");
      list.add("Kafka");
      list.add("MongoDB");
      list.add("Jenkins");
      list.add("MySQL");
      list.add("JSF");
      list.add("Spring");
      list.add("Microservices");
      
      System.out.println("List elements: " + list);
      
      // Removes the element at the specified index in the list.
      list.remove(3);
      System.out.println("List after calling remove(int index) method: " + list);
      
      // Removes the first occurrence of the specified element from the List
      list.remove("JSF");
      System.out.println("List after calling remove(Object o) method: " + list);
      
      // Creating another list
      List<String> childList = new ArrayList<>();
        
      childList.add("Kafka");
      childList.add("MySQL");
      childList.add("Microservices");
      
      // Removes from this list all of its elements that are contained in the
      // specified collection.
      list.removeAll(childList);
      System.out.println("List after calling removeAll(Collection c) method: " + list);
      
      // Removes all of the elements of this collection that satisfy the given predicate.
      list.removeIf(n -> (n.charAt(0) == 'J')); // Removing names start with J
      
      // Now finally printing the list
      System.out.println("After all remove() methods, final list elements: ");
      for (String course : list) {
        System.out.println(course);
      }
    }
  }

List elements: [Java, Hibernate, Kafka, MongoDB, Jenkins, MySQL, JSF, Spring, Microservices]
List after calling remove(int index) method: [Java, Hibernate, Kafka, Jenkins, MySQL, JSF, Spring, Microservices]
List after calling remove(Object o) method: [Java, Hibernate, Kafka, Jenkins, MySQL, Spring, Microservices]
List after calling removeAll(Collection c) method: [Java, Hibernate, Jenkins, Spring]
After all remove() methods, final list elements:
Hibernate
Spring

  
  import java.util.List;
  import java.util.ArrayList;
  import java.util.Arrays;
  public class ListUtilityMethods {
    public static void main(String[] args) {
      
      List<String> list = new ArrayList<>(
      Arrays.asList("India", "USA", "Canada", "South Africa", "Sri Lanka"));
      
      // Returns 'true' if list contains the specified element otherwise 'false'
      System.out.println(list.contains("Canada")); 	// Output : true
      System.out.println(list.contains("Nepal")); 	// Output : false
      
      List<String> childList = new ArrayList<>(Arrays.asList(
                                            "USA", "Germany", "England", "Japan"));
        
      // Returns 'true' if the list contains all of the elements childList
      System.out.println(list.containsAll(childList)); // Output : false
      
      // List size before calling clear() method
      System.out.println("List Size Before : " + list.size());
      
      // Removes all of the elements from this list.
      list.clear();
      
      // List size after calling clear() method
      System.out.println("List Size After : " + list.size());
    }
  }

List	Set
A List is an ordered collection of elements.	A Set is an unordered collection of elements.
List contains duplicate elements.	Set does not contain duplicate elements.
List accepts any number of nulls as an element.	Set accepts only one null as an element.
List allows positional access to elements.	Set does not allow positional access to elements.
List has one legacy class called Vector.	Set does not have any legacy classes.
List uses ListIterator for traversing the elements in any direction.	ListIterator does not work with Set.
List implementation classes are ArrayList, LinkedList, Vector and Stack.	Set implementation classes are TreeSet, HashSet and LinkedHashSet.

List Interface in Java

👉 What is List Interface in Java?

👉 List Interface important features:

👉 Java List Interface Hierarchy

👉 Java List Interface Declaration

👉 Uses of List Interface with concrete classes

👉 Example : A sample program of List Interface using ArrayList

👉 Methods in List Interface

Java List Interface Methods Examples

List Interface - Interview Questions and Asnwers

Currently No Video available