ArrayListpublic class ArrayList extends AbstractList implements Serializable, RandomAccess, List, Cloneable| ArrayList is an implementation of {@link List}, backed by an array. All
optional operations adding, removing, and replacing are supported. The
elements can be any objects. |
| Fields Summary |
|---|
| private static final long | serialVersionUID | | private static final Object[] | emptyArrayzero-element array | | private transient int | firstIndex | | private transient int | lastIndex | | private transient E[] | array | | private static final ObjectStreamField[] | serialPersistentFields |
| Constructors Summary |
|---|
public ArrayList()Constructs a new instance of {@code ArrayList} with zero capacity.
this(0);
| public ArrayList(int capacity)Constructs a new instance of {@code ArrayList} with the specified
capacity.
firstIndex = lastIndex = 0;
try {
array = newElementArray(capacity);
} catch (NegativeArraySizeException e) {
throw new IllegalArgumentException();
}
| public ArrayList(Collection collection)Constructs a new instance of {@code ArrayList} containing the elements of
the specified collection. The initial size of the {@code ArrayList} will
be 10% higher than the size of the specified collection.
int size = collection.size();
firstIndex = lastIndex = 0;
array = newElementArray(size + (size / 10));
addAll(collection);
|
| Methods Summary |
|---|
| public void | add(int location, E object)Inserts the specified object into this {@code ArrayList} at the specified
location. The object is inserted before any previous element at the
specified location. If the location is equal to the size of this
{@code ArrayList}, the object is added at the end.
// BEGIN android-changed: slight performance improvement
int size = lastIndex - firstIndex;
// END android-changed
if (0 < location && location < size) {
if (firstIndex == 0 && lastIndex == array.length) {
growForInsert(location, 1);
} else if ((location < size / 2 && firstIndex > 0)
|| lastIndex == array.length) {
System.arraycopy(array, firstIndex, array, --firstIndex,
location);
} else {
int index = location + firstIndex;
System.arraycopy(array, index, array, index + 1, size
- location);
lastIndex++;
}
array[location + firstIndex] = object;
} else if (location == 0) {
if (firstIndex == 0) {
growAtFront(1);
}
array[--firstIndex] = object;
} else if (location == size) {
if (lastIndex == array.length) {
growAtEnd(1);
}
array[lastIndex++] = object;
} else {
throw new IndexOutOfBoundsException();
}
modCount++;
| | public boolean | add(E object)Adds the specified object at the end of this {@code ArrayList}.
if (lastIndex == array.length) {
growAtEnd(1);
}
array[lastIndex++] = object;
modCount++;
return true;
| | public boolean | addAll(int location, java.util.Collection collection)Inserts the objects in the specified collection at the specified location
in this List. The objects are added in the order they are returned from
the collection's iterator.
int size = size();
if (location < 0 || location > size) {
throw new IndexOutOfBoundsException();
}
int growSize = collection.size();
if (0 < location && location < size) {
if (array.length - size < growSize) {
growForInsert(location, growSize);
} else if ((location < size / 2 && firstIndex > 0)
|| lastIndex > array.length - growSize) {
int newFirst = firstIndex - growSize;
if (newFirst < 0) {
int index = location + firstIndex;
System.arraycopy(array, index, array, index - newFirst,
size - location);
lastIndex -= newFirst;
newFirst = 0;
}
System.arraycopy(array, firstIndex, array, newFirst, location);
firstIndex = newFirst;
} else {
int index = location + firstIndex;
System.arraycopy(array, index, array, index + growSize, size
- location);
lastIndex += growSize;
}
} else if (location == 0) {
growAtFront(growSize);
firstIndex -= growSize;
} else if (location == size) {
if (lastIndex > array.length - growSize) {
growAtEnd(growSize);
}
lastIndex += growSize;
}
if (growSize > 0) {
Iterator<? extends E> it = collection.iterator();
int index = location + firstIndex;
int end = index + growSize;
while (index < end) {
array[index++] = it.next();
}
modCount++;
return true;
}
return false;
| | public boolean | addAll(java.util.Collection collection)Adds the objects in the specified collection to this {@code ArrayList}.
int growSize = collection.size();
if (growSize > 0) {
if (lastIndex > array.length - growSize) {
growAtEnd(growSize);
}
Iterator<? extends E> it = collection.iterator();
int end = lastIndex + growSize;
while (lastIndex < end) {
array[lastIndex++] = it.next();
}
modCount++;
return true;
}
return false;
| | public void | clear()Removes all elements from this {@code ArrayList}, leaving it empty.
if (firstIndex != lastIndex) {
Arrays.fill(array, firstIndex, lastIndex, null);
firstIndex = lastIndex = 0;
modCount++;
}
| | public java.lang.Object | clone()Returns a new {@code ArrayList} with the same elements, the same size and
the same capacity as this {@code ArrayList}.
try {
ArrayList<E> newList = (ArrayList<E>) super.clone();
newList.array = array.clone();
return newList;
} catch (CloneNotSupportedException e) {
return null;
}
| | public boolean | contains(java.lang.Object object)Searches this {@code ArrayList} for the specified object.
if (object != null) {
for (int i = firstIndex; i < lastIndex; i++) {
if (object.equals(array[i])) {
return true;
}
}
} else {
for (int i = firstIndex; i < lastIndex; i++) {
if (array[i] == null) {
return true;
}
}
}
return false;
| | public void | ensureCapacity(int minimumCapacity)Ensures that after this operation the {@code ArrayList} can hold the
specified number of elements without further growing.
if (array.length < minimumCapacity) {
if (firstIndex > 0) {
growAtFront(minimumCapacity - array.length);
} else {
growAtEnd(minimumCapacity - array.length);
}
}
| | public E | get(int location)
// BEGIN android-changed: slight performance improvement
int _firstIndex = firstIndex;
if (0 <= location && location < lastIndex - _firstIndex) {
return array[_firstIndex + location];
}
throw new IndexOutOfBoundsException("Invalid location " + location
+ ", size is " + (lastIndex - _firstIndex));
// END android-changed
| | private void | growAtEnd(int required)
int size = size();
if (firstIndex >= required - (array.length - lastIndex)) {
int newLast = lastIndex - firstIndex;
if (size > 0) {
System.arraycopy(array, firstIndex, array, 0, size);
int start = newLast < firstIndex ? firstIndex : newLast;
Arrays.fill(array, start, array.length, null);
}
firstIndex = 0;
lastIndex = newLast;
} else {
int increment = size / 2;
if (required > increment) {
increment = required;
}
if (increment < 12) {
increment = 12;
}
E[] newArray = newElementArray(size + increment);
if (size > 0) {
System.arraycopy(array, firstIndex, newArray, 0, size);
firstIndex = 0;
lastIndex = size;
}
array = newArray;
}
| | private void | growAtFront(int required)
int size = size();
if (array.length - lastIndex >= required) {
int newFirst = array.length - size;
if (size > 0) {
System.arraycopy(array, firstIndex, array, newFirst, size);
int length = firstIndex + size > newFirst ? newFirst
: firstIndex + size;
Arrays.fill(array, firstIndex, length, null);
}
firstIndex = newFirst;
lastIndex = array.length;
} else {
int increment = size / 2;
if (required > increment) {
increment = required;
}
if (increment < 12) {
increment = 12;
}
E[] newArray = newElementArray(size + increment);
if (size > 0) {
System.arraycopy(array, firstIndex, newArray, newArray.length
- size, size);
}
firstIndex = newArray.length - size;
lastIndex = newArray.length;
array = newArray;
}
| | private void | growForInsert(int location, int required)
int size = size(), increment = size / 2;
if (required > increment) {
increment = required;
}
if (increment < 12) {
increment = 12;
}
E[] newArray = newElementArray(size + increment);
if (location < size / 2) {
int newFirst = newArray.length - (size + required);
System.arraycopy(array, location, newArray, location + increment,
size - location);
System.arraycopy(array, firstIndex, newArray, newFirst, location);
firstIndex = newFirst;
lastIndex = newArray.length;
} else {
System.arraycopy(array, firstIndex, newArray, 0, location);
System.arraycopy(array, location, newArray, location + required,
size - location);
firstIndex = 0;
lastIndex += required;
}
array = newArray;
| | public int | indexOf(java.lang.Object object)
if (object != null) {
for (int i = firstIndex; i < lastIndex; i++) {
if (object.equals(array[i])) {
return i - firstIndex;
}
}
} else {
for (int i = firstIndex; i < lastIndex; i++) {
if (array[i] == null) {
return i - firstIndex;
}
}
}
return -1;
| | public boolean | isEmpty()
return lastIndex == firstIndex;
| | public int | lastIndexOf(java.lang.Object object)
if (object != null) {
for (int i = lastIndex - 1; i >= firstIndex; i--) {
if (object.equals(array[i])) {
return i - firstIndex;
}
}
} else {
for (int i = lastIndex - 1; i >= firstIndex; i--) {
if (array[i] == null) {
return i - firstIndex;
}
}
}
return -1;
| | private E[] | newElementArray(int size)
// BEGIN android-added
if (size == 0) {
return (E[])emptyArray;
}
// END android-added
return (E[])new Object[size];
| | private void | readObject(java.io.ObjectInputStream stream)
ObjectInputStream.GetField fields = stream.readFields();
lastIndex = fields.get("size", 0); //$NON-NLS-1$
array = newElementArray(stream.readInt());
for (int i = 0; i < lastIndex; i++) {
array[i] = (E)stream.readObject();
}
| | public E | remove(int location)Removes the object at the specified location from this list.
E result;
// BEGIN android-changed: slight performance improvement
int size = lastIndex - firstIndex;
// END android-changed
if (0 <= location && location < size) {
if (location == size - 1) {
result = array[--lastIndex];
array[lastIndex] = null;
} else if (location == 0) {
result = array[firstIndex];
array[firstIndex++] = null;
} else {
int elementIndex = firstIndex + location;
result = array[elementIndex];
if (location < size / 2) {
System.arraycopy(array, firstIndex, array, firstIndex + 1,
location);
array[firstIndex++] = null;
} else {
System.arraycopy(array, elementIndex + 1, array,
elementIndex, size - location - 1);
array[--lastIndex] = null;
}
}
} else {
throw new IndexOutOfBoundsException();
}
modCount++;
return result;
| | public boolean | remove(java.lang.Object object)
int index = indexOf(object);
if (index >= 0) {
remove(index);
return true;
}
return false;
| | protected void | removeRange(int start, int end)Removes the objects in the specified range from the start to the end, but
not including the end index.
if (start >= 0 && start <= end && end <= size()) {
if (start == end) {
return;
}
int size = size();
if (end == size) {
Arrays.fill(array, firstIndex + start, lastIndex, null);
lastIndex = firstIndex + start;
} else if (start == 0) {
Arrays.fill(array, firstIndex, firstIndex + end, null);
firstIndex += end;
} else {
System.arraycopy(array, firstIndex + end, array, firstIndex
+ start, size - end);
int newLast = lastIndex + start - end;
Arrays.fill(array, newLast, lastIndex, null);
lastIndex = newLast;
}
modCount++;
} else {
throw new IndexOutOfBoundsException();
}
| | public E | set(int location, E object)Replaces the element at the specified location in this {@code ArrayList}
with the specified object.
// BEGIN android-changed: slight performance improvement
if (0 <= location && location < (lastIndex - firstIndex)) {
// END android-changed
E result = array[firstIndex + location];
array[firstIndex + location] = object;
return result;
}
throw new IndexOutOfBoundsException();
| | public int | size()Returns the number of elements in this {@code ArrayList}.
return lastIndex - firstIndex;
| | public java.lang.Object[] | toArray()Returns a new array containing all elements contained in this
{@code ArrayList}.
int size = size();
Object[] result = new Object[size];
System.arraycopy(array, firstIndex, result, 0, size);
return result;
| | public T[] | toArray(T[] contents)Returns an array containing all elements contained in this
{@code ArrayList}. If the specified array is large enough to hold the
elements, the specified array is used, otherwise an array of the same
type is created. If the specified array is used and is larger than this
{@code ArrayList}, the array element following the collection elements
is set to null.
int size = size();
if (size > contents.length) {
Class<?> ct = contents.getClass().getComponentType();
contents = (T[]) Array.newInstance(ct, size);
}
System.arraycopy(array, firstIndex, contents, 0, size);
if (size < contents.length) {
contents[size] = null;
}
return contents;
| | public void | trimToSize()Sets the capacity of this {@code ArrayList} to be the same as the current
size.
int size = size();
E[] newArray = newElementArray(size);
System.arraycopy(array, firstIndex, newArray, 0, size);
array = newArray;
firstIndex = 0;
lastIndex = array.length;
| | private void | writeObject(java.io.ObjectOutputStream stream) //$NON-NLS-1$
ObjectOutputStream.PutField fields = stream.putFields();
fields.put("size", size()); //$NON-NLS-1$
stream.writeFields();
stream.writeInt(array.length);
Iterator<?> it = iterator();
while (it.hasNext()) {
stream.writeObject(it.next());
}
|
|
