public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.
Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.
Note that this implementation is not synchronized.
If multiple threads access an ArrayList instance concurrently,
and at least one of the threads modifies the list structurally, it
must be synchronized externally. (A structural modification is
any operation that adds or deletes one or more elements, or explicitly
resizes the backing array; merely setting the value of an element is not
a structural modification.) This is typically accomplished by
synchronizing on some object that naturally encapsulates the list.
If no such object exists, the list should be "wrapped" using the
Collections.synchronizedList
method. This is best done at creation time, to prevent accidental
unsynchronized access to the list:
List list = Collections.synchronizedList(new ArrayList(...));
The iterators returned by this class's iterator and
listIterator methods are fail-fast:
if the list is structurally modified at any time after the iterator is
created, in any way except through the iterator's own
remove or
add methods, the iterator will throw a
ConcurrentModificationException. Thus, in the face of
concurrent modification, the iterator fails quickly and cleanly, rather
than risking arbitrary, non-deterministic behavior at an undetermined
time in the future.
Note that the fail-fast behavior of an iterator cannot be guaranteed
as it is, generally speaking, impossible to make any hard guarantees in the
presence of unsynchronized concurrent modification. Fail-fast iterators
throw ConcurrentModificationException on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators
should be used only to detect bugs.
This class is a member of the Java Collections Framework.
Collection,
List,
LinkedList,
Vector,
Serialized FormmodCount| Constructor and Description |
|---|
ArrayList()
Constructs an empty list with an initial capacity of ten.
|
ArrayList(Collection<? extends E> c)
Constructs a list containing the elements of the specified
collection, in the order they are returned by the collection's
iterator.
|
ArrayList(int initialCapacity)
Constructs an empty list with the specified initial capacity.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
add(E e)
Appends the specified element to the end of this list.
|
void |
add(int index,
E element)
Inserts the specified element at the specified position in this
list.
|
boolean |
addAll(Collection<? extends E> c)
Appends all of the elements in the specified collection to the end of
this list, in the order that they are returned by the
specified collection's Iterator.
|
boolean |
addAll(int index,
Collection<? extends E> c)
Inserts all of the elements in the specified collection into this
list, starting at the specified position.
|
void |
clear()
Removes all of the elements from this list.
|
Object |
clone()
Returns a shallow copy of this ArrayList instance.
|
boolean |
contains(Object o)
Returns true if this list contains the specified element.
|
void |
ensureCapacity(int minCapacity)
Increases the capacity of this ArrayList instance, if
necessary, to ensure that it can hold at least the number of elements
specified by the minimum capacity argument.
|
void |
forEach(Consumer<? super E> action)
Performs the given action for each element of the
Iterable
until all elements have been processed or the action throws an
exception. |
E |
get(int index)
Returns the element at the specified position in this list.
|
int |
indexOf(Object o)
Returns the index of the first occurrence of the specified element
in this list, or -1 if this list does not contain the element.
|
boolean |
isEmpty()
Returns true if this list contains no elements.
|
Iterator<E> |
iterator()
Returns an iterator over the elements in this list in proper sequence.
|
int |
lastIndexOf(Object o)
Returns the index of the last occurrence of the specified element
in this list, or -1 if this list does not contain the element.
|
ListIterator<E> |
listIterator()
Returns a list iterator over the elements in this list (in proper
sequence).
|
ListIterator<E> |
listIterator(int index)
Returns a list iterator over the elements in this list (in proper
sequence), starting at the specified position in the list.
|
E |
remove(int index)
Removes the element at the specified position in this list.
|
boolean |
remove(Object o)
Removes the first occurrence of the specified element from this list,
if it is present.
|
boolean |
removeAll(Collection<?> c)
Removes from this list all of its elements that are contained in the
specified collection.
|
boolean |
removeIf(Predicate<? super E> filter)
Removes all of the elements of this collection that satisfy the given
predicate.
|
protected void |
removeRange(int fromIndex,
int toIndex)
Removes from this list all of the elements whose index is between
fromIndex, inclusive, and toIndex, exclusive. |
void |
replaceAll(UnaryOperator<E> operator)
Replaces each element of this list with the result of applying the
operator to that element.
|
boolean |
retainAll(Collection<?> c)
Retains only the elements in this list that are contained in the
specified collection.
|
E |
set(int index,
E element)
Replaces the element at the specified position in this list with
the specified element.
|
int |
size()
Returns the number of elements in this list.
|
void |
sort(Comparator<? super E> c)
Sorts this list according to the order induced by the specified
Comparator. |
Spliterator<E> |
spliterator()
Creates a late-binding
and fail-fast
Spliterator over the elements in this
list. |
List<E> |
subList(int fromIndex,
int toIndex)
Returns a view of the portion of this list between the specified
fromIndex, inclusive, and toIndex, exclusive. |
Object[] |
toArray()
Returns an array containing all of the elements in this list
in proper sequence (from first to last element).
|
<T> T[] |
toArray(T[] a)
Returns an array containing all of the elements in this list in proper
sequence (from first to last element); the runtime type of the returned
array is that of the specified array.
|
void |
trimToSize()
Trims the capacity of this ArrayList instance to be the
list's current size.
|
equals, hashCodecontainsAll, toStringfinalize, getClass, notify, notifyAll, wait, wait, waitcontainsAll, equals, hashCodeparallelStream, streampublic ArrayList(int initialCapacity)
initialCapacity - the initial capacity of the listIllegalArgumentException - if the specified initial capacity
is negativepublic ArrayList()
public ArrayList(Collection<? extends E> c)
c - the collection whose elements are to be placed into this listNullPointerException - if the specified collection is nullpublic void trimToSize()
public void ensureCapacity(int minCapacity)
minCapacity - the desired minimum 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>public boolean contains(Object o)
contains in interface Collection<E>contains in interface List<E>contains in class AbstractCollection<E>o - element whose presence in this list is to be testedpublic int indexOf(Object o)
public int lastIndexOf(Object o)
lastIndexOf in interface List<E>lastIndexOf in class AbstractList<E>o - element to search forpublic Object clone()
public Object[] toArray()
The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
toArray in interface Collection<E>toArray in interface List<E>toArray in class AbstractCollection<E>Arrays.asList(Object[])public <T> T[] toArray(T[] a)
If the list fits in the specified array with room to spare (i.e., the array has more elements than the list), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)
toArray in interface Collection<E>toArray in interface List<E>toArray in class AbstractCollection<E>T - the runtime type of the array to contain the collectiona - the array into which the elements of the list are to
be stored, if it is big enough; otherwise, a new array of the
same runtime type is allocated for this purpose.ArrayStoreException - if the runtime type of the specified array
is not a supertype of the runtime type of every element in
this listNullPointerException - if the specified array is nullpublic E get(int index)
get in interface List<E>get in class AbstractList<E>index - index of the element to returnIndexOutOfBoundsException - if the index is out of range
(index < 0 || index >= size())public E set(int index, E element)
set in interface List<E>set in class AbstractList<E>index - index of the element to replaceelement - element to be stored at the specified positionIndexOutOfBoundsException - if the index is out of range
(index < 0 || index >= size())public boolean add(E e)
add in interface Collection<E>add in interface List<E>add in class AbstractList<E>e - element to be appended to this listCollection.add(E))public void add(int index,
E element)
add in interface List<E>add in class AbstractList<E>index - index at which the specified element is to be insertedelement - element to be insertedIndexOutOfBoundsException - if the index is out of range
(index < 0 || index > size())public E remove(int index)
remove in interface List<E>remove in class AbstractList<E>index - the index of the element to be removedIndexOutOfBoundsException - if the index is out of range
(index < 0 || index >= size())public boolean remove(Object o)
remove in interface Collection<E>remove in interface List<E>remove in class AbstractCollection<E>o - element to be removed from this list, if presentpublic void clear()
clear in interface Collection<E>clear in interface List<E>clear in class AbstractList<E>public boolean addAll(Collection<? extends E> c)
addAll in interface Collection<E>addAll in interface List<E>addAll in class AbstractCollection<E>c - collection containing elements to be added to this listNullPointerException - if the specified collection is nullAbstractCollection.add(Object)public boolean addAll(int index,
Collection<? extends E> c)
addAll in interface List<E>addAll in class AbstractList<E>index - index at which to insert the first element from the
specified collectionc - collection containing elements to be added to this listIndexOutOfBoundsException - if the index is out of range
(index < 0 || index > size())NullPointerException - if the specified collection is nullprotected void removeRange(int fromIndex,
int toIndex)
fromIndex, inclusive, and toIndex, exclusive.
Shifts any succeeding elements to the left (reduces their index).
This call shortens the list by (toIndex - fromIndex) elements.
(If toIndex==fromIndex, this operation has no effect.)removeRange in class AbstractList<E>fromIndex - index of first element to be removedtoIndex - index after last element to be removedIndexOutOfBoundsException - if fromIndex or
toIndex is out of range
(fromIndex < 0 ||
fromIndex >= size() ||
toIndex > size() ||
toIndex < fromIndex)public boolean removeAll(Collection<?> c)
removeAll in interface Collection<E>removeAll in interface List<E>removeAll in class AbstractCollection<E>c - collection containing elements to be removed from this listtrue if this list changed as a result of the callClassCastException - if the class of an element of this list
is incompatible with the specified collection
(optional)NullPointerException - if this list contains a null element and the
specified collection does not permit null elements
(optional),
or if the specified collection is nullCollection.contains(Object)public boolean retainAll(Collection<?> c)
retainAll in interface Collection<E>retainAll in interface List<E>retainAll in class AbstractCollection<E>c - collection containing elements to be retained in this listtrue if this list changed as a result of the callClassCastException - if the class of an element of this list
is incompatible with the specified collection
(optional)NullPointerException - if this list contains a null element and the
specified collection does not permit null elements
(optional),
or if the specified collection is nullCollection.contains(Object)public ListIterator<E> listIterator(int index)
next.
An initial call to previous would
return the element with the specified index minus one.
The returned list iterator is fail-fast.
listIterator in interface List<E>listIterator in class AbstractList<E>index - index of the first element to be returned from the
list iterator (by a call to next)IndexOutOfBoundsException - if the index is out of range
(index < 0 || index > size())public ListIterator<E> listIterator()
The returned list iterator is fail-fast.
listIterator in interface List<E>listIterator in class AbstractList<E>listIterator(int)public Iterator<E> iterator()
The returned iterator is fail-fast.
public List<E> subList(int fromIndex, int toIndex)
fromIndex, inclusive, and toIndex, exclusive. (If
fromIndex and toIndex are equal, the returned list is
empty.) The returned list is backed by this list, so non-structural
changes in the returned list are reflected in this list, and vice-versa.
The returned list supports all of the optional list operations.
This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:
list.subList(from, to).clear();
Similar idioms may be constructed for indexOf(Object) and
lastIndexOf(Object), and all of the algorithms in the
Collections class can be applied to a subList.
The semantics of the list returned by this method become undefined if the backing list (i.e., this list) is structurally modified in any way other than via the returned list. (Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.)
subList in interface List<E>subList in class AbstractList<E>fromIndex - low endpoint (inclusive) of the subListtoIndex - high endpoint (exclusive) of the subListIndexOutOfBoundsException - if an endpoint index value is out of range
(fromIndex < 0 || toIndex > size)IllegalArgumentException - if the endpoint indices are out of order
(fromIndex > toIndex)public void forEach(Consumer<? super E> action)
IterableIterable
until all elements have been processed or the action throws an
exception. Unless otherwise specified by the implementing class,
actions are performed in the order of iteration (if an iteration order
is specified). Exceptions thrown by the action are relayed to the
caller.public Spliterator<E> spliterator()
Spliterator over the elements in this
list.
The Spliterator reports Spliterator.SIZED,
Spliterator.SUBSIZED, and Spliterator.ORDERED.
Overriding implementations should document the reporting of additional
characteristic values.
spliterator in interface Iterable<E>spliterator in interface Collection<E>spliterator in interface List<E>Spliterator over the elements in this listpublic boolean removeIf(Predicate<? super E> filter)
CollectionremoveIf in interface Collection<E>filter - a predicate which returns true for elements to be
removedtrue if any elements were removedpublic void replaceAll(UnaryOperator<E> operator)
ListreplaceAll in interface List<E>operator - the operator to apply to each elementpublic void sort(Comparator<? super E> c)
ListComparator.
All elements in this list must be mutually comparable using the
specified comparator (that is, c.compare(e1, e2) must not throw
a ClassCastException for any elements e1 and e2
in the list).
If the specified comparator is null then all elements in this
list must implement the Comparable interface and the elements'
natural ordering should be used.
This list must be modifiable, but need not be resizable.
sort in interface List<E>c - the Comparator used to compare list elements.
A null value indicates that the elements'
natural ordering should be used Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2024, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.