java.util
Class AbstractList<E>
- Collection<E>, Iterable<E>, List<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.
protected int | modCount- A count of the number of structural modifications that have been made to
the list (that is, insertions and removals).
|
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, 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 | 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.
|
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 | subList(int fromIndex, int toIndex)- Obtain a List view of a subsection of this list, from fromIndex
(inclusive) to toIndex (exclusive).
|
T[] toArray, add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toString |
clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait |
modCount
protected 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.
AbstractList
protected AbstractList()
The main constructor, for use by subclasses.
add
public boolean add(E 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.
- add in interface List<E>
- add in interface Collection<E>
- add in interface AbstractCollection<E>
- true, as defined by Collection for a modified list
add
public void add(int index,
E 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.
- add in interface List<E>
index - the location to insert the itemo - the object to insert
addAll
public boolean addAll(int index,
E> 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.
- addAll in interface List<E>
index - the location to insert the collectionc - the collection to insert
- true if the list was modified by this action, that is, if c is
non-empty
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.
- clear in interface List<E>
- clear in interface Collection<E>
- clear in interface AbstractCollection<E>
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.
- equals in interface List<E>
- equals in interface Collection<E>
- equals in interface Object
o - the object to test for equality with this list
- true if o is equal to this list
get
public abstract E get(int index)
Returns the elements at the specified position in the list.
- get in interface List<E>
index - the element to return
- the element at that position
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.
- hashCode in interface List<E>
- hashCode in interface Collection<E>
- hashCode in interface Object
- the hash code of this list
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.
- indexOf in interface List<E>
o - the object to search for
- 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).
- iterator in interface List<E>
- iterator in interface Collection<E>
- iterator in interface Iterable<E>
- iterator in interface AbstractCollection<E>
- an Iterator over the elements of this list, in order
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.
- lastIndexOf in interface List<E>
- 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).
- listIterator in interface List<E>
- 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.
- listIterator in interface List<E>
index - the position, between 0 and size() inclusive, to begin the
iteration from
- a ListIterator over the elements of this list, in order, starting
at index
remove
public E 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.
- remove in interface List<E>
index - the position within the list of the object to remove
- the object that was removed
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.
fromIndex - the index, inclusive, to remove from.toIndex - the index, exclusive, to remove to.
set
public E set(int index,
E o) Replace an element of this list with another object (optional operation).
This implementation always throws an UnsupportedOperationException.
- set in interface List<E>
index - the position within this list of the element to be replacedo - the object to replace it with
- the object that was replaced
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.
- 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)
- a List backed by a subsection of this list
AbstractList.java -- Abstract implementation of most of List
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005
Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version.