Added in API level 1

Summary: Inherited Fields | Protected Ctors | Methods | Inherited Methods

AbstractSequentialList

public abstract class AbstractSequentialList
extends AbstractList<E>

java.lang.Object
↳	java.util.AbstractCollection<E>
	↳	java.util.AbstractList<E>
		↳	java.util.AbstractSequentialList<E>

Known direct subclasses

LinkedList<E>

LinkedList<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.

This class is a member of the Java Collections Framework.

See also:

Summary

Inherited fields

From class java.util.AbstractList


    protected
    
    
    int

modCount

The number of times this list has been structurally modified.

Protected constructors
`AbstractSequentialList()` Sole constructor.

Public methods
`void`	`add(int index, E element)` Inserts the specified element at the specified position in this list (optional operation).
`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).
`E`	`get(int index)` Returns the element at the specified position in this list.
`Iterator<E>`	`iterator()` Returns an iterator over the elements in this list (in proper sequence).
`abstract ListIterator<E>`	`listIterator(int index)` Returns a list iterator over the elements in this list (in proper sequence).
`E`	`remove(int index)` Removes the element at the specified position in this list (optional operation).
`E`	`set(int index, E element)` Replaces the element at the specified position in this list with the specified element (optional operation).

Inherited methods

From class


        
          java.util.AbstractList

`void`	`add(int index, E element)` Inserts the specified element at the specified position in this list (optional operation).
`boolean`	`add(E e)` Appends the specified element to the end of this list (optional operation).
`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).
`void`	`clear()` Removes all of the elements from this list (optional operation).
`boolean`	`equals(Object o)` Compares the specified object with this list for equality.
`abstract E`	`get(int index)` Returns the element at the specified position in this list.
`int`	`hashCode()` Returns the hash code value for this list.
`int`	`indexOf(Object o)` Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
`Iterator<E>`	`iterator()` Returns an iterator over the elements in this list in proper sequence.
`int`	`lastIndexOf(Object o)` Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
`ListIterator<E>`	`listIterator(int index)` Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
`ListIterator<E>`	`listIterator()` Returns a list iterator over the elements in this list (in proper sequence).
`E`	`remove(int index)` Removes the element at the specified position in this list (optional operation).
`void`	`removeRange(int fromIndex, int toIndex)` Removes from this list all of the elements whose index is between `fromIndex`, inclusive, and `toIndex`, exclusive.
`E`	`set(int index, E element)` Replaces the element at the specified position in this list with the specified element (optional operation).
`List<E>`	`subList(int fromIndex, int toIndex)` Returns a view of the portion of this list between the specified `fromIndex`, inclusive, and `toIndex`, exclusive.

From class


        
          java.util.AbstractCollection

`boolean`	`add(E e)` Ensures that this collection contains the specified element (optional operation).
`boolean`	`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this collection (optional operation).
`void`	`clear()` Removes all of the elements from this collection (optional operation).
`boolean`	`contains(Object o)` Returns `true` if this collection contains the specified element.
`boolean`	`containsAll(Collection<?> c)` Returns `true` if this collection contains all of the elements in the specified collection.
`boolean`	`isEmpty()` Returns `true` if this collection contains no elements.
`abstract Iterator<E>`	`iterator()` Returns an iterator over the elements contained in this collection.
`boolean`	`remove(Object o)` Removes a single instance of the specified element from this collection, if it is present (optional operation).
`boolean`	`removeAll(Collection<?> c)` Removes all of this collection's elements that are also contained in the specified collection (optional operation).
`boolean`	`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
`abstract int`	`size()` Returns the number of elements in this collection.
`<T> T[]`	`toArray(T[] a)` Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
`Object[]`	`toArray()` Returns an array containing all of the elements in this collection.
`String`	`toString()` Returns a string representation of this collection.

