java.util
Class AbstractList

java.lang.Object
  java.util.AbstractCollection
      java.util.AbstractList

All Implemented Interfaces:

Collection, List

Direct Known Subclasses:

ArrayList, Vector

public abstract class AbstractList
extends AbstractCollection
implements List

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.

Since:

1.2

See Also:

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

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

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

modCount

protected transient int modCount

A count of the number of structural modifications that have been made to the list (that is, insertions and removals). Structural modifications are ones which change the list size or affect how iterations would behave. This field is available for use by Iterator and ListIterator, in order to throw a 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

AbstractList

protected AbstractList()

The main constructor, for use by subclasses.

Method Detail

get

public abstract Object get(int index)

Returns the elements at the specified position in the list.

Specified by:

get in interface List

Parameters:

index - the element to return

Returns:

the element at that position

Throws:

IndexOutOfBoundsException - if index < 0 || index >= size()

add

public void add(int index,
                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 implementation always throws UnsupportedOperationException, and must be overridden to make a modifiable List. If you want fail-fast iterators, be sure to increment modCount when overriding this.

Specified by:

add in interface List

Parameters:

index - the location to insert the item

o - the object to insert

Throws:

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 reason

See Also:

modCount

add

public boolean add(Object o)

Add an element to the end of the list (optional operation). If the list imposes restraints on what can be inserted, such as no null elements, this should be documented. This implementation calls add(size(), o);, and will fail if that version does.

Specified by:

add in interface Collection

Specified by:

add in interface List

Overrides:

add in class AbstractCollection

Parameters:

o - the object to add

Returns:

true, as defined by Collection for a modified list

Throws:

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 reason

See Also:

add(int, Object)

addAll

public boolean addAll(int index,
                      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 uses the iterator of the collection, repeatedly calling add(int, Object); this will fail if add does. This can often be made more efficient.

Specified by:

addAll in interface List

Parameters:

index - the location to insert the collection

c - the collection to insert

Returns:

true if the list was modified by this action, that is, if c is non-empty

Throws:

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 null

See Also:

add(int, Object)

clear

public void clear()

Clear the list, such that a subsequent call to isEmpty() would return true (optional operation). This implementation calls removeRange(0, size()), so it will fail unless remove or removeRange is overridden.

Specified by:

clear in interface Collection

Specified by:

clear in interface List

Overrides:

clear in class AbstractCollection

Throws:

UnsupportedOperationException - if this list does not support the clear operation

See Also:

remove(int), removeRange(int, int)

equals

public boolean equals(Object o)

Test whether this list is equal to another object. A List is defined to be equal to an object if and only if that object is also a List, and the two lists have the same sequence. Two lists l1 and l2 are equal if and only if 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.

Specified by:

equals in interface Collection

Specified by:

equals in interface List

Overrides:

equals in class Object

Parameters:

o - the object to test for equality with this list

Returns:

true if o is equal to this list

See Also:

Object.equals(Object), hashCode()

hashCode

public int hashCode()

Obtains a hash code for this list. In order to obey the general contract of the hashCode method of class Object, this value is calculated as follows:

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.

Specified by:

hashCode in interface Collection

Specified by:

hashCode in interface List

Overrides:

hashCode in class Object

Returns:

the hash code of this list

See Also:

Object.hashCode(), equals(Object)

indexOf

public int indexOf(Object o)

Obtain the first index at which a given object is to be found in this list. This implementation follows a listIterator() until a match is found, or returns -1 if the list end is reached.

Specified by:

indexOf in interface List

Parameters:

o - the object to search for

Returns:

the least integer n such that o == null ? get(n) == null : o.equals(get(n)), or -1 if there is no such index

iterator

public Iterator iterator()

Obtain an Iterator over this list, whose sequence is the list order. This implementation uses size(), get(int), and remove(int) of the backing list, and does not support remove unless the list does. This implementation is fail-fast if you correctly maintain modCount. Also, this implementation is specified by Sun to be distinct from listIterator, although you could easily implement it as return listIterator(0).

Specified by:

iterator in interface Collection

Specified by:

iterator in interface List

Specified by:

iterator in class AbstractCollection

Returns:

an Iterator over the elements of this list, in order

See Also:

modCount

lastIndexOf

public int lastIndexOf(Object o)

Obtain the last index at which a given object is to be found in this list. This implementation grabs listIterator(size()), then searches backwards for a match or returns -1.

Specified by:

lastIndexOf in interface List

Returns:

the greatest integer n such that o == null ? get(n) == null : o.equals(get(n)), or -1 if there is no such index

listIterator

public ListIterator listIterator()

Obtain a ListIterator over this list, starting at the beginning. This implementation returns listIterator(0).

Specified by:

listIterator in interface List

Returns:

a ListIterator over the elements of this list, in order, starting at the beginning

listIterator

public ListIterator listIterator(int index)

Obtain a ListIterator over this list, starting at a given position. A first call to next() would return the same as get(index), and a first call to previous() would return the same as get(index - 1).

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.

Specified by:

listIterator in interface List

Parameters:

index - the position, between 0 and size() inclusive, to begin the iteration from

Returns:

a ListIterator over the elements of this list, in order, starting at index

Throws:

IndexOutOfBoundsException - if index < 0 || index > size()

See Also:

modCount

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 always throws an UnsupportedOperationException. If you want fail-fast iterators, be sure to increment modCount when overriding this.

Specified by:

remove in interface List

Parameters:

index - the position within the list of the object to remove

Returns:

the object that was removed

Throws:

UnsupportedOperationException - if this list does not support the remove operation

IndexOutOfBoundsException - if index < 0 || index >= size()

See Also:

modCount

removeRange

protected void removeRange(int fromIndex,
                           int toIndex)

Remove a subsection of the list. This is called by the clear and removeRange methods of the class which implements subList, which are difficult for subclasses to override directly. Therefore, this method should be overridden instead by the more efficient implementation, if one exists. Overriding this can reduce quadratic efforts to constant time in some cases!

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.

Parameters:

fromIndex - the index, inclusive, to remove from.

toIndex - the index, exclusive, to remove to.

Throws:

UnsupportedOperationException - if the list does not support removing elements.

set

public Object set(int index,
                  Object o)

Replace an element of this list with another object (optional operation). This implementation always throws an UnsupportedOperationException.

Specified by:

set in interface List

Parameters:

index - the position within this list of the element to be replaced

o - the object to replace it with

Returns:

the object that was replaced

Throws:

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

subList

public List subList(int fromIndex,
                    int toIndex)

Obtain a List view of a subsection of this list, from fromIndex (inclusive) to toIndex (exclusive). If the two indices are equal, the sublist is empty. The returned list should be modifiable if and only if this list is modifiable. Changes to the returned list should be reflected in this list. If this list is structurally modified in any way other than through the returned list, the result of any subsequent operations on the returned list is undefined.

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.

Specified by:

subList in interface List

Parameters:

fromIndex - the index that the returned list should start from (inclusive)

toIndex - the index that the returned list should go to (exclusive)

Returns:

a List backed by a subsection of this list

Throws:

IndexOutOfBoundsException - if fromIndex < 0 || toIndex > size()

IllegalArgumentException - if fromIndex > toIndex

See Also:

ConcurrentModificationException, RandomAccess