文章目录
3. Vector
3.1 同步
3.2 与 ArrayList 的比较
3.3 替代方案

Java 容器
3. Vector
3.1 同步
它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

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);
    elementData[--elementCount] = null; // Let gc do its work

    return oldValue;
}

3.2 与 ArrayList 的比较
Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；

Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
3.3 替代方案
可以使用 Collections.synchronizedList() 得到一个线程安全的 ArrayList。
List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);

也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
List<String> list = new CopyOnWriteArrayList<>();

一句话：Vector线程安全，ArrayList线程不安全，以下是实验代码：

package com.yarm.test;

import java.util.ArrayList;
import java.util.Vector;

public class ArrayListAndVectorThread {
	//实例化两个静态容器
	static Vector<Integer> vector = new Vector<Integer>();
	static ArrayList<Integer> arrayList = new ArrayList<Integer>();

	public static class ArrayListThread implements Runnable{
		
		
		public void run(){
				
			for (int i = 0; i < 10000000; i++) {
				//线程不安全
				vector.add(i);
				//线程安全
				arrayList.add(i);
			}
		}
	}
	
	// main函数
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(new ArrayListThread());
		Thread t2 = new Thread(new ArrayListThread());
		t1.start();
		t2.start();
		t1.join(); t2.join();
		System.out.println("arrayList长度：" + arrayList.size());
		System.out.println("vector长度：" + vector.size());
	}
}


控制台输出结果：

arrayList长度：19991800

vector长度：20000000

最后结论：

依照实验结果说明，ArrayList输出的长度不是20000000，而Vector的长度正好等于20000000，说明ArrayList线程不安全，Vector线程安全。

 

java.util.Vector
Vector与ArrayList的异同
相同点：随机存取，可通过位置序号直接获取数据。都是通过一个数组来存放元素。
不同点：Vector是线程安全的，方法有synchronized关键字修饰。
Vector容量增长策略
Vector默认的增长策略是每次在原容量的基础上x2。
Vector的ListIterator怎么做到线程安全的
Vector实现了自己的iterator，为了保证并发线程安全的共享一个Vector，开发者在next等方法中也加入了synchronized。
public E next() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor;
if (i >= elementCount)
throw new NoSuchElementException();
cursor = i + 1;
return elementData(lastRet = i);
}
}
这里synchronized修饰的是Vector.this对象本身，而不是iterator自己，这样多个线程使用iterator操作Vector时，就可以保证线程的安全。
Vector与ArrayList实现的Spliterator类似
唯一的区别就是在使用自己的Vector时，加上了synchronized关键字。
Stack与Vector
Stack类继承自Vector，stack的实现不止一种方式，比如LinkedList。java中在Vector基础上实现了一个Stack。实现的想法也很简单，就是在数组的末尾push和pop。

1.同步

它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。

2.扩容

Vector 的构造函数可以传入 capacityIncrement 参数，它的作用是在扩容时使容量 capacity 增长 capacityIncrement。如果这个参数的值小于等于 0，扩容时每次都令 capacity 为原来的两倍。

3. 与 ArrayList 的比较

Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
	
Vector 每次扩容请求其大小的 2 倍（也可以通过构造函数设置增长的容量），而 ArrayList 是 1.5 倍。
4. 替代方案

可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList。

List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);

也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。

List<String> list = new CopyOnWriteArrayList<>();