From class


        
          java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long timeoutMillis, int nanos)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait(long timeoutMillis)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait()` Causes the current thread to wait until it is awakened, typically by being notified or interrupted.

From interface


        
          java.util.List

`abstract boolean`	`add(E e)` Appends the specified element to the end of this list (optional operation).
`abstract void`	`add(int index, E element)` Inserts the specified element at the specified position in this list (optional operation).
`abstract boolean`	`addAll(Collection<? extends E> c)` 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).
`abstract 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).
`default void`	`addFirst(E e)` Adds an element as the first element of this collection (optional operation).
`default void`	`addLast(E e)` Adds an element as the last element of this collection (optional operation).
`abstract void`	`clear()` Removes all of the elements from this list (optional operation).
`abstract boolean`	`contains(Object o)` Returns `true` if this list contains the specified element.
`abstract boolean`	`containsAll(Collection<?> c)` Returns `true` if this list contains all of the elements of the specified collection.
`static <E> List<E>`	`copyOf(Collection<? extends E> coll)` Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.
`abstract boolean`	`equals(Object o)` Compares the specified object with this list for equality.
`abstract E`	`get(int index)` Returns the element at the specified position in this list.
`default E`	`getFirst()` Gets the first element of this collection.
`default E`	`getLast()` Gets the last element of this collection.
`abstract int`	`hashCode()` Returns the hash code value for this list.
`abstract int`	`indexOf(Object o)` Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
`abstract boolean`	`isEmpty()` Returns `true` if this list contains no elements.
`abstract Iterator<E>`	`iterator()` Returns an iterator over the elements in this list in proper sequence.
`abstract int`	`lastIndexOf(Object o)` Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
`abstract ListIterator<E>`	`listIterator(int index)` Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
`abstract ListIterator<E>`	`listIterator()` Returns a list iterator over the elements in this list (in proper sequence).
`static <E> List<E>`	`of(E e1, E e2, E e3)` Returns an unmodifiable list containing three elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)` Returns an unmodifiable list containing nine elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5)` Returns an unmodifiable list containing five elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6)` Returns an unmodifiable list containing six elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)` Returns an unmodifiable list containing eight elements.
`static <E> List<E>`	`of(E... elements)` Returns an unmodifiable list containing an arbitrary number of elements.
`static <E> List<E>`	`of()` Returns an unmodifiable list containing zero elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)` Returns an unmodifiable list containing ten elements.
`static <E> List<E>`	`of(E e1, E e2)` Returns an unmodifiable list containing two elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)` Returns an unmodifiable list containing seven elements.
`static <E> List<E>`	`of(E e1, E e2, E e3, E e4)` Returns an unmodifiable list containing four elements.
`static <E> List<E>`	`of(E e1)` Returns an unmodifiable list containing one element.
`abstract E`	`remove(int index)` Removes the element at the specified position in this list (optional operation).
`abstract boolean`	`remove(Object o)` Removes the first occurrence of the specified element from this list, if it is present (optional operation).
`abstract boolean`	`removeAll(Collection<?> c)` Removes from this list all of its elements that are contained in the specified collection (optional operation).
`default E`	`removeFirst()` Removes and returns the first element of this collection (optional operation).
`default E`	`removeLast()` Removes and returns the last element of this collection (optional operation).
`default void`	`replaceAll(UnaryOperator<E> operator)` Replaces each element of this list with the result of applying the operator to that element.
`abstract boolean`	`retainAll(Collection<?> c)` Retains only the elements in this list that are contained in the specified collection (optional operation).
`default List<E>`	`reversed()` Returns a reverse-ordered view of this collection.
`abstract E`	`set(int index, E element)` Replaces the element at the specified position in this list with the specified element (optional operation).
`abstract int`	`size()` Returns the number of elements in this list.
`default void`	`sort(Comparator<? super E> c)` Sorts this list according to the order induced by the specified `Comparator`.
`default Spliterator<E>`	`spliterator()` Creates a `Spliterator` over the elements in this list.
`abstract List<E>`	`subList(int fromIndex, int toIndex)` Returns a view of the portion of this list between the specified `fromIndex`, inclusive, and `toIndex`, exclusive.
`abstract Object[]`	`toArray()` Returns an array containing all of the elements in this list in proper sequence (from first to last element).
`abstract <T> T[]`	`toArray(T[] a)` 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.

From interface


        
          java.util.Collection

