java.util
Class AbstractSequentialList
java.lang.Object
|
+--java.util.AbstractCollection
|
+--java.util.AbstractList
|
+--java.util.AbstractSequentialList
public abstract class
AbstractSequentialListextends
AbstractList Abstract superclass to make it easier to implement the List interface when
backed by a sequential-access store, such as a linked list. For random
access data, use AbstractList. This class implements the random access
methods (
get
,
set
,
add
, and
remove
) atop the list iterator, opposite of AbstractList's
approach of implementing the iterator atop random access.
To implement a list, you need an implementation for size()
and listIterator
. With just hasNext
,
next
, hasPrevious
, previous
,
nextIndex
, and previousIndex
, you have an
unmodifiable list. For a modifiable one, add set
, and for
a variable-size list, add add
and remove
.
The programmer should provide a no-argument constructor, and one that
accepts another Collection, as recommended by the Collection interface.
Unfortunately, there is no way to enforce this in Java.
Since:Authors:- Original author unknown
- Bryce McKinlay
- Eric Blake <ebb9@email.byu.edu>
See Also:
AbstractSequentialList
protected AbstractSequentialList()
The main constructor, for use by subclasses.
add
public void add(int index, java.lang.Object o)
Insert an element into the list at a given position (optional operation).
This shifts all existing elements from that position to the end one
index to the right. This version of add has no return, since it is
assumed to always succeed if there is no exception. This iteration
uses listIterator(index).add(o).
Parameters:
Throws:
addAll
public boolean addAll(int index, java.util.Collection c)
Insert the contents of a collection into the list at a given position
(optional operation). Shift all elements at that position to the right
by the number of elements inserted. This operation is undefined if
this list is modified during the operation (for example, if you try
to insert a list into itself).
This implementation grabs listIterator(index), then proceeds to use add
for each element returned by c's iterator. Sun's online specs are wrong,
claiming that this also calls next(): listIterator.add() correctly
skips the added element.
Parameters:
Returns:
- true if the list was modified by this action, that is, if c is
non-empty
Throws:
See Also:
get
public Object get(int index)
Get the element at a given index in this list. This implementation
returns listIterator(index).next().
Parameters:
Returns:
- the element at index index in this list
Throws:
iterator
public Iterator iterator()
Obtain an Iterator over this list, whose sequence is the list order. This
implementation returns listIterator().
Returns:
- an Iterator over the elements of this list, in order
listIterator
public ListIterator listIterator(int index)
Returns a ListIterator over the list, starting from position index.
Subclasses must provide an implementation of this method.
Parameters:
Returns:
Throws:
remove
public Object remove(int index)
Remove the element at a given position in this list (optional operation).
Shifts all remaining elements to the left to fill the gap. This
implementation uses listIterator(index) and ListIterator.remove().
Parameters:
Returns:
- the object that was removed
Throws:
set
public Object set(int index, java.lang.Object o)
Replace an element of this list with another object (optional operation).
This implementation uses listIterator(index) and ListIterator.set(o).
Parameters:
Returns:
- the object that was replaced
Throws:
get
,set
,add
, andremove
) atop the list iterator, opposite of AbstractList's approach of implementing the iterator atop random access.To implement a list, you need an implementation for
size()
andlistIterator
. With justhasNext
,next
,hasPrevious
,previous
,nextIndex
, andpreviousIndex
, you have an unmodifiable list. For a modifiable one, addset
, and for a variable-size list, addadd
andremove
.The programmer should provide a no-argument constructor, and one that accepts another Collection, as recommended by the Collection interface. Unfortunately, there is no way to enforce this in Java.