|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectjava.util.AbstractCollection<E>
java.util.AbstractList<E>
public abstract class AbstractList<E>
A basic implementation of most of the methods in the List interface to make it easier to create a List based on a random-access data structure. If the list is sequential (such as a linked list), use AbstractSequentialList. To create an unmodifiable list, it is only necessary to override the size() and get(int) methods (this contrasts with all other abstract collection classes which require an iterator to be provided). To make the list modifiable, the set(int, Object) method should also be overridden, and to make the list resizable, the add(int, Object) and remove(int) methods should be overridden too. Other methods should be overridden if the backing data structure allows for a more efficient implementation. The precise implementation used by AbstractList is documented, so that subclasses can tell which methods could be implemented more efficiently.
As recommended by Collection and List, the subclass should provide at least a no-argument and a Collection constructor. This class is not synchronized.
Collection,
List,
AbstractSequentialList,
AbstractCollection,
ListIterator| Field Summary | |
|---|---|
protected int |
modCount
A count of the number of structural modifications that have been made to the list (that is, insertions and removals). |
| Constructor Summary | |
|---|---|
protected |
AbstractList()
The main constructor, for use by subclasses. |
| Method Summary | |
|---|---|
boolean |
add(E o)
Add an element to the end of the list (optional operation). |
void |
add(int index,
E o)
Insert an element into the list at a given position (optional operation). |
boolean |
addAll(int index,
Collection<? extends E> c)
Insert the contents of a collection into the list at a given position (optional operation). |
void |
clear()
Clear the list, such that a subsequent call to isEmpty() would return true (optional operation). |
boolean |
equals(Object o)
Test whether this list is equal to another object. |
abstract E |
get(int index)
Returns the elements at the specified position in the list. |
int |
hashCode()
Obtains a hash code for this list. |
int |
indexOf(Object o)
Obtain the first index at which a given object is to be found in this list. |
Iterator<E> |
iterator()
Obtain an Iterator over this list, whose sequence is the list order. |
int |
lastIndexOf(Object o)
Obtain the last index at which a given object is to be found in this list. |
ListIterator<E> |
listIterator()
Obtain a ListIterator over this list, starting at the beginning. |
ListIterator<E> |
listIterator(int index)
Obtain a ListIterator over this list, starting at a given position. |
E |
remove(int index)
Remove the element at a given position in this list (optional operation). |
protected void |
removeRange(int fromIndex,
int toIndex)
Remove a subsection of the list. |
E |
set(int index,
E o)
Replace an element of this list with another object (optional operation). |
List<E> |
subList(int fromIndex,
int toIndex)
Obtain a List view of a subsection of this list, from fromIndex (inclusive) to toIndex (exclusive). |
| Methods inherited from class java.util.AbstractCollection |
|---|
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, toArray, toArray, toString |
| Methods inherited from class java.lang.Object |
|---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.util.List |
|---|
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, toArray, toArray |
| Field Detail |
|---|
protected transient int modCount
ConcurrentModificationException in response
to the next operation on the iterator. This fail-fast behavior
saves the user from many subtle bugs otherwise possible from concurrent
modification during iteration.
To make lists fail-fast, increment this field by just 1 in the
add(int, Object) and remove(int) methods.
Otherwise, this field may be ignored.
| Constructor Detail |
|---|
protected AbstractList()
| Method Detail |
|---|
public abstract E get(int index)
get in interface List<E>index - the element to return
IndexOutOfBoundsException - if index < 0 || index >= size()
public void add(int index,
E o)
add in interface List<E>index - the location to insert the itemo - the object to insert
UnsupportedOperationException - if this list does not support the
add operation
IndexOutOfBoundsException - if index < 0 || index > size()
ClassCastException - if o cannot be added to this list due to its
type
IllegalArgumentException - if o cannot be added to this list for
some other reasonmodCountpublic boolean add(E o)
add(size(), o);, and will fail if that version does.
add in interface Collection<E>add in interface List<E>add in class AbstractCollection<E>o - the object to add
UnsupportedOperationException - if this list does not support the
add operation
ClassCastException - if o cannot be added to this list due to its
type
IllegalArgumentException - if o cannot be added to this list for
some other reasonadd(int, Object)
public boolean addAll(int index,
Collection<? extends E> c)
addAll in interface List<E>index - the location to insert the collectionc - the collection to insert
UnsupportedOperationException - if this list does not support the
addAll operation
IndexOutOfBoundsException - if index < 0 || index > size()
ClassCastException - if some element of c cannot be added to this
list due to its type
IllegalArgumentException - if some element of c cannot be added
to this list for some other reason
NullPointerException - if the specified collection is nulladd(int, Object)public void clear()
removeRange(0, size()), so it will fail unless remove
or removeRange is overridden.
clear in interface Collection<E>clear in interface List<E>clear in class AbstractCollection<E>UnsupportedOperationException - if this list does not support the
clear operationremove(int),
removeRange(int, int)public boolean equals(Object o)
l1.size() == l2.size(), and for every integer n between 0
and l1.size() - 1 inclusive, l1.get(n) == null ?
l2.get(n) == null : l1.get(n).equals(l2.get(n)).
This implementation returns true if the object is this, or false if the object is not a List. Otherwise, it iterates over both lists (with iterator()), returning false if two elements compare false or one list is shorter, and true if the iteration completes successfully.
equals in interface Collection<E>equals in interface List<E>equals in class Objecto - the object to test for equality with this list
Object.equals(Object),
hashCode()public int hashCode()
hashCode = 1;
Iterator i = list.iterator();
while (i.hasNext())
{
Object obj = i.next();
hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
}
This ensures that the general contract of Object.hashCode() is adhered to.
hashCode in interface Collection<E>hashCode in interface List<E>hashCode in class ObjectObject.hashCode(),
equals(Object)public int indexOf(Object o)
indexOf in interface List<E>o - the object to search for
o == null ? get(n) == null :
o.equals(get(n)), or -1 if there is no such indexpublic Iterator<E> iterator()
return listIterator(0).
iterator in interface Iterable<E>iterator in interface Collection<E>iterator in interface List<E>iterator in class AbstractCollection<E>modCountpublic int lastIndexOf(Object o)
lastIndexOf in interface List<E>o == null ? get(n) == null
: o.equals(get(n)), or -1 if there is no such indexpublic ListIterator<E> listIterator()
listIterator in interface List<E>public ListIterator<E> listIterator(int index)
This implementation uses size(), get(int), set(int, Object), add(int, Object), and remove(int) of the backing list, and does not support remove, set, or add unless the list does. This implementation is fail-fast if you correctly maintain modCount.
listIterator in interface List<E>index - the position, between 0 and size() inclusive, to begin the
iteration from
IndexOutOfBoundsException - if index < 0 || index > size()modCountpublic E remove(int index)
remove in interface List<E>index - the position within the list of the object to remove
UnsupportedOperationException - if this list does not support the
remove operation
IndexOutOfBoundsException - if index < 0 || index >= size()modCount
protected void removeRange(int fromIndex,
int toIndex)
This implementation first checks for illegal or out of range arguments. It then obtains a ListIterator over the list using listIterator(fromIndex). It then calls next() and remove() on this iterator repeatedly, toIndex - fromIndex times.
fromIndex - the index, inclusive, to remove from.toIndex - the index, exclusive, to remove to.
UnsupportedOperationException - if the list does
not support removing elements.
public E set(int index,
E o)
set in interface List<E>index - the position within this list of the element to be replacedo - the object to replace it with
UnsupportedOperationException - if this list does not support the
set operation
IndexOutOfBoundsException - if index < 0 || index >= size()
ClassCastException - if o cannot be added to this list due to its
type
IllegalArgumentException - if o cannot be added to this list for
some other reason
public List<E> subList(int fromIndex,
int toIndex)
This implementation returns a subclass of AbstractList. It stores, in private fields, the offset and size of the sublist, and the expected modCount of the backing list. If the backing list implements RandomAccess, the sublist will also.
The subclass's set(int, Object), get(int),
add(int, Object), remove(int),
addAll(int, Collection) and
removeRange(int, int) methods all delegate to the
corresponding methods on the backing abstract list, after
bounds-checking the index and adjusting for the offset. The
addAll(Collection c) method merely returns addAll(size, c).
The listIterator(int) method returns a "wrapper object"
over a list iterator on the backing list, which is created with the
corresponding method on the backing list. The iterator()
method merely returns listIterator(), and the size() method
merely returns the subclass's size field.
All methods first check to see if the actual modCount of the backing list is equal to its expected value, and throw a ConcurrentModificationException if it is not.
subList in interface List<E>fromIndex - the index that the returned list should start from
(inclusive)toIndex - the index that the returned list should go to (exclusive)
IndexOutOfBoundsException - if fromIndex < 0
|| toIndex > size()
IllegalArgumentException - if fromIndex > toIndexConcurrentModificationException,
RandomAccess
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||