java.util.ArrayList 线性表类

java.util.ArrayList;

    ArrayList 实现了容量大小可变的 List 接口，实现了所有裂变的可选操作，并允许包括 null 在内的所有元素，此类还提供了一些方法来操作内部用来储存列表的数组的大小。（此类大致上相当于 Vector 类，除了它不是同步的。）

    size, isEmpty, get, set, iterator 和 listIterator 操作的运行时间都是固定的，add 操作与添加元素的数量有关，即添加 n 个元素需要 O(n) 时间。粗略地说，所有其它的操作都以线性时间运行。此类的实现的常数因子比用于 LinkedList 实现的常数因子较低。

    每个 ArrayList 的实现都有一个容量，该容量是指储存列表中的元素的数组的大小，容量总是大于等于列表的大小，随着向 ArrayList 中不断地添加元素，容量也会随之自动增加。但是在大量添加元素之前，建议使用 ensureCapacity 操作来主动增加数组的容量，以减少数组自动增加的次数来提高添加元素的效率。

    注意，此实现是不同步的。如果多个线程同时访问 ArrayList 实例，并且至少有一个在结构上修改了列表，则必须保证在外部进行同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者是明确调整底层数组的大小，仅修改元素的值不是结构修改。）一般通过自然封装该列表的对象进行同步操作完成，如果不存在这样的对象，则应该用 Collections.synchronizedList 方法将该列表“包装”起来。这最好是在创建时完成，以防止意外对列表进行不同步的访问：

        List list = Collections.synchronizedList(new ArrayList(...));

    此类的 iterator 和 listIterator 方法返回的迭代器都是快速失败的，在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException 异常。因此，面对并发的修改，迭代器很快就会完全失败，而不是在将来某个不确定时间发生任意不确定行为的风险。

    注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException 异常。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法，迭代器的快速失败行为应该仅用于检测 bug。

    此类是 Java Collections Framework 的成员。

构造方法：

1.public ArrayList(int initialCapacity)

    构造一个具有指定初始容量的空列表。

参数：

intitialCapacity - 列表的初始容量。

抛出异常：

IllegalArgumentException - 当指定的初始容量为负数的时候。

2.public ArrayList()

    构造一个初始容量为 10 的空链表。

3.public ArrayList(Collection<? extends E> c)

    构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

参数：

c - 其元素将被放入新列表中的集合。

抛出异常：

NullPointerException - 当一个指定的集合为空的时候。

常用的方法：

boolean add(E e) - 将指定的元素添加到列表的尾部。

void add(int index, E element) - 在链表中指定的位置添加指定的元素。

boolean addAll(Collection<? extends E> c) - 按照该 collection 的迭代器返回的顺序将该 collection 中所有的元素添加到列表的尾部。

boolean addAll(int index, Collection<? extends E> c) -按照该 collection 的迭代器返回的顺序将该 collection 中所有的元素添加到列表的指定位置。

void clear() - 从列表中删除所有元素。

boolean contains(Object o) - 如果此链表包含指定的元素，则返回 true，反之则返回 false。

void ensureCapacity(int minCapacity) - 如果需要，则增加此 ArrayList 实例的容量，确保至少可以容纳 minCapacity 指定的大小。

E get(int index) - 返回指定位置的元素。如果指定位置超出当前列表范围，则会抛出 java.lang.IndexOutOfBoundsException 异常。

int indesOf(Object o) - 返回该线性表中指定元素首次出现的位置，如果不包含此元素则返回 -1.

boolean isEmpty() - 如果线性表中不包含任何元素则返回 true，否则返回 false。

ListIterator<E> ListLterator() - 返回列表中的列表迭代器（按适当的顺序）。

ListIterator<E> ListIterator(int index) - 从列表指定的位置开始，返回该列表中的列表迭代器（按适当的顺序）。

E remove(int index) - 移除列表中指定位置的元素，并返回该元素。如果指定位置超出当前列表范围，则会抛出 java.lang.IndexOutOfBoundsException 异常。

boolean remove(Object o) - 如果存在，移除指定元素在列表中第一次出现的位置（返回 true），如果不存在则返回 false。

boolean removeAll(Collection<?> c) - 从此列表中移除指定集合中包含的所有元素，重复出现的元素全部移除。

boolean removeIf(Predicate<? super E> filter) - 从此列表中删除满足指定谓词的所有元素。

protected void removeRange(int fromIndex, int toIndex) - 从此列表中删除指定位置区间的所有元素，包括 fromIndex 而不包括 toIndex。

void replaceAll(UnaryOperator<E> operator) - 将该列表中的所有元素替换为指定运算符应用于该元素的结果。

boolean retainAll(Collection<?> c) - 仅保留该列表中包含在指定集合中的元素。

E set(int index, E element) - 用指定的元素替换此列表中指定位置的元素，并返回被替换的元素。如果指定位置超出当前列表范围，则会抛出 java.lang.IndexOutOfBoundsException 异常。

int size() - 返回该列表中元素的个数。

void sort(Comparator<? super E> c) - 根据指定的比较器对列表进行排序。

List<E> subList(int fromIndex, int toIndex) - 返回列表中指定位置区间的视图，包括 fromIndex 而不包括 toIndex。

Object[] toArray() - 以正确的顺序（从第一个到最后一个）返回一个包含列表中所有元素的数组。

void trimToSize() - 将此 Arraylist 实例的容量修改为列表的当前大小。

代码示例：

import java.util.ArrayList;
import java.util.ListIterator;

public class ArrayListDemo
{
	public static void main(String args[])
	{
		ArrayList<String> a = new ArrayList<String>();	//构造方法2:ArrayList()
		a.add("alpha");								//boolean add(E e)
		a.add("gamma");
		a.add(1, "beta");							//void add(int index, E element)
		ArrayList<String> b = new ArrayList<String>(4);	//构造方法1:ArrayList(int initialCapacity)
		b.add("delta");
		b.add("epsilon");
		b.add("zeta");
		b.add("eta");
		a.addAll(b);								//boolean addAll(int index, Collection<? extends E> c)
		System.out.println(a.toString());
		ArrayList<String> backup = new ArrayList<String>(a);
		b = null;
		b = new ArrayList<String>(a);						//构造方法3:ArrayList(Collection<? extends E> c)
		System.out.println(b.toString());
		b.clear();								//void clear()
		System.out.println("a.contains(\"alpha\"):" + a.contains("alpha"));	//boolean contains(Object o)
		System.out.println("a.contains(\"theta\"):" + a.contains("theta"));	//boolean contains(Object o)
		System.out.println("a.get(3):" + a.get(3));				//E get(int index)
		try
		{
			System.out.println(a.get(10));					//E get(int index)
		}
		catch(IndexOutOfBoundsException e)
		{
			System.out.println("a.get(10):index out of bounds.");
		}
		System.out.println("a.indexOf(\"delta\"):" + a.indexOf("delta"));	//int indesOf(Object o)
		System.out.println("a.indexOf(\"theta\"):" + a.indexOf("theta"));	//int indesOf(Object o)
		System.out.println("a.isEmpty():" + a.isEmpty());
		System.out.print("a.listIterator():");
		ListIterator<String> iter = a.listIterator();				//ListIterator<E> ListLterator()
		while(iter.hasNext())
			System.out.print(iter.next() + ",");
		System.out.print("\na.listIterator(3):");
		iter = a.listIterator(3);						//ListIterator<E> ListLterator(int index)
		while(iter.hasNext())
			System.out.print(iter.next() + ",");
		System.out.println();
		System.out.println("a.remove(4):" + a.remove(4));			//E remove(int index)
		a.add(3, "beta");
		System.out.println("current a:" + a.toString());
		a.remove("beta");							//boolean remove(Object o)
		System.out.println("after a.remove(\"beta\"):" + a.toString());
		b.add("beta");
		b.add("delta");
		System.out.println("current b:" + b.toString());
		a.removeAll(b);								//removeAll(Collection<?> c)
		System.out.println("a.removeAll(b):" + a.toString());
		a.retainAll(b);
		System.out.println("a.retainAll(b):" + a.toString());			//retainAll(Collection<?> c)
		a = backup;
		System.out.println("current a:" + a.toString());
		a.set(2, "alphabet");							//E set(int index, E element)
		System.out.println("a.set(2, \"alphabet\"):" + a.toString());
		System.out.println("a.size():" + a.size());				//int size()
	}
}

结果：

注：

上述介绍的 ArrayList 方法中个别方法由于需要其他类的应用，所以在此并没有做为示例，比如 boolean removeIf(Predicate<? super E> filter) 方法需要过滤器类、void replaceAll(UnaryOperator<E> operator) 方法需要运算符类等，在我的博客中后续将会有介绍。