|
|||||||||
| 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>
java.util.ArrayList<E>
public class ArrayList<E>
An array-backed implementation of the List interface. This implements all optional list operations, and permits null elements, so that it is better than Vector, which it replaces. Random access is roughly constant time, and iteration is roughly linear time, so it is nice and fast, with less overhead than a LinkedList.
Each list has a capacity, and as the array reaches that capacity it is automatically transferred to a larger array. You also have access to ensureCapacity and trimToSize to control the backing array's size, avoiding reallocation or wasted memory.
ArrayList is not synchronized, so if you need multi-threaded access,
consider using:
List l = Collections.synchronizedList(new ArrayList(...));
The iterators are fail-fast, meaning that any structural
modification, except for remove() called on the iterator
itself, cause the iterator to throw a
ConcurrentModificationException rather than exhibit
non-deterministic behavior.
Collection,
List,
LinkedList,
Vector,
Collections.synchronizedList(List),
AbstractList,
Serialized Form| Field Summary |
|---|
| Fields inherited from class java.util.AbstractList |
|---|
modCount |
| Constructor Summary | |
|---|---|
ArrayList()
Construct a new ArrayList with the default capacity (16). |
|
ArrayList(Collection<? extends E> c)
Construct a new ArrayList, and initialize it with the elements in the supplied Collection. |
|
ArrayList(int capacity)
Construct a new ArrayList with the supplied initial capacity. |
|
| Method Summary | ||
|---|---|---|
boolean |
add(E e)
Appends the supplied element to the end of this list. |
|
void |
add(int index,
E e)
Adds the supplied element at the specified index, shifting all elements currently at that index or higher one to the right. |
|
boolean |
addAll(Collection<? extends E> c)
Add each element in the supplied Collection to this List. |
|
boolean |
addAll(int index,
Collection<? extends E> c)
Add all elements in the supplied collection, inserting them beginning at the specified index. |
|
void |
clear()
Removes all elements from this List |
|
Object |
clone()
Creates a shallow copy of this ArrayList (elements are not cloned). |
|
boolean |
contains(Object e)
Returns true iff element is in this ArrayList. |
|
void |
ensureCapacity(int minCapacity)
Guarantees that this list will have at least enough capacity to hold minCapacity elements. |
|
E |
get(int index)
Retrieves the element at the user-supplied index. |
|
int |
indexOf(Object e)
Returns the lowest index at which element appears in this List, or -1 if it does not appear. |
|
boolean |
isEmpty()
Checks if the list is empty. |
|
int |
lastIndexOf(Object e)
Returns the highest index at which element appears in this List, or -1 if it does not appear. |
|
E |
remove(int index)
Removes the element at the user-supplied index. |
|
protected void |
removeRange(int fromIndex,
int toIndex)
Removes all elements in the half-open interval [fromIndex, toIndex). |
|
E |
set(int index,
E e)
Sets the element at the specified index. |
|
int |
size()
Returns the number of elements in this list. |
|
Object[] |
toArray()
Returns an Object array containing all of the elements in this ArrayList. |
|
|
toArray(T[] a)
Returns an Array whose component type is the runtime component type of the passed-in Array. |
|
void |
trimToSize()
Trims the capacity of this List to be equal to its size; a memory saver. |
|
| Methods inherited from class java.util.AbstractList |
|---|
equals, hashCode, iterator, listIterator, listIterator, subList |
| Methods inherited from class java.util.AbstractCollection |
|---|
containsAll, remove, removeAll, retainAll, toString |
| Methods inherited from class java.lang.Object |
|---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.util.List |
|---|
containsAll, equals, hashCode, iterator, listIterator, listIterator, remove, removeAll, retainAll, subList |
| Constructor Detail |
|---|
public ArrayList(int capacity)
capacity - initial capacity of this ArrayList
IllegalArgumentException - if capacity is negativepublic ArrayList()
public ArrayList(Collection<? extends E> c)
c - the collection whose elements will initialize this list
NullPointerException - if c is null| Method Detail |
|---|
public void trimToSize()
public void ensureCapacity(int minCapacity)
minCapacity - the minimum guaranteed capacitypublic int size()
size in interface Collection<E>size in interface List<E>size in class AbstractCollection<E>public boolean isEmpty()
isEmpty in interface Collection<E>isEmpty in interface List<E>isEmpty in class AbstractCollection<E>AbstractCollection.size()public boolean contains(Object e)
contains in interface Collection<E>contains in interface List<E>contains in class AbstractCollection<E>e - the element whose inclusion in the List is being tested
public int indexOf(Object e)
indexOf in interface List<E>indexOf in class AbstractList<E>e - the element whose inclusion in the List is being tested
public int lastIndexOf(Object e)
lastIndexOf in interface List<E>lastIndexOf in class AbstractList<E>e - the element whose inclusion in the List is being tested
public Object clone()
clone in class ObjectCloneablepublic Object[] toArray()
toArray in interface Collection<E>toArray in interface List<E>toArray in class AbstractCollection<E>public <T> T[] toArray(T[] a)
toArray in interface Collection<E>toArray in interface List<E>toArray in class AbstractCollection<E>a - the passed-in Array
ArrayStoreException - if the runtime type of a does not allow
an element in this list
NullPointerException - if a is nullpublic E get(int index)
get in interface List<E>get in class AbstractList<E>index - the index of the element we are fetching
IndexOutOfBoundsException - if index < 0 || index >= size()
public E set(int index,
E e)
set in interface List<E>set in class AbstractList<E>index - the index at which the element is being sete - the element to be set
IndexOutOfBoundsException - if index < 0 || index >= 0public boolean add(E e)
add in interface Collection<E>add in interface List<E>add in class AbstractList<E>e - the element to be appended to this list
AbstractList.add(int, Object)
public void add(int index,
E e)
add in interface List<E>add in class AbstractList<E>index - the index at which the element is being addede - the item being added
IndexOutOfBoundsException - if index < 0 || index > size()AbstractList.modCountpublic E remove(int index)
remove in interface List<E>remove in class AbstractList<E>index - the index of the element to be removed
IndexOutOfBoundsException - if index < 0 || index >= size()AbstractList.modCountpublic void clear()
clear in interface Collection<E>clear in interface List<E>clear in class AbstractList<E>AbstractList.remove(int),
AbstractList.removeRange(int, int)public boolean addAll(Collection<? extends E> c)
addAll in interface Collection<E>addAll in interface List<E>addAll in class AbstractCollection<E>c - a Collection containing elements to be added to this List
NullPointerException - if c is nullAbstractCollection.add(Object)
public boolean addAll(int index,
Collection<? extends E> c)
addAll in interface List<E>addAll in class AbstractList<E>index - the index at which the elements will be insertedc - the Collection containing the elements to be inserted
IndexOutOfBoundsException - if index < 0 || index > 0
NullPointerException - if c is nullAbstractList.add(int, Object)
protected void removeRange(int fromIndex,
int toIndex)
removeRange in class AbstractList<E>fromIndex - the first index which will be removedtoIndex - one greater than the last index which will be removed
IndexOutOfBoundsException - if fromIndex > toIndex
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||