AbstractSequentialList in Java with Examples

AbstractSequentialList is an abstract class in the Java Collections Framework that provides a skeletal implementation of the List interface for sequential-access data structures like linked lists. It simplifies list implementation by providing default methods.

• Extends AbstractList and is designed for sequential access rather than random access.
• Abstract class, so it cannot be instantiated directly.
• For AbstractSequentialList, you must implement listIterator(int index) and size().

import java.util.AbstractSequentialList;
import java.util.LinkedList;

public class GfG {

    public static void main(String[] args)
    {
        // Creating an instance of AbstractSequentialList
        AbstractSequentialList<Integer> a
            = new LinkedList<>();

        // adding elements
        a.add(5);
        a.add(6);
        a.add(7);

        // Printing the list
        System.out.println(a);
    }
}

[5, 6, 7]

Java Collections Hierarchy

The diagram shows the relationship between the main interfaces, abstract classes, and implementations in the Java Collections Framework.

Explanation Flow

• Collection: Root interface for storing groups of objects.
• List: Extends Collection and maintains an ordered collection.
• AbstractList: Provides a basic implementation of the List interface.
• ArrayList and Vector: Extend AbstractList.
• Stack: Extends Vector.
• Queue: Extends Collection for queue-based operations.
• Deque: Extends Queue and supports operations at both ends.
• AbstractSequentialList: Extends AbstractList and is designed for sequential-access lists.
• LinkedList: Extends AbstractSequentialList and implements Deque.

Declaration

public abstract class AbstractSequentialListextends AbstractList

Here, E represents the type of elements stored in the list.

Constructors of AbstractSequentialList

AbstractSequentialList provides a protected no-argument constructor:

AbstractSequentialList asl = new LinkedList();

import java.util.AbstractSequentialList;
import java.util.LinkedList;

public class AbstractSequentialListDemo {

    public static void main(String args[])
    {

        // Creating an empty AbstractSequentialList
        AbstractSequentialList<String> a
            = new LinkedList<String>();

        // Using add() method to add elements
        a.add("Geeks");
        a.add("for");
        a.add("Geeks");
        a.add("10");
        a.add("20");

        // Output the list
        System.out.println("AbstractSequentialList: " + a);

        // Remove the head using remove()
        a.remove(3);

        // Print the final list
        System.out.println("Final List: " + a);

        // Fetching the specific element from the list
        // using get() method
        System.out.println("The element is: " + a.get(2));
    }
}

AbstractSequentialList: [Geeks, for, Geeks, 10, 20]
Final List: [Geeks, for, Geeks, 20]
The element is: Geeks

Explanation

• LinkedList is used as the concrete implementation of AbstractSequentialList.
• The add() method adds elements to the list.
• remove(3) removes the element at index 3, which is "10".
• get(2) returns the element at index 2, which is "Geeks".
• Although get() is available, AbstractSequentialList is intended for sequential-access data structures, so indexed access may require traversal.

Methods of AbstractSequentialList

Methods Inherited From class java.util.AbstractList

 Methods Inherited From class java.util.AbstractCollection

Methods Inherited From Interface java.util.Collection

Methods Inherited From Interface java.util.List