第1个回答 2008-03-28
1、什么是ArrayList
ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：
动态的增加和减少元素
实现了ICollection和IList接口
灵活的设置数组的大小
2、如何使用ArrayList
最简单的例子：
ArrayList List = new ArrayList();
for( int i=0;i<10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i<3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法
3、ArrayList重要的方法和属性
1）构造器
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组
2）IsSynchronized属性和ArrayList.Synchronized方法
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：
ArrayList list = new ArrayList();
//...
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性
{
list.Add( “Add a Item” );
}
如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上 ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。
3）Count属性和Capacity属性
Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。
4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
这几个方法比较类似
Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动
另外，还有几个类似的方法：
Clear方法用于清除现有所有的元素
Contains方法用来查找某个对象在不在列表之中
其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细
5）TrimSize方法
这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。
6）ToArray方法
这个方法把ArrayList的元素Copy到一个新的数组中。
4、ArrayList与数组转换
例1：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));
例2：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);
Int32[] values = new Int32[List.Count];
List.CopyTo(values);
上面介绍了两种从ArrayList转换到数组的方法
例3：
ArrayList List = new ArrayList();
List.Add( “string” );
List.Add( 1 );
//往数组中添加不同类型的元素
object[] values = List.ToArray(typeof(object)); //正确
string[] values = (string[])List.ToArray(typeof(string)); //错误
和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。
第2个回答 2008-03-28
java.util
类 ArrayList<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.ArrayList<E>
所有已实现的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
直接已知子类：
AttributeList, RoleList, RoleUnresolvedList
--------------------------------------------------------------------------------
public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, SerializableList 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）
size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：
List list = Collections.synchronizedList(new ArrayList(...)); 此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。
注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。
此类是 Java Collections Framework 的成员。
构造方法详细信息
ArrayList
public ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
参数：
initialCapacity - 列表的初始容量
抛出：
IllegalArgumentException - 如果指定的初始容量为负
--------------------------------------------------------------------------------
ArrayList
public ArrayList()构造一个初始容量为 10 的空列表。
--------------------------------------------------------------------------------
ArrayList
public ArrayList(Collection<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
参数：
c - 其元素将放置在此列表中的 collection
抛出：
NullPointerException - 如果指定的 collection 为 null
方法详细信息
trimToSize
public void trimToSize()将此 ArrayList 实例的容量调整为列表的当前大小。应用程序可以使用此操作来最小化 ArrayList 实例的存储量。
--------------------------------------------------------------------------------
ensureCapacity
public void ensureCapacity(int minCapacity)如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
参数：
minCapacity - 所需的最小容量
--------------------------------------------------------------------------------
size
public int size()返回此列表中的元素数。
指定者：
接口 Collection<E> 中的 size
指定者：
接口 List<E> 中的 size
指定者：
类 AbstractCollection<E> 中的 size
返回：
此列表中的元素数
--------------------------------------------------------------------------------
isEmpty
public boolean isEmpty()如果此列表中没有元素，则返回 true
指定者：
接口 Collection<E> 中的 isEmpty
指定者：
接口 List<E> 中的 isEmpty
覆盖：
类 AbstractCollection<E> 中的 isEmpty
返回：
如果此列表中没有元素，则返回 true
--------------------------------------------------------------------------------
contains
public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。
指定者：
接口 Collection<E> 中的 contains
指定者：
接口 List<E> 中的 contains
覆盖：
类 AbstractCollection<E> 中的 contains
参数：
o - 测试此列表中是否存在的元素
返回：
如果此列表包含特定的元素，则返回 true
--------------------------------------------------------------------------------
indexOf
public int indexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。
指定者：
接口 List<E> 中的 indexOf
覆盖：
类 AbstractList<E> 中的 indexOf
参数：
o - 要搜索的元素
返回：
此列表中第一次出现的指定元素的索引，如果列表不包含该元素，则返回 -1
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i，如果不存在此类索引，则返回 -1。
指定者：
接口 List<E> 中的 lastIndexOf
覆盖：
类 AbstractList<E> 中的 lastIndexOf
参数：
o - 要搜索的元素
返回：
列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1
--------------------------------------------------------------------------------
clone
public Object clone()返回此 ArrayList 实例的浅表副本。（不复制这些元素本身。）
覆盖：
类 Object 中的 clone
返回：
此 ArrayList 实例的一个副本
另请参见：
Cloneable
--------------------------------------------------------------------------------
toArray
public Object[] toArray()按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
由于此列表不维护对返回数组的任何引用，，因而它将是“安全的”。（换句话说，此方法必须分配一个新的数组）。因此，调用者可以自由地修改返回的数组。
此方法担当基于数组的 API 和基于 collection 的 API 之间的桥梁。
指定者：
接口 Collection<E> 中的 toArray
指定者：
接口 List<E> 中的 toArray
覆盖：
类 AbstractCollection<E> 中的 toArray
返回：
包含此列表中所有元素的数组（按适当顺序）
另请参见：
Arrays.asList(Object[])
--------------------------------------------------------------------------------
toArray
public <T> T[] toArray(T[] a)按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳列表，则将该列表返回此处。否则，将分配一个具有指定数组的运行时类型和此列表大小的新数组。
如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），那么会将数组中紧接 collection 尾部的元素设置为 null。（仅 在调用者知道列表中不包含任何 null 元素时才能用此方法确定列表长度）。
指定者：
接口 Collection<E> 中的 toArray
指定者：
接口 List<E> 中的 toArray
覆盖：
类 AbstractCollection<E> 中的 toArray
参数：
a - 要在其中存储列表元素的数组（如果它足够大）；否则，为此分配一个具有相同运行时类型的新数组。
返回：
包含列表元素的数组
抛出：
ArrayStoreException - 如果指定数组的运行时类型不是此列表每个元素的运行时类型的超类型
NullPointerException - 如果指定数组为 null
--------------------------------------------------------------------------------
get
public E get(int index)返回此列表中指定位置上的元素。
指定者：
接口 List<E> 中的 get
指定者：
类 AbstractList<E> 中的 get
参数：
index - 要返回元素的索引
返回：
此列表中指定位置上的元素
抛出：
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
--------------------------------------------------------------------------------
set
public E set(int index,
E element)用指定的元素替代此列表中指定位置上的元素。
指定者：
接口 List<E> 中的 set
覆盖：
类 AbstractList<E> 中的 set
参数：
index - 要替代的元素的索引
element - 存储在指定位置上的元素
返回：
以前位于该指定位置上的元素
抛出：
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
--------------------------------------------------------------------------------
add
public boolean add(E e)将指定的元素添加到此列表的尾部。
指定者：
接口 Collection<E> 中的 add
指定者：
接口 List<E> 中的 add
覆盖：
类 AbstractList<E> 中的 add
参数：
e - 要添加到此列表中的元素
返回：
true（按照 Collection.add(E) 的指定）
--------------------------------------------------------------------------------
add
public void add(int index,
E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。
指定者：
接口 List<E> 中的 add
覆盖：
类 AbstractList<E> 中的 add
参数：
index - 指定元素所插入位置的索引
element - 要插入的元素
抛出：
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
--------------------------------------------------------------------------------
remove
public E remove(int index)移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。
指定者：
接口 List<E> 中的 remove
覆盖：
类 AbstractList<E> 中的 remove
参数：
index - 要移除的元素的索引
返回：
从列表中移除的元素
抛出：
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
--------------------------------------------------------------------------------
remove
public boolean remove(Object o)移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。
指定者：
接口 Collection<E> 中的 remove
指定者：
接口 List<E> 中的 remove
覆盖：
类 AbstractCollection<E> 中的 remove
参数：
o - 要从此列表中移除的元素（如果存在）
返回：
如果此列表包含指定的元素，则返回 true
--------------------------------------------------------------------------------
clear
public void clear()移除此列表中的所有元素。此调用返回后，列表将为空。
指定者：
接口 Collection<E> 中的 clear
指定者：
接口 List<E> 中的 clear
覆盖：
类 AbstractList<E> 中的 clear
--------------------------------------------------------------------------------
addAll
public boolean addAll(Collection<? extends E> c)按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。
指定者：
接口 Collection<E> 中的 addAll
指定者：
接口 List<E> 中的 addAll
覆盖：
类 AbstractCollection<E> 中的 addAll
参数：
c - 包含要添加到此列表中的元素的 collection
返回：
如果此列表由于调用而发生更改，则返回 true
抛出：
NullPointerException - 如果指定的 collection 为 null
另请参见：
AbstractCollection.add(Object)
--------------------------------------------------------------------------------
addAll
public boolean addAll(int index,
Collection<? extends E> c)从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。向右移动当前位于该位置的元素（如果有）以及所有后续元素（增加其索引）。新元素将按照指定 collection 的迭代器所返回的元素顺序出现在列表中。
指定者：
接口 List<E> 中的 addAll
覆盖：
类 AbstractList<E> 中的 addAll
参数：
index - 插入指定 collection 中的首个元素的位置索引
c - 包含要添加到此列表中元素的 collection
返回：
如果此列表由于调用而发生更改，则返回 true
抛出：
IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
NullPointerException - 如果指定的 collection 为 null
--------------------------------------------------------------------------------
removeRange
protected void removeRange(int fromIndex,
int toIndex)移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。向左移动所有后续元素（减小其索引）。此调用将列表缩短了 (toIndex - fromIndex) 个元素。（如果 toIndex==fromIndex，则此操作无效。）
覆盖：
类 AbstractList<E> 中的 removeRange
参数：
fromIndex - 要移除的首个元素的索引
toIndex - 最后一个要移除的元素后面那个元素的索引
抛出：
IndexOutOfBoundsException - 如果 fromIndex 或 toIndex 超出范围 (fromIndex < 0 || fromIndex >= size() || toIndex > size() || toIndex < fromIndex)
---------------------------------------------------------------------
from java API