The AbstractList Class and ArrayList Class in Java Collection

import java.util.AbstractList;

public class SimpleList<E> extends AbstractList<E> {
    private Object[] elements;
    private int size;

    public SimpleList(int capacity) {
        elements = new Object[capacity];
        size = 0;
    }
    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return (E) elements[index];
    }
    @Override
    public int size() {
        return size;
    }
    @Override
    public boolean add(E e) {
        if (size == elements.length) {
            ensureCapacity(size + 1);
        }
        elements[size++] = e;
        return true;
    }
    private void ensureCapacity(int minCapacity) {
        int oldCapacity = elements.length;
        if (minCapacity > oldCapacity) {
            int newCapacity = oldCapacity * 2;
            if (newCapacity < minCapacity) {
                newCapacity = minCapacity;
            }
            Object[] newElements = new Object[newCapacity];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
        }
    }
    public static void main(String[] args) {
        SimpleList<String> myList = new SimpleList<>(5);
        myList.add("Apple");
        myList.add("Banana");
        myList.add("Cherry");
        for (int i = 0; i < myList.size(); i++) {
            System.out.println(myList.get(i));
        }
    }
}

The ArrayList Class

The ArrayList class extends the AbstractList class and implements the List, Cloneable, and Serializable interfaces. It provides a dynamic array in Java applications, meaning the size of the array is not fixed and can be adjusted at runtime. As elements are added to the ArrayList, its capacity automatically increases to accommodate new elements. Each instance of the ArrayList can store a collection of elements, offering a flexible and resizable solution for managing lists in Java.

Constructor

• ArrayList(): Create an empty list. The capacity of the list is initialized to ten.
• ArrayList(Collection c): Creates a list to which the elements of the specified collection are added.
• ArrayList(int capacity): Creates an empty list. The capacity of the list is initialized to the specified value.

The ArrayList class inherits methods from the List interface, allowing direct access to elements via the get() and set() methods. To add an element to the list, the add() method is used, while the remove() method facilitates the removal of elements from the list.

The below source code illustrates the usage of the add() and remove() methods of the ArrayList class.

import java.util.*;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> arraylist = new ArrayList<>();    
        System.out.println("Initial size of the array list: " + arraylist.size());       
        arraylist.add("A");
        arraylist.add("B");
        arraylist.add("C");
        arraylist.add("D");       
        System.out.println("Size of arraylist after adding elements: " + arraylist.size());
        System.out.println("Contents of arrayList: " + arraylist);      
        arraylist.add(2, "E");    
        System.out.println("Changed contents of arraylist by adding element at the given index: " + arraylist);    
        arraylist.remove(3);
        arraylist.remove("A");      
        System.out.println("Changed contents of arraylist by removing elements from the list: " + arraylist);
    }
}

Output

The provided code demonstrates basic operations on an ArrayList in Java. The ArrayListExample class creates an instance of ArrayList, initially printing its size, which is zero. It then adds four elements ("A", "B", "C", "D") and displays the updated size and contents of the list. The code inserts the element "E" at index 2 and shows the modified list. Subsequently, it removes the element at index 3 and the element "A" by value, printing the final state of the ArrayList. This example illustrates how to manipulate an ArrayList by adding and removing elements and observing the changes in the list's size and contents.

Summary

The AbstractList class in Java provides a skeletal implementation of the List interface, simplifying the creation of custom list implementations by offering default implementations for many methods. It serves as a foundational class that allows developers to focus on the specifics of their custom list while inheriting basic functionality such as element access and size management. In contrast, the ArrayList class is a concrete implementation of the List interface that uses a dynamic array to store elements. It offers efficient index-based access and automatically resizes as elements are added or removed. ArrayList provides a practical and versatile solution for managing lists where frequent access and modification are required. While AbstractList is used as a base for creating specialized lists, ArrayList is a ready-to-use implementation ideal for most dynamic list needs.