List

In Java, the `List` interface represents an ordered collection of elements where duplicates are allowed. It extends the `Collection` interface and provides methods to access, insert, update, and remove elements. Here's an explanation along with a demonstration example:

Explanation:

1. Ordered Collection:

   - Lists maintain the order of elements as they are inserted.

   - Each element in a list has an index, starting from 0 for the first element.

2. Duplicates Allowed:

   - Lists can contain duplicate elements, unlike sets where elements are unique.

3. Key Methods:

   - `add(E element)`: Adds the specified element to the end of the list.

   - `get(int index)`: Retrieves the element at the specified index.

   - `set(int index, E element)`: Replaces the element at the specified position with the specified element.

   - `remove(int index)`: Removes the element at the specified index.

   - `size()`: Returns the number of elements in the list.

4. Common Implementations:

   - `ArrayList`: Resizable-array implementation of the `List` interface.

   - `LinkedList`: Doubly-linked list implementation.

   - `Vector`: Synchronized resizable-array implementation (less commonly used).

Example Demonstration:

Let's demonstrate using `ArrayList`, one of the most commonly used implementations of the `List` interface.

import java.util.ArrayList;

import java.util.List;

public class ListExample {

    public static void main(String[] args) {

        // Creating an ArrayList

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

        // Adding elements to the list

        fruits.add("Apple");

        fruits.add("Banana");

        fruits.add("Orange");

        fruits.add("Apple"); // Duplicates are allowed

        // Accessing elements by index

        System.out.println("First fruit: " + fruits.get(0));

        // Iterating over the list

        System.out.println("All fruits:");

        for (String fruit : fruits) {

            System.out.println(fruit);

        }

        // Removing an element

        fruits.remove(1); // Removing "Banana"

        // Updating an element

        fruits.set(1, "Mango"); // Replacing "Banana" with "Mango"

        // Size of the list

        System.out.println("Number of fruits: " + fruits.size());

        // Checking if a specific element is present

        if (fruits.contains("Orange")) {

            System.out.println("Orange is in the list.");

        } else {

            System.out.println("Orange is not in the list.");

        }

    }

}

Output:

First fruit: Apple

All fruits:

Apple

Banana

Orange

Apple

Number of fruits: 3

Orange is in the list.

In this example, we created an `ArrayList` called `fruits`, added elements, accessed elements by index, iterated over the list, removed an element, updated an element, checked the size of the list, and checked for the presence of a specific element. Lists are versatile data structures in Java, suitable for various use cases where ordered collection with duplicates is required.