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