注意：本文基于JDK1.8进行记录。
1 Vector 1.1 简介不常用的集合，和ArrayList类似，允许任何符合规则的元素插入，包括null和重复元素。
底层是数组结构，提供了索引机制，查找效率高，增删效率低。
线程安全，使用了synchronized关键字。
1.2 扩容机制扩容机制和ArrayList类似，初始容量默认为10，负载因子是1，表示当插入元素后个数超出原有长度时会进行扩增，扩容增量是默认为原容量，所以扩增后容量为2倍，可使用方法手动扩容和缩减。
最好指定初始容量值和增量，避免过多的进行扩容操作而浪费时间和效率。
1.3 方法说明 1.3.1 构造方法// 空参构造器，返回默认容量为10的集合。 public Vector(); // 指定长度的构造器，默认增量为0。 public Vector(int initialCapacity); // 指定长度和增量的构造器，默认增量为0。 public Vector(int initialCapacity, int capacityIncrement); // 传入了一个集合的构造器，如果集合长度为0，返回容量为0的集合。 public Vector(Collection c);1.3.2 常用方法
// 获取指定下标的元素。 public synchronized E get(int index); // 设置指定下标的指定元素，并返回旧元素。 public synchronized E set(int index, E element); // 添加元素，并返回是否成功。 public synchronized boolean add(E e); // 在指定位置添加指定元素。 public void add(int index, E element); // 删除指定位置的元素，并返回删除的元素。 public synchronized E remove(int index); // 删除元素，并返回是否成功。 public boolean remove(Object o);1.4 源码分析 1.4.1 属性
// 数组。 protected Object[] elementData; // 元素个数。 protected int elementCount; // 扩容增量 protected int capacityIncrement;1.4.2 构造方法
// 空参构造器，返回默认容量为10的集合。
public Vector() {
this(10);
}
// 指定长度的构造器，默认增量为0。
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
// 指定长度和增量的构造器，默认增量为0。
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
// 传入了一个集合的构造器，如果集合长度为0，返回容量为0的集合。
public Vector(Collection c) {
elementData = c.toArray();
elementCount = elementData.length;
// Object[]数组里的类型不一定都是Object类型的，有可能是Object的子类，所以要判断一下。
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
1.4.3 常用方法
// 获取指定下标的元素。
public synchronized E get(int index) {
// 检查指定下标是否越界。
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
// 返回指定下标的元素。
return elementData(index);
}
// 设置指定下标的指定元素，并返回旧元素。
public synchronized E set(int index, E element) {
// 检查指定下标是否越界。
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
// 设置指定元素并返回旧元素。
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
// 添加元素，并返回是否成功。
public synchronized boolean add(E e) {
// 操作数自增。
modCount++;
// 扩容。
ensureCapacityHelper(elementCount + 1);
// 元素个数增加并设置指定元素。
elementData[elementCount++] = e;
// 返回成功。
return true;
}
// 在指定位置添加指定元素。
public void add(int index, E element) {
insertElementAt(element, index);
}
// 删除指定位置的元素，并返回删除的元素。
public synchronized E remove(int index) {
// 操作数自增。
modCount++;
// 检查指定下标是否越界。
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
// 获取指定下标的元素。
E oldValue = elementData(index);
// 需要移动的元素个数。
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// 将最后一个元素设置为null并减少容量大小。
elementData[--elementCount] = null;
// 返回指定下标的元素。
return oldValue;
}
// 删除元素，并返回是否成功。
public boolean remove(Object o) {
return removeElement(o);
}
1.4.4 扩容方法
// 对集合进行扩容。
public synchronized void ensureCapacity(int minCapacity) {
// 如果指定容量大于扩充值，则进行扩容。
if (minCapacity > 0) {
// 操作数自增。
modCount++;
ensureCapacityHelper(minCapacity);
}
}
// 对集合进行扩容。
private void ensureCapacityHelper(int minCapacity) {
// 如果最小值大于数组长度，则进行扩容。
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 扩容计算。
private void grow(int minCapacity) {
// 获取原容量大小。
int oldCapacity = elementData.length;
// 如果增量大于0，则使用增量，否则使用原容量作为增量，最后加上原容量作为新容量。
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
// 如果扩容后小于最小值，则设置容量为最小值。
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果扩容后大于最大值，则进一步设置容量。
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 复制数组。
elementData = Arrays.copyOf(elementData, newCapacity);
}
// 扩容后容量过大的处理方法。
private static int hugeCapacity(int minCapacity) {
// 如果最小值小于零，则表示溢出，抛出内存溢出异常。
if (minCapacity < 0)
throw new OutOfMemoryError();
// 如果扩容后的值大于最大值，则使用Integer的最大值，否则就使用最大值。
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
2 Stack
2.1 简介
不常用的集合，继承自Vector，允许任何符合规则的元素插入，包括null和重复元素。
同Vector类似，底层是数组结构，但通过对Vector的扩展，将数组结构倒置形成堆栈结构，使用典型的后进先出操作方式。
线程安全，使用了synchronized关键字。
2.2 扩容机制同Vector。
2.3 方法说明 2.3.1 构造方法public Stack();2.3.2 常用方法
// 判断是否为空。 public boolean empty(); // 入栈，添加到栈顶。 public E push(E item); // 出栈，查看并删除栈顶元素。 public synchronized E pop(); // 查看栈顶元素。 public synchronized E peek(); // 查找元素，返回栈中首次出现下标。 public synchronized int search(Object o);2.4 源码分析 2.4.1 构造方法
public Stack() {
}
2.4.2 常用方法
// 判断是否为空。
public boolean empty() {
// 通过Vector的size()方法判断。
return size() == 0;
}
// 入栈，添加到栈顶。
public E push(E item) {
// 实际添加到数组尾部。
addElement(item);
return item;
}
// 出栈，查看并删除栈顶元素。
public synchronized E pop() {
E obj;
int len = size();
// 实际查看数组尾部元素。
obj = peek();
// 实际删除数组尾部元素。
removeElementAt(len - 1);
return obj;
}
// 查看栈顶元素。
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
// 实际查看数组尾部元素。
return elementAt(len - 1);
}
// 查找元素，返回栈中首次出现下标。
public synchronized int search(Object o) {
// 实际查看元素在数组最后出现位置。
int i = lastIndexOf(o);
if (i >= 0) {
// 转换为栈中位置。
return size() - i;
}
return -1;
}
