public abstract class AbstractList extends AbstractCollection implements List
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| Modifier and Type | Field and Description |
|---|---|
protected int |
modCount
A count of the number of structural modifications that have been made to
the list (that is, insertions and removals).
|
| Modifier | Constructor and Description |
|---|---|
protected |
AbstractList()
The main constructor, for use by subclasses.
|
| Modifier and Type | Method and Description |
|---|---|
void |
add(int index,
Object o)
Insert an element into the list at a given position (optional operation).
|
boolean |
add(Object o)
Add an element to the end of the list (optional operation).
|
boolean |
addAll(int index,
Collection 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 Object |
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 |
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 |
listIterator()
Obtain a ListIterator over this list, starting at the beginning.
|
ListIterator |
listIterator(int index)
Obtain a ListIterator over this list, starting at a given position.
|
Object |
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.
|
Object |
set(int index,
Object o)
Replace an element of this list with another object (optional operation).
|
List |
subList(int fromIndex,
int toIndex)
Obtain a List view of a subsection of this list, from fromIndex
(inclusive) to toIndex (exclusive).
|
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, toArray, toArray, toStringprotected 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.
protected AbstractList()
public abstract Object get(int index)
get in interface Listindex - the element to returnIndexOutOfBoundsException - if index < 0 || index >= size()public void add(int index,
Object o)
add in interface Listindex - the location to insert the itemo - the object to insertUnsupportedOperationException - if this list does not support the
add operationIndexOutOfBoundsException - if index < 0 || index > size()ClassCastException - if o cannot be added to this list due to its
typeIllegalArgumentException - if o cannot be added to this list for
some other reasonmodCountpublic boolean add(Object o)
add(size(), o);, and will fail if that version does.add in interface Collectionadd in interface Listadd in class AbstractCollectiono - the object to addUnsupportedOperationException - if this list does not support the
add operationClassCastException - if o cannot be added to this list due to its
typeIllegalArgumentException - if o cannot be added to this list for
some other reasonadd(int, Object)public boolean addAll(int index,
Collection c)
addAll in interface Listindex - the location to insert the collectionc - the collection to insertUnsupportedOperationException - if this list does not support the
addAll operationIndexOutOfBoundsException - if index < 0 || index > size()ClassCastException - if some element of c cannot be added to this
list due to its typeIllegalArgumentException - if some element of c cannot be added
to this list for some other reasonNullPointerException - 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 Collectionclear in interface Listclear in class AbstractCollectionUnsupportedOperationException - 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 Collectionequals in interface Listequals in class Objecto - the object to test for equality with this listObject.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 CollectionhashCode in interface ListhashCode in class ObjectObject.hashCode(),
equals(Object)public int indexOf(Object o)
public Iterator iterator()
return listIterator(0).iterator in interface Collectioniterator in interface Listiterator in class AbstractCollectionmodCountpublic int lastIndexOf(Object o)
lastIndexOf in interface Listo == null ? get(n) == null
: o.equals(get(n)), or -1 if there is no such indexpublic ListIterator listIterator()
listIterator in interface Listpublic ListIterator 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 Listindex - the position, between 0 and size() inclusive, to begin the
iteration fromIndexOutOfBoundsException - if index < 0 || index > size()modCountpublic Object remove(int index)
remove in interface Listindex - the position within the list of the object to removeUnsupportedOperationException - if this list does not support the
remove operationIndexOutOfBoundsException - if index < 0 || index >= size()modCountprotected 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.public Object set(int index, Object o)
set in interface Listindex - the position within this list of the element to be replacedo - the object to replace it withUnsupportedOperationException - if this list does not support the
set operationIndexOutOfBoundsException - if index < 0 || index >= size()ClassCastException - if o cannot be added to this list due to its
typeIllegalArgumentException - if o cannot be added to this list for
some other reasonpublic List 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 ListfromIndex - 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