java 的文档，自己看吧/**
* Resizable-array implementation of the <tt>List</tt> interface. Implements
* all optional list operations, and permits all elements, including
* <tt>null</tt>. In addition to implementing the <tt>List</tt> interface,
* this class provides methods to manipulate the size of the array that is
* used internally to store the list. (This class is roughly equivalent to
* <tt>Vector</tt>, except that it is unsynchronized.)<p>
*
* The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>,
* <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant
* time. The <tt>add</tt> operation runs in <i>amortized constant time</i>,
* 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 <tt>LinkedList</tt> implementation.<p>
*
* Each <tt>ArrayList</tt> instance has a <i>capacity</i>. 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 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.<p>
*
* An application can increase the capacity of an <tt>ArrayList</tt> instance
* before adding a large number of elements using the <tt>ensureCapacity</tt>
* operation. This may reduce the amount of incremental reallocation.<p>
*
* <strong>Note that this implementation is not synchronized.</strong> If
* multiple threads access an <tt>ArrayList</tt> instance concurrently, and at
* least one of the threads modifies the list structurally, it <i>must</i> 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 <tt>Collections.synchronizedList</tt>
* method. This is best done at creation time, to prevent accidental
* unsynchronized access to the list:
* <pre>
* List list = Collections.synchronizedList(new ArrayList(...));
* </pre><p>
*
* The iterators returned by this class's <tt>iterator</tt> and
* <tt>listIterator</tt> methods are <i>fail-fast</i>: if 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.
*
* <p>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 <tt>ConcurrentModificationException</tt> on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i>the fail-fast behavior of iterators
* should be used only to detect bugs.</i>
*
* @author Josh Bloch
* @version 1.36, 12/03/01
* @see Collection
* @see List
* @see LinkedList
* @see Vector
* @see CollectionssynchronizedList(List)
* @since 1.2
*/
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable；
/**
* The <code>Vector</code> class implements a growable array of
* objects. Like an array, it contains components that can be
* accessed using an integer index. However, the size of a
* <code>Vector</code> can grow or shrink as needed to accommodate
* adding and removing items after the <code>Vector</code> has been created.<p>
*
* Each vector tries to optimize storage management by maintaining a
* <code>capacity</code> and a <code>capacityIncrement</code>. The
* <code>capacity</code> is always at least as large as the vector
* size; it is usually larger because as components are added to the
* vector, the vector's storage increases in chunks the size of
* <code>capacityIncrement</code>. An application can increase the
* capacity of a vector before inserting a large number of
* components; this reduces the amount of incremental reallocation. <p>
*
* As of the Java 2 platform v1.2, this class has been retrofitted to
* implement List, so that it becomes a part of Java's collection framework.
* Unlike the new collection implementations, Vector is synchronized.<p>
*
* The Iterators returned by Vector's iterator and listIterator
* methods are <em>fail-fast</em>: if the Vector 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.
* The Enumerations returned by Vector's elements method are <em>not</em>
* fail-fast.
*
* <p>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 <tt>ConcurrentModificationException</tt> on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i>the fail-fast behavior of iterators
* should be used only to detect bugs.</i>
*
* @author Lee Boynton
* @author Jonathan Payne
* @version 1.85, 12/03/01
* @see Collection
* @see List
* @see ArrayList
* @see LinkedList
* @since JDK1.0
*/
public class Vector extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
