数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
这个我们可以看看他们的源码就可以知道：
ArrayList的size()方法：
1 /**
2 * Returns the number of elements in this list.
3 *
4 * @return the number of elements in this list
5 */
6 public int size() {
7 return size;
8 }
Vector的size()方法：
1 /**
2 * Returns the number of components in this vector.
3 *
4 * @return the number of components in this vector
5 */
6 public synchronized int size() {
7 return elementCount;
8 }
其实Vector的其他很多方法都是同步的：
1 /**
2 * Sets the size of this vector. If the new size is greater than the
3 * current size, new {@code null} items are added to the end of
4 * the vector. If the new size is less than the current size, all
5 * components at index {@code newSize} and greater are discarded.
6 *
7 * @param newSize the new size of this vector
8 * @throws ArrayIndexOutOfBoundsException if the new size is negative
9 */
10 public synchronized void setSize(int newSize) {
11 modCount++;
12 if (newSize > elementCount) {
13 ensureCapacityHelper(newSize);
14 } else {
15 for (int i = newSize ; i < elementCount ; i++) {
16 elementData[i] = null;
17 }
18 }
19 elementCount = newSize;
20 }
21
22 /**
23 * Returns the current capacity of this vector.
24 *
25 * @return the current capacity (the length of its internal
26 * data array, kept in the field {@code elementData}
27 * of this vector)
28 */
29 public synchronized int capacity() {
30 return elementData.length;
31 }
32
33 /**
34 * Returns the number of components in this vector.
35 *
36 * @return the number of components in this vector
37 */
38 public synchronized int size() {
39 return elementCount;
40 }
41
42 /**
43 * Tests if this vector has no components.
44 *
45 * @return {@code true} if and only if this vector has
46 * no components, that is, its size is zero;
47 * {@code false} otherwise.
48 */
49 public synchronized boolean isEmpty() {
50 return elementCount == 0;
51 }
那现在我们应该设计一个方案来研究我们的这些结论的正确性！！
下面给出ArrayList线程不安全证明方案：
1 /**
2 *
3 */
4 package com.b510;
5
6 import java.util.ArrayList;
7 import java.util.Collections;
8 import java.util.List;
9
10 /**
11 * @date 2013-5-2
12 * @author xhw
13 *
14 */
15 public class HongtenArrayList implements Runnable {
16 //线程不安全
17 List<String> list = new ArrayList<String>(1);
18 //线程安全
19 //List<String> list = Collections.synchronizedList(new ArrayList<String>());
20 public void run() {
21 try {
22 Thread.sleep((int) (Math.random() * 2));
23 } catch (InterruptedException e) {
24 e.printStackTrace();
25 }
26 System.out.println(Thread.currentThread().getName());
27 list.add(Thread.currentThread().getName());
28 }
29
30 public static void main(String[] args) throws InterruptedException {
31 ThreadGroup group = new ThreadGroup("hongtenGroup");
32 HongtenArrayList t = new HongtenArrayList();
33 for (int i = 0; i < 10000; i++) {
34 Thread th = new Thread(group, t, String.valueOf(i));
35 th.start();
36 }
37 while (group.activeCount() > 0) {
38 Thread.sleep(10);
39 }
40 System.out.println("result=============");
41 //如果线程安全，那么结果是10000，如果线程不安全，则结果不可预测
42 System.out.println(t.list.size());
43 }
44
45 }
下面贴出部分运行结果：
线程不安全：
当然线程安全下面会出现：(运行结果都是10000)
9982
9988
9990
9979
9981
9977
9965
9971
9848
9846
9989
9993
9991
9678
9995
9992
9998
9994
9996
9997
9999
result=============
10000
对于增长，我们可以看看ArrayList的源码：
ArrayList:grow()
1 /**
2 * Increases the capacity to ensure that it can hold at least the
3 * number of elements specified by the minimum capacity argument.
4 *
5 * @param minCapacity the desired minimum capacity
6 */
7 private void grow(int minCapacity) {
8 // overflow-conscious code
9 int oldCapacity = elementData.length;
10 int newCapacity = oldCapacity + (oldCapacity >> 1);
11 if (newCapacity - minCapacity < 0)
12 newCapacity = minCapacity;
13 if (newCapacity - MAX_ARRAY_SIZE > 0)
14 newCapacity = hugeCapacity(minCapacity);
15 // minCapacity is usually close to size, so this is a win:
16 elementData = Arrays.copyOf(elementData, newCapacity);
17 }
Vector:grow()
1 private void grow(int minCapacity) {
2 // overflow-conscious code
3 int oldCapacity = elementData.length;
4 int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
5 capacityIncrement : oldCapacity);
6 if (newCapacity - minCapacity < 0)
7 newCapacity = minCapacity;
8 if (newCapacity - MAX_ARRAY_SIZE > 0)
9 newCapacity = hugeCapacity(minCapacity);
10 elementData = Arrays.copyOf(elementData, newCapacity);
11 }
