The List interface in Java represents an ordered collection that allows duplicate elements and provides positional access. It is a part of the java.util package and extends the Collection interface. Lists are commonly used when the order of elements matters, and when you need to access elements by their index position.

Key Characteristics of List:

• Ordered Collection: Elements in a List are ordered, meaning they maintain the sequence in which they were inserted.
• Allows Duplicates: A List can contain multiple occurrences of the same element.
• Indexed Access: Elements can be accessed using an integer index, with the first element at index 0.
• Null Elements: List implementations allow the inclusion of null elements.

Declaration of the Java List Interface

The List interface in Java is declared as follows:

public interface List<E> extends Collection<E> { }

It represents an ordered collection that allows duplicate elements and provides positional access.

Since List is an interface, we cannot instantiate it directly. Instead, we create an instance of a class that implements it, such as ArrayList, LinkedList, or Vector.

Example:

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

public class ListDemo {
    public static void main(String[] args) {
        // Instantiate a List using ArrayList
        List<String> list = new ArrayList<>();  // Using ArrayList
        list.add("Java");
        list.add("Python");
        list.add("C++");

        System.out.println(list); //Output: [Java, Python, C++]
    }
}

✅ Explanation:

• List<String> → The generic type <String> specifies that this list will store String elements.
• new ArrayList<>() → We are creating an ArrayList instance that implements the List interface.

Common Implementations of List:

• ArrayList
• LinkedList
• Vector
• Stack
• CopyOnWriteArrayList

List Implementation classes

Java provides several classes that implement the List interface, each with its own characteristics and use cases:

1. ArrayList: A resizable array implementation of the List interface. It allows fast random access and is efficient for storing and accessing data. However, adding or removing elements (except at the end) can be slow due to the need to shift elements.
2. LinkedList: A doubly-linked list implementation of the List interface. It allows for efficient insertion or removal of elements from both ends and from the middle of the list. However, it provides slower access to elements by index compared to ArrayList.
3. Vector: An older implementation of the List interface. It is similar to ArrayList but is synchronized, making it thread-safe. However, this synchronization comes with a performance cost.
4. Stack: A subclass of Vector that represents a last-in, first-out stack of objects. It provides methods like push(), pop(), and peek() to operate on the stack.
5. CopyOnWriteArrayList: A thread-safe variant of ArrayList where all mutative operations (like add, set, etc.) are implemented by making a fresh copy of the underlying array. This is useful when you have a list that is frequently read but infrequently modified.

Java List – Operations in Detail

The List interface in Java (part of the Collection Framework) represents an ordered collection that can contain duplicate elements.
Common implementations: ArrayList, LinkedList, CopyOnWriteArrayList, Vector.

1. Creating a List

import java.util.*;

public class ListCreation {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();  // Using ArrayList
        list.add("Java");
        list.add("Python");
        list.add("C++");

        System.out.println(list); // [Java, Python, C++]
    }
}

2. Adding Elements

• add(E e) → Adds element at the end.
• add(int index, E e) → Inserts element at a specific index.

list.add("Go");            // Adds at end
list.add(1, "Kotlin");     // Inserts at index 1

3. Accessing Elements

• get(int index) → Retrieves element at given index.

System.out.println(list.get(0));  // Java
System.out.println(list.get(2));  // Kotlin

4. Updating Elements

• set(int index, E e) → Replaces element at index.

list.set(2, "Rust");  
System.out.println(list); // [Java, Kotlin, Rust, Go]

5. Removing Elements

• remove(int index) → Removes by index.
• remove(Object o) → Removes first occurrence of object.
• clear() → Removes all elements.

list.remove("Kotlin");   // Removes element
list.remove(1);          // Removes by index
list.clear();            // Removes all

6. Searching in List

• contains(Object o) → Checks if element exists.
• indexOf(Object o) → First index of element, or -1 if not found.
• lastIndexOf(Object o) → Last index of element.

System.out.println(list.contains("Java"));   // true
System.out.println(list.indexOf("Java"));    // 0
System.out.println(list.lastIndexOf("Go"));  // 3

7. Iterating Over a List

• For-each Loop

for (String lang: list) {
  System.out.println(lang);
}

• Iterator

Iterator < String > itr = list.iterator();
while (itr.hasNext()) {
  System.out.println(itr.next());
}

• ListIterator (Bidirectional)

ListIterator < String > litr = list.listIterator();
while (litr.hasNext()) {
  System.out.println(litr.next());
}

• Java 8+ forEach with Lambda

list.forEach(System.out::println);

8. Sorting a List

Collections.sort(list);                  // Natural order
list.sort(Comparator.reverseOrder());    // Reverse order

9. Sublist Operation

List < String > sub = list.subList(1, 3);
System.out.println(sub); // [Python, C++]

10. Converting List to Array

String[] arr = list.toArray(new String[0]);
System.out.println(Arrays.toString(arr));

11. Streams & Functional Operations (Java 8+)

list.stream()
    .filter(lang -> lang.startsWith("J"))
    .forEach(System.out::println);   // Java

12. Checking if an Element is Present in a List

The List interface provides methods to check whether an element exists inside a list.

✅ Methods Used

1. contains(Object o) → Returns true if the list contains the specified element, else false.
2. indexOf(Object o) → Returns the first index of the element, or -1 if not found.
3. lastIndexOf(Object o) → Returns the last index of the element, or -1 if not found.

Example

import java.util.*;

public class ListSearchExample {
    public static void main(String[] args) {
        List<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("Python");
        languages.add("C++");
        languages.add("Java"); // duplicate

        // 1. contains()
        System.out.println(languages.contains("Java"));   // true
        System.out.println(languages.contains("Rust"));   // false

        // 2. indexOf()
        System.out.println(languages.indexOf("Java"));    // 0 (first occurrence)
        System.out.println(languages.indexOf("Rust"));    // -1 (not found)

        // 3. lastIndexOf()
        System.out.println(languages.lastIndexOf("Java")); // 3 (last occurrence)
    }
}

Output

true
false
0
-1
3

📌 Summary Table of List Operations

✅ In short:
The List interface in Java provides powerful operations to manage ordered collections, making it one of the most widely used data structures in Java applications.