mirror of git://gcc.gnu.org/git/gcc.git
418 lines
11 KiB
Java
418 lines
11 KiB
Java
/* ArrayList.java -- JDK1.2's answer to Vector; this is an array-backed
|
|
implementation of the List interface
|
|
Copyright (C) 1998, 1999, 2000 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., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA.
|
|
|
|
As a special exception, if you link this library with other files to
|
|
produce an executable, this library does not by itself cause the
|
|
resulting executable to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why the
|
|
executable file might be covered by the GNU General Public License. */
|
|
|
|
|
|
package java.util;
|
|
|
|
import java.lang.reflect.Array;
|
|
import java.io.Serializable;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
|
|
/**
|
|
* An array-backed implementation of the List interface. ArrayList
|
|
* performs well on simple tasks: random access into a list, appending
|
|
* to or removing from the end of a list, checking the size, &c.
|
|
*
|
|
* @author Jon A. Zeppieri
|
|
* @see java.util.AbstractList
|
|
* @see java.util.List
|
|
*/
|
|
public class ArrayList extends AbstractList
|
|
implements List, Cloneable, Serializable
|
|
{
|
|
/** the default capacity for new ArrayLists */
|
|
private static final int DEFAULT_CAPACITY = 16;
|
|
|
|
/** the number of elements in this list */
|
|
int size;
|
|
|
|
/** where the data is stored */
|
|
transient Object[] data;
|
|
|
|
/**
|
|
* Construct a new ArrayList with the supplied initial capacity.
|
|
*
|
|
* @param capacity Initial capacity of this ArrayList
|
|
*/
|
|
public ArrayList(int capacity)
|
|
{
|
|
data = new Object[capacity];
|
|
}
|
|
|
|
|
|
/**
|
|
* Construct a new ArrayList with the default capcity
|
|
*/
|
|
public ArrayList()
|
|
{
|
|
this(DEFAULT_CAPACITY);
|
|
}
|
|
|
|
/**
|
|
* Construct a new ArrayList, and initialize it with the elements
|
|
* in the supplied Collection; Sun specs say that the initial
|
|
* capacity is 110% of the Collection's size.
|
|
*
|
|
* @param c the collection whose elements will initialize this list
|
|
*/
|
|
public ArrayList(Collection c)
|
|
{
|
|
this((int) (c.size() * 1.1));
|
|
addAll(c);
|
|
}
|
|
|
|
/**
|
|
* Guarantees that this list will have at least enough capacity to
|
|
* hold minCapacity elements.
|
|
*
|
|
* @specnote This implementation will grow the list to
|
|
* max(current * 2, minCapacity) if (minCapacity > current). The JCL says
|
|
* explictly that "this method increases its capacity to minCap", while
|
|
* the JDK 1.3 online docs specify that the list will grow to at least the
|
|
* size specified.
|
|
* @param minCapacity the minimum guaranteed capacity
|
|
*/
|
|
public void ensureCapacity(int minCapacity)
|
|
{
|
|
Object[] newData;
|
|
int current = data.length;
|
|
|
|
if (minCapacity > current)
|
|
{
|
|
newData = new Object[Math.max((current * 2), minCapacity)];
|
|
System.arraycopy(data, 0, newData, 0, size);
|
|
data = newData;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Appends the supplied element to the end of this list.
|
|
*
|
|
* @param e the element to be appended to this list
|
|
*/
|
|
public boolean add(Object e)
|
|
{
|
|
modCount++;
|
|
if (size == data.length)
|
|
ensureCapacity(size + 1);
|
|
data[size++] = e;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the element at the user-supplied index.
|
|
*
|
|
* @param index the index of the element we are fetching
|
|
* @throws IndexOutOfBoundsException (iIndex < 0) || (iIndex >= size())
|
|
*/
|
|
public Object get(int index)
|
|
{
|
|
if (index < 0 || index >= size)
|
|
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" +
|
|
size);
|
|
return data[index];
|
|
}
|
|
|
|
/**
|
|
* Returns the number of elements in this list
|
|
*/
|
|
public int size()
|
|
{
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Removes the element at the user-supplied index
|
|
*
|
|
* @param iIndex the index of the element to be removed
|
|
* @return the removed Object
|
|
* @throws IndexOutOfBoundsException (iIndex < 0) || (iIndex >= size())
|
|
*/
|
|
public Object remove(int index)
|
|
{
|
|
modCount++;
|
|
if (index < 0 || index > size)
|
|
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" +
|
|
size);
|
|
Object r = data[index];
|
|
if (index != --size)
|
|
System.arraycopy(data, (index + 1), data, index, (size - index));
|
|
data[size] = null;
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* Removes all elements in the half-open interval [iFromIndex, iToIndex).
|
|
*
|
|
* @param fromIndex the first index which will be removed
|
|
* @param toIndex one greater than the last index which will be
|
|
* removed
|
|
*/
|
|
protected void removeRange(int fromIndex, int toIndex)
|
|
{
|
|
modCount++;
|
|
if (fromIndex != toIndex)
|
|
{
|
|
System.arraycopy(data, toIndex, data, fromIndex, size - toIndex);
|
|
size -= (toIndex - fromIndex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the supplied element at the specified index, shifting all
|
|
* elements currently at that index or higher one to the right.
|
|
*
|
|
* @param index the index at which the element is being added
|
|
* @param e the item being added
|
|
*/
|
|
public void add(int index, Object e)
|
|
{
|
|
modCount++;
|
|
if (index < 0 || index > size)
|
|
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" +
|
|
size);
|
|
if (size == data.length)
|
|
ensureCapacity(size + 1);
|
|
if (index != size)
|
|
System.arraycopy(data, index, data, index + 1, size - index);
|
|
data[index] = e;
|
|
size++;
|
|
}
|
|
|
|
/**
|
|
* Add each element in the supplied Collection to this List.
|
|
*
|
|
* @param c a Collection containing elements to be
|
|
* added to this List
|
|
*/
|
|
public boolean addAll(Collection c)
|
|
{
|
|
return addAll(size, c);
|
|
}
|
|
|
|
/**
|
|
* Add all elements in the supplied collection, inserting them beginning
|
|
* at the specified index.
|
|
*
|
|
* @param index the index at which the elements will be inserted
|
|
* @param c the Collection containing the elements to be
|
|
* inserted
|
|
*/
|
|
public boolean addAll(int index, Collection c)
|
|
{
|
|
if (index < 0 || index > size)
|
|
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" +
|
|
size);
|
|
modCount++;
|
|
Iterator itr = c.iterator();
|
|
int csize = c.size();
|
|
|
|
if (csize + size > data.length)
|
|
ensureCapacity(size + csize);
|
|
int end = index + csize;
|
|
if (size > 0 && index != size)
|
|
System.arraycopy(data, index, data, end, csize);
|
|
size += csize;
|
|
for (; index < end; index++)
|
|
{
|
|
data[index] = itr.next();
|
|
}
|
|
return (csize > 0);
|
|
}
|
|
|
|
/**
|
|
* Creates a shallow copy of this ArrayList
|
|
*/
|
|
public Object clone()
|
|
{
|
|
ArrayList clone = null;
|
|
try
|
|
{
|
|
clone = (ArrayList) super.clone();
|
|
clone.data = new Object[data.length];
|
|
System.arraycopy(data, 0, clone.data, 0, size);
|
|
}
|
|
catch (CloneNotSupportedException e) {}
|
|
return clone;
|
|
}
|
|
|
|
/**
|
|
* Returns true iff oElement is in this ArrayList.
|
|
*
|
|
* @param e the element whose inclusion in the List is being
|
|
* tested
|
|
*/
|
|
public boolean contains(Object e)
|
|
{
|
|
return (indexOf(e) != -1);
|
|
}
|
|
|
|
/**
|
|
* Returns the lowest index at which oElement appears in this List, or
|
|
* -1 if it does not appear.
|
|
*
|
|
* @param e the element whose inclusion in the List is being
|
|
* tested
|
|
*/
|
|
public int indexOf(Object e)
|
|
{
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
if (e == null ? data[i] == null : e.equals(data[i]))
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the highest index at which oElement appears in this List, or
|
|
* -1 if it does not appear.
|
|
*
|
|
* @param e the element whose inclusion in the List is being
|
|
* tested
|
|
*/
|
|
public int lastIndexOf(Object e)
|
|
{
|
|
int i;
|
|
|
|
for (i = size - 1; i >= 0; i--)
|
|
{
|
|
if (e == null ? data[i] == null : e.equals(data[i]))
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Removes all elements from this List
|
|
*/
|
|
public void clear()
|
|
{
|
|
modCount++;
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
data[i] = null;
|
|
}
|
|
size = 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the element at the specified index.
|
|
*
|
|
* @param index the index at which the element is being set
|
|
* @param e the element to be set
|
|
* @return the element previously at the specified index, or null if
|
|
* none was there
|
|
*/
|
|
public Object set(int index, Object e)
|
|
{
|
|
Object result;
|
|
if (index < 0 || index >= size)
|
|
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" +
|
|
size);
|
|
result = data[index];
|
|
// SEH: no structural change, so don't update modCount
|
|
data[index] = e;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns an Object Array containing all of the elements in this ArrayList
|
|
*/
|
|
public Object[] toArray()
|
|
{
|
|
Object[] array = new Object[size];
|
|
System.arraycopy(data, 0, array, 0, size);
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Returns an Array whose component type is the runtime component type of
|
|
* the passed-in Array. The returned Array is populated with all of the
|
|
* elements in this ArrayList. If the passed-in Array is not large enough
|
|
* to store all of the elements in this List, a new Array will be created
|
|
* and returned; if the passed-in Array is <i>larger</i> than the size
|
|
* of this List, then size() index will be set to null.
|
|
*
|
|
* @param array the passed-in Array
|
|
*/
|
|
public Object[] toArray(Object[] array)
|
|
{
|
|
if (array.length < size)
|
|
array = (Object[]) Array.newInstance(array.getClass().getComponentType(),
|
|
size);
|
|
else if (array.length > size)
|
|
array[size] = null;
|
|
System.arraycopy(data, 0, array, 0, size);
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Trims the capacity of this List to be equal to its size;
|
|
* a memory saver.
|
|
*/
|
|
public void trimToSize()
|
|
{
|
|
// not a structural change from the perspective of iterators on this list,
|
|
// so don't update modCount
|
|
Object[] newData = new Object[size];
|
|
System.arraycopy(data, 0, newData, 0, size);
|
|
data = newData;
|
|
}
|
|
|
|
private void writeObject(ObjectOutputStream out) throws IOException
|
|
{
|
|
int i;
|
|
|
|
// The 'size' field.
|
|
out.defaultWriteObject();
|
|
|
|
// FIXME: Do we really want to serialize unused list entries??
|
|
out.writeInt(data.length);
|
|
for (i = 0; i < data.length; i++)
|
|
out.writeObject(data[i]);
|
|
}
|
|
|
|
private void readObject(ObjectInputStream in)
|
|
throws IOException, ClassNotFoundException
|
|
{
|
|
int i;
|
|
int capacity;
|
|
|
|
// the `size' field.
|
|
in.defaultReadObject();
|
|
|
|
capacity = in.readInt();
|
|
data = new Object[capacity];
|
|
|
|
for (i = 0; i < capacity; i++)
|
|
data[i] = in.readObject();
|
|
}
|
|
}
|