AbstractSequentialList
Stay organized with collections
Save and categorize content based on your preferences.
AI-generated Key Takeaways
AbstractSequentialList is a skeletal Java List implementation optimized for sequential access data structures like linked lists, minimizing coding by implementing random access methods using its list iterator.
To create a custom list, developers need to extend AbstractSequentialList and implement the list iterator's methods: hasNext, next, hasPrevious, previous, and index for an unmodifiable list; additionally, set for modifiable; and further, remove and add for variable-size lists.
It provides core functionalities like adding, retrieving, and removing elements at specific indices, primarily using a list iterator for these operations, while inheriting methods from Collection and Iterable interfaces for other functionalities.
AbstractSequentialList is designed for sequential access, making random access potentially less efficient, and it's crucial for subclasses to implement the abstract listIterator(int index) method defining specific list iteration logic.
Developers should consider that AbstractSequentialList is not synchronized, requiring external synchronization mechanisms for concurrent access, and some methods might throw an UnsupportedOperationException if not supported by the concrete list implementation.
public abstract class
AbstractSequentialList
extends AbstractList<E>
Doubly-linked list implementation of the List and Deque
interfaces.
This class provides a skeletal implementation of the List
interface to minimize the effort required to implement this interface
backed by a "sequential access" data store (such as a linked list). For
random access data (such as an array), AbstractList should be used
in preference to this class.
This class is the opposite of the AbstractList class in the sense
that it implements the "random access" methods (get(int index),
set(int index, E element), add(int index, E element) and
remove(int index)) on top of the list's list iterator, instead of
the other way around.
To implement a list the programmer needs only to extend this class and
provide implementations for the listIterator and size
methods. For an unmodifiable list, the programmer need only implement the
list iterator's hasNext, next, hasPrevious,
previous and index methods.
For a modifiable list the programmer should additionally implement the list
iterator's set method. For a variable-size list the programmer
should additionally implement the list iterator's remove and
add methods.
The programmer should generally provide a void (no argument) and collection
constructor, as per the recommendation in the Collection interface
specification.
Returns true if this collection contains all of the elements
in the specified collection.
This implementation iterates over the specified collection,
checking each element returned by the iterator in turn to see
if it's contained in this collection.
Removes all of this collection's elements that are also contained in the
specified collection (optional operation).
This implementation iterates over this collection, checking each
element returned by the iterator in turn to see if it's contained
in the specified collection.
Retains only the elements in this collection that are contained in the
specified collection (optional operation).
This implementation iterates over this collection, checking each
element returned by the iterator in turn to see if it's contained
in the specified collection.
Returns an array containing all of the elements in this collection;
the runtime type of the returned array is that of the specified array.
This implementation returns an array containing all the elements
returned by this collection's iterator in the same order, stored in
consecutive elements of the array, starting with index 0.
Returns an array containing all of the elements in this collection.
This implementation returns an array containing all the elements
returned by this collection's iterator, in the same order, stored in
consecutive elements of the array, starting with index 0.
Appends all of the elements in the specified collection to the end of
this list, in the order that they are returned by the specified
collection's iterator (optional operation).
Returns an array containing all of the elements in this list in
proper sequence (from first to last element); the runtime type of
the returned array is that of the specified array.
Creates a Spliterator over the elements described by this
Iterable.
Protected Constructors
protected
AbstractSequentialList()
Sole constructor. (For invocation by subclass constructors, typically
implicit.)
Public Methods
public
void
add(int index, E element)
Inserts the specified element at the specified position in this list
(optional operation). Shifts the element currently at that position
(if any) and any subsequent elements to the right (adds one to their
indices).
This implementation first gets a list iterator pointing to the
indexed element (with listIterator(index)). Then, it
inserts the specified element with ListIterator.add.
Note that this implementation will throw an
UnsupportedOperationException if the list iterator does not
implement the add operation.
Parameters
index
index at which the specified element is to be inserted
public
boolean
addAll(int index, Collection<? extends E> c)
Inserts all of the elements in the specified collection into this
list at the specified position (optional operation). Shifts the
element currently at that position (if any) and any subsequent
elements to the right (increases their indices). The new elements
will appear in this list in the order that they are returned by the
specified collection's iterator. The behavior of this operation is
undefined if the specified collection is modified while the
operation is in progress. (Note that this will occur if the specified
collection is this list, and it's nonempty.)
This implementation gets an iterator over the specified collection and
a list iterator over this list pointing to the indexed element (with
listIterator(index)). Then, it iterates over the specified
collection, inserting the elements obtained from the iterator into this
list, one at a time, using ListIterator.add followed by
ListIterator.next (to skip over the added element).
Note that this implementation will throw an
UnsupportedOperationException if the list iterator returned by
the listIterator method does not implement the add
operation.
Parameters
index
index at which to insert the first element from the
specified collection
c
collection containing elements to be added to this list
Returns the element at the specified position in this list.
This implementation first gets a list iterator pointing to the
indexed element (with listIterator(index)). Then, it gets
the element using ListIterator.next and returns it.
Parameters
index
index of the element to return
Returns
the element at the specified position in this list
Removes the element at the specified position in this list (optional
operation). Shifts any subsequent elements to the left (subtracts one
from their indices). Returns the element that was removed from the
list.
This implementation first gets a list iterator pointing to the
indexed element (with listIterator(index)). Then, it removes
the element with ListIterator.remove.
Note that this implementation will throw an
UnsupportedOperationException if the list iterator does not
implement the remove operation.
Replaces the element at the specified position in this list with the
specified element (optional operation).
This implementation first gets a list iterator pointing to the
indexed element (with listIterator(index)). Then, it gets
the current element using ListIterator.next and replaces it
with ListIterator.set.
Note that this implementation will throw an
UnsupportedOperationException if the list iterator does not
implement the set operation.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2024-07-10 UTC."],[],["`AbstractSequentialList` provides a base for sequential-access `List` implementations. Subclasses must implement `listIterator` and `size`. Core functions like `get`, `set`, `add`, and `remove` are implemented using `ListIterator`. For unmodifiable lists, `hasNext`, `next`, `hasPrevious`, `previous`, and `index` must be implemented in the `ListIterator`; for modification, `set`, `remove`, and `add` methods are also needed in the `ListIterator`. It also has protected `modCount` to track structural modifications. The List, Collection, and Iterable interfaces provide functionalities like adding, removing, and iterating over elements.\n"]]
