All Packages Class Hierarchy This Package Previous Next Index
Class com.sun.java.util.collections.AbstractSequentialList
java.lang.Object
|
+----com.sun.java.util.collections.AbstractCollection
|
+----com.sun.java.util.collections.AbstractList
|
+----com.sun.java.util.collections.AbstractSequentialList
- public abstract class AbstractSequentialList
- extends AbstractList
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, Object element), set(int index, Object
element), add(int index, Object 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.
- See Also:
- Collection, List, AbstractList, AbstractCollection
-
AbstractSequentialList()
- Sole constructor.
-
add(int, Object)
- Inserts the specified element at the specified position in this list.
-
addAll(int, Collection)
- Inserts all of the elements in in the specified collection into this
list at the specified position.
-
get(int)
- Returns the element at the specified position in this list.
-
iterator()
- Returns an iterator over the elements in this list (in proper
sequence).
This implementation merely returns a list iterator over the list.
-
listIterator(int)
- Returns a list iterator over the elements in this list (in proper
sequence).
-
remove(int)
- Removes the element at the specified position in this list.
-
set(int, Object)
- Replaces the element at the specified position in this list with the
specified element.
AbstractSequentialList
protected AbstractSequentialList()
- Sole constructor. (For invocation by subclass constructors, typically
implicit.)
get
public Object 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.
- Returns:
- the element at the specified position in this list. * @param
index index of element to return. * @throws
IndexOutOfBoundsException if the specified index is out of
range (index < 0 || index >= size()).
- Overrides:
- get in class AbstractList
set
public Object set(int index,
Object element)
- Replaces the element at the specified position in this list with the
specified element.
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 list iterator does not implement
the set operation.
- Parameters:
- index - index of element to replace.
- element - element to be stored at the specified position.
- Returns:
- the element previously at the specified position.
- Overrides:
- set in class AbstractList
add
public void add(int index,
Object element)
- Inserts the specified element at the specified position in this list.
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 list iterator does not
implement the add operation.
- Parameters:
- index - index at which the specified element is to be inserted.
- element - element to be inserted.
- Overrides:
- add in class AbstractList
remove
public Object remove(int index)
- Removes the element at the specified position in this list. Shifts any
subsequent elements to the left (subtracts one from their indices).
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 list iterator does not
implement the remove operation.
- Parameters:
- the - index of the element to be removed from the List.
- Returns:
- the element that was removed from the list.
- Overrides:
- remove in class AbstractList
addAll
public boolean addAll(int index,
Collection c)
- Inserts all of the elements in in the specified collection into this
list at the specified position. 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 the list in the order
that they are returned by the specified collection's iterator. The
behavior of this operation is unspecified 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.)
Optional operation.
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 first element from the specified
collection.
- c - elements to be inserted into this list.
- Returns:
- true if this list changed as a result of the call.
- Overrides:
- addAll in class AbstractList
iterator
public Iterator iterator()
- Returns an iterator over the elements in this list (in proper
sequence).
This implementation merely returns a list iterator over the list.
- Returns:
- an iterator over the elements in this list (in proper sequence).
- Overrides:
- iterator in class AbstractList
listIterator
public abstract ListIterator listIterator(int index)
- Returns a list iterator over the elements in this list (in proper
sequence).
- Returns:
- a list iterator over the elements in this list (in proper
sequence).
- Overrides:
- listIterator in class AbstractList
All Packages Class Hierarchy This Package Previous Next Index