`abstract boolean`	`add(E e)` Ensures that this collection contains the specified element (optional operation).
`abstract boolean`	`addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this collection (optional operation).
`abstract void`	`clear()` Removes all of the elements from this collection (optional operation).
`abstract boolean`	`contains(Object o)` Returns `true` if this collection contains the specified element.
`abstract boolean`	`containsAll(Collection<?> c)` Returns `true` if this collection contains all of the elements in the specified collection.
`abstract boolean`	`equals(Object o)` Compares the specified object with this collection for equality.
`abstract int`	`hashCode()` Returns the hash code value for this collection.
`abstract boolean`	`isEmpty()` Returns `true` if this collection contains no elements.
`abstract Iterator<E>`	`iterator()` Returns an iterator over the elements in this collection.
`default Stream<E>`	`parallelStream()` Returns a possibly parallel `Stream` with this collection as its source.
`abstract boolean`	`remove(Object o)` Removes a single instance of the specified element from this collection, if it is present (optional operation).
`abstract boolean`	`removeAll(Collection<?> c)` Removes all of this collection's elements that are also contained in the specified collection (optional operation).
`default boolean`	`removeIf(Predicate<? super E> filter)` Removes all of the elements of this collection that satisfy the given predicate.
`abstract boolean`	`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
`abstract int`	`size()` Returns the number of elements in this collection.
`default Spliterator<E>`	`spliterator()` Creates a `Spliterator` over the elements in this collection.
`default Stream<E>`	`stream()` Returns a sequential `Stream` with this collection as its source.
`abstract <T> T[]`	`toArray(T[] a)` Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
`abstract Object[]`	`toArray()` Returns an array containing all of the elements in this collection.
`default <T> T[]`	`toArray(IntFunction<T[]> generator)` Returns an array containing all of the elements in this collection, using the provided `generator` function to allocate the returned array.

From interface


        
          java.util.SequencedCollection

`default void`	`addFirst(E e)` Adds an element as the first element of this collection (optional operation).
`default void`	`addLast(E e)` Adds an element as the last element of this collection (optional operation).
`default E`	`getFirst()` Gets the first element of this collection.
`default E`	`getLast()` Gets the last element of this collection.
`default E`	`removeFirst()` Removes and returns the first element of this collection (optional operation).
`default E`	`removeLast()` Removes and returns the last element of this collection (optional operation).
`abstract SequencedCollection<E>`	`reversed()` Returns a reverse-ordered view of this collection.

From interface


        
          java.lang.Iterable

`default void`	`forEach(Consumer<? super T> action)` Performs the given action for each element of the `Iterable` until all elements have been processed or the action throws an exception.
`abstract Iterator<E>`	`iterator()` Returns an iterator over elements of type `T`.
`default Spliterator<E>`	`spliterator()` Creates a `Spliterator` over the elements described by this `Iterable`.

Protected constructors

AbstractSequentialList

Added in API level 1

protected AbstractSequentialList ()

Sole constructor. (For invocation by subclass constructors, typically implicit.)

Public methods

add

Added in API level 1

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`	`int`: index at which the specified element is to be inserted
`element`	`E`: element to be inserted

Throws
`UnsupportedOperationException`
`ClassCastException`
`NullPointerException`
`IllegalArgumentException`
`IndexOutOfBoundsException`

addAll

Added in API level 1

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`	`int`: index at which to insert the first element from the specified collection
`c`	`Collection`: collection containing elements to be added to this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`UnsupportedOperationException`
`ClassCastException`
`NullPointerException`
`IllegalArgumentException`
`IndexOutOfBoundsException`

get

Added in API level 1

public E get (int index)

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`	`int`: index of the element to return

Returns
`E`	the element at the specified position in this list

Throws
`IndexOutOfBoundsException`

iterator

Added in API level 1

public Iterator<E> iterator ()

Returns an iterator over the elements in this list (in proper sequence).

This implementation merely returns a list iterator over the list.

Returns
`Iterator<E>`	an iterator over the elements in this list (in proper sequence)

listIterator

Added in API level 1

public abstract ListIterator<E> listIterator (int index)

Returns a list iterator over the elements in this list (in proper sequence).

Parameters
`index`	`int`: index of first element to be returned from the list iterator (by a call to the `next` method)

Returns
`ListIterator<E>`	a list iterator over the elements in this list (in proper sequence)

Throws
`IndexOutOfBoundsException`

remove

Added in API level 1

public E remove (int index)

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.

Parameters
`index`	`int`: the index of the element to be removed

Returns
`E`	the element previously at the specified position

Throws
`UnsupportedOperationException`
`IndexOutOfBoundsException`

set

Added in API level 1

public E set (int index, 
                E element)

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.

Parameters
`index`	`int`: index of the element to replace
`element`	`E`: element to be stored at the specified position

Returns
`E`	the element previously at the specified position

Throws
`UnsupportedOperationException`
`ClassCastException`
`NullPointerException`
`IllegalArgumentException`
`IndexOutOfBoundsException`