java集合浅谈——List
一、类库结构图概览
Java中集合类库的结构图，如下所示：
图1
图2
二、Collection接口说明
（1）Collection是最基本的集合接口，由Collection接口派生的两个接口是List和Set。
（2）所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数和有一个Collection类型参数的构造函数。前者用于创建一个空的Collection，后者用于创建一个新的Collection，允许用户复制一个Collection。
（3）不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，可逐一访问Collection中每一个元素。用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子 while(it.hasNext()) { Object obj = it.next(); // 得到下一个元素 }
Note：
容器对象仅能持有对象引用(对象的指针)，而不是Copy对象信息
三、List源码解读
List以某种插入顺序来维护元素顺序，另外元素可以重复。
ArrayList
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList是用数组（Object类型的数组，被标注为transient）来实现的，读取速度快，插入与删除速度慢（因为插入与删除时要移动后面的元素），适合于随机访问。
ArrayList是动态增长的，并确保始终存在添加元素的空间。
初始化ArrayList时可以指定容量，源代码如下：
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @throws IllegalArgumentException if the specified initial capacity * is negative */ public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }
通过add(E e)方法添加元素时，可能需要调整内部数组的大小，代码如下：
/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return {@code true} (as specified by {@link Collection#add}) */ public boolean add(E e) { modCount++; add(e, elementData, size); return true; }
/** * This helper method split out from add(E) to keep method * bytecode size under 35 (the -XX:MaxInlineSize default value), * which helps when add(E) is called in a C1-compiled loop. */ private void add(E e, Object[] elementData, int s) { if (s == elementData.length) elementData = grow(); elementData[s] = e; size = s + 1; }
问题：How does the remove method work in ArrayList? [ArrayList shrinks automatically ]
可以使用remove(int i) 或remove(Object o)从ArrayList中删除一个元素。
当移除任何元素时，内部所有后续元素都要左移，以填补被移除元素的空白，数组的大小将减 1。
/** * Removes the element at the specified position in this list. * Shifts any subsequent elements to the left (subtracts one from their * indices). * * @param index the index of the element to be removed * @return the element that was removed from the list * @throws IndexOutOfBoundsException {@inheritDoc} */ public E remove(int index) { Objects.checkIndex(index, size); final Object[] es = elementData; @SuppressWarnings("unchecked") E oldValue = (E) es[index]; fastRemove(es, index); return oldValue; }
/** * Private remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(Object[] es, int i) { modCount++; final int newSize; if ((newSize = size - 1) > i) System.arraycopy(es, i + 1, es, i, newSize - i); es[size = newSize] = null; }
扩展阅读：
LinkedList
是用双向链表来实现的，删除与插入速度快，读取速度较慢，因为它读取时是从头向尾或从尾向头查找元素，适合于元素的插入与删除操作。
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable
问题：How add() method works in a LinkedList
/** * Appends the specified element to the end of this list. * * <p>This method is equivalent to {@link #addLast}. * * @param e element to be appended to this list * @return {@code true} (as specified by {@link Collection#add}) */ public boolean add(E e) { linkLast(e); return true; }
/** * Links e as last element. */ void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; }
内部数据结构是双向链表，示意图如下：
对应源代码如下：
private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }
问题：How remove() method works in Java LinkedList class
当调用remove()方法时，必须更改删除节点左侧和右侧节点的引用，源代码如下：
/** * Removes the element at the specified position in this list. Shifts any * subsequent elements to the left (subtracts one from their indices). * Returns the element that was removed from the list. * * @param index the index of the element to be removed * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */ public E remove(int index) { checkElementIndex(index); return unlink(node(index)); }
/** * Unlinks non-null node x. */ E unlink(Node<E> x) { // assert x != null; final E element = x.item; final Node<E> next = x.next; final Node<E> prev = x.prev; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } x.item = null; size--; modCount++; return element; }
Vector
功能与ArrayList几乎相同，也是用数组来实现的，其添加、删除等都是基于线程同步的，源代码如下：
/** * Appends the specified element to the end of this Vector. * * @param e element to be appended to this Vector * @return {@code true} (as specified by {@link Collection#add}) * @since 1.2 */ public synchronized boolean add(E e) { modCount++; add(e, elementData, elementCount); return true; }
初始化Vector时可以设定容量，源代码如下：
/** * Constructs an empty vector with the specified initial capacity and * with its capacity increment equal to zero. * * @param initialCapacity the initial capacity of the vector * @throws IllegalArgumentException if the specified initial capacity * is negative */ public Vector(int initialCapacity) { this(initialCapacity, 0); }
如果以new Vector()方式创建Vector，则其初始容量为10；
如果以new Vector(int initialCapacity, int capacityIncrement)方式创建Vector，则其初始容量为initialCapacity。
Stack
Stack继承自Vector，实现一个后进先出的堆栈，线程同步。
除了基本的入栈和出栈操作，该类还提供了另外几个函数，如：peek、search，对应源代码如下：
/** * Looks at the object at the top of this stack without removing it * from the stack. * * @return the object at the top of this stack (the last item * of the {@code Vector} object). * @throws EmptyStackException if this stack is empty. */ public synchronized E peek() { int len = size(); if (len == 0) throw new EmptyStackException(); return elementAt(len - 1); }
Note：
Stack是继承自Java中的Vector的遗留类，当我们不需要线程安全时会有额外的开销。
建议使用ArrayDeque来实现堆栈，因为它在单线程环境中效率更高。
