List Interface in Java (original) (raw)

Last Updated : 18 Nov, 2025

The List interface in Java extends the Collection interface and is part of the java.util package. It is used to store ordered collections where duplicates are allowed and elements can be accessed by their index.

• Maintains insertion order
• Allows duplicate elements
• Supports null elements (implementation dependent)
• Supports bidirectional traversal using ListIterator

Declaration of Java List Interface

public interface List extends Collection { }

To use a List, we must instantiate a class that implements it. Example classes that implement it are ArrayList and LinkedList

List list = new ArrayList();

Java `

import java.util.*;

class Geeks {

public static void main(String[] args)
{
    // Creating a List of Strings using ArrayList
    List<String> li = new ArrayList<>();

    // Adding elements in List
    li.add("Java");
    li.add("Python");
    li.add("DSA");
    li.add("C++");

    System.out.println("Elements of List are:");

    // Iterating through the list
    for (String s : li) {
        System.out.println(s);
    }

} }

`

Output

Elements of List are: Java Python DSA C++

The common implementation classes of the List interface are

list-implemented-classes

• **ArrayList:It is implemented using resizable array, offers fast random access but slower insert/delete.
• **LinkedList: It is implemented usingDoubly-linked list, efficient for frequent insertions and deletions.
• **Vector: It is implemented using Legacy synchronized dynamic array, thread-safe but slower.
• **Stack: It is implemented using a LIFO (Last-In-First-Out) subclass of Vector for stack operations.

Java List - Operations

List can be used only with a class that implements this interface. Now, let's see how to perform a few frequently used operations on the List.

1. Adding Elements

To add an element to the list, we can use the add() method. This method is overloaded to perform multiple operations based on different parameters.

• **add(Object o): This method is used to add an element at the end of the List.
• **add(int index, Object o): This method is used to add an element at a specific index in the List Java `

import java.util.*;

class Geeks {

public static void main(String args[])
{
    List<String> al = new ArrayList<>();

    // Adding elements to object of List interface Custom elements
    al.add("Geeks");
    al.add("Geeks");
    al.add(1, "For");

    System.out.println(al);
}

}

`

Output

[Geeks, For, Geeks]

**Note: If we try to add element at index 1 before adding elements at index 0 it will throw an error. It is always recommended to add elements in a particular index only when the size is defined or to add them sequentially.

2. Updating Elements

To update an element in a list, use the set() method with the target index and the new value. Since List is indexed, the element is replaced at the specified position.

Java `

import java.util.*;

class Geeks {

public static void main(String args[])
{
    // Creating an object of List interface
    List<String> al = new ArrayList<>();

    // Adding elements to object of List class
    al.add("Geeks");
    al.add("Geeks");
    al.add(1, "Geeks");

    System.out.println("Initial ArrayList " + al);

    // Setting (updating) element at 1st index using set() method
    al.set(1, "For");

    System.out.println("Updated ArrayList " + al);
}

}

`

Output

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]

3. Searching Elements

Searching in a List can be done using indexOf(), lastIndexOf() methods.

• **indexOf(Object o): It returns the index of the first occurrence of the specified element in the list or -1 if the element is not found
• **lastIndexOf(Object o): It returns the index of the last occurrence of the specified element in the list or -1 if the element is not found Java `

import java.util.*;

class Geeks {

public static void main(String[] args)
{
    // create a list of integers
    List<Integer> al = new ArrayList<>();

    // add some integers to the list
    al.add(1);
    al.add(2);
    al.add(3);
    al.add(2);

    // use indexOf() to find the first occurrence of an element in the list
    int i = al.indexOf(2);
  
    System.out.println("First Occurrence of 2 is at Index: "+i);

    // use lastIndexOf() to find the last occurrence of an element in the list
    int l = al.lastIndexOf(2);
  
    System.out.println("Last Occurrence of 2 is at Index: "+l);
}

}

`

Output

First Occurrence of 2 is at Index: 1 Last Occurrence of 2 is at Index: 3

4. Removing Elements

To remove an element from a list, we can use the remove() method. This method is overloaded to perform multiple operations based on different parameters.

• **remove(Object o): Removes the first occurrence of the specified object from the list.
• **remove(int index): Removes the element at the specified index and shifts subsequent elements left. Java `

import java.util.ArrayList; import java.util.List;

class Geeks {

public static void main(String args[])
{

    // Creating List class object
    List<String> al = new ArrayList<>();

    // Adding elements to the object Custom inputs
    al.add("Geeks");
    al.add("Geeks");

    // Adding For at 1st indexes
    al.add(1, "For");

    System.out.println("Initial ArrayList " + al);

    // Now remove element from the above list present at 1st index
    al.remove(1);

    System.out.println("After the Index Removal " + al);

    // Now remove the current object from the updated List
    al.remove("Geeks");
    
    System.out.println("After the Object Removal " + al);
}

}

`

Output

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]

5. Accessing Elements

To access an element in the list, we can use the get() method, which returns the element at the specified index.

**get(int index): This method returns the element at the specified index in the list.

Java `

import java.util.*;

class Geeks {

public static void main(String args[])
{

    List<String> al = new ArrayList<>();

    // Adding elements to object of List interface
    al.add("Geeks");
    al.add("For");
    al.add("Geeks");

    // Accessing elements using get() method
    String first = al.get(0);
    String second = al.get(1);
    String third = al.get(2);
    
    System.out.println(first);
    System.out.println(second);
    System.out.println(third);
    System.out.println(al);
}

}

`

Output

Geeks For Geeks [Geeks, For, Geeks]

6. Checking if an element is present or not

To check if an element is present in the list, we can use the contains() method. This method returns true if the specified element is present in the list, otherwise, it returns false.

**contains(Object o): This method takes a single parameter, the object to be checked if it is present in the list.

Java `

import java.util.*;

class Geeks {

public static void main(String args[])
{
 
    List<String> al = new ArrayList<>();

    // Adding elements to object of List interface
    al.add("Geeks");
    al.add("For");
    al.add("Geeks");

    // Checking if element is present using contains() method
    boolean isPresent = al.contains("Geeks");

    // Printing the result
    System.out.println("Is Geeks present in the list? "+ isPresent);
}

}

`

Output

Is Geeks present in the list? true

Iterating over List Interface in Java

For larger datasets, Lists can be iterated using:

• Basic for loop with get(index)
• Enhanced for-each loop

These methods allow efficient traversal of elements.

Java `

import java.util.*;

public class Geeks {

public static void main(String args[])
{
    // Creating an empty Arraylist of string type
    List<String> al = new ArrayList<>();

    // Adding elements to above object of ArrayList
    al.add("Geeks");
    al.add("Geeks");

    // Adding element at specified position inside list object
    al.add(1, "For");

    // Using  for loop for iteration
    for (int i = 0; i < al.size(); i++) {

        // Using get() method to access particular element
        System.out.print(al.get(i) + " ");
    }

    // New line for better readability
    System.out.println();

    // Using for-each loop for iteration
    for (String str : al)
        
        System.out.print(str + " ");
}

}

`

Output

Geeks For Geeks Geeks For Geeks

Complexity of List Interface in Java

Methods of the List Interface

List vs Set

Both the List interface and the Set interface inherits the Collection interface. However, there exists some differences between them.