文章目录
 
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<>();

在java中vector容器相当于c++的动态数组，
Vector 可实现自动增长的对象数组。 
java.util.vector提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。比如在c,c++中所谓的“动态数组”一般都由指针来实现。为了弥补这个缺点，Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。 

    创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。 
java vector遍历的五种办法：

import java.util.Enumeration;  
import java.util.Iterator;  
import java.util.Vector;  
import java.util.function.Consumer;  
public class VetcorString {  
  
    public static void main(String[] args) {  
        Vector<String>  t=new Vector<String>();  
        t.add("H");  
        t.add("E");  
        t.add("L");  
        t.add("L");  
        t.add("O");    
        //第一种  
        for (String string : t) {  
            System.err.print(string);  
        }  
        //第二种  
        t.forEach(new Consumer<String>() {  
            @Override  
            public void accept(String t) {  
                // TODO Auto-generated method stub  
                System.out.print(t);      
            }  
        });  
        //第三种  
        for (int i = 0; i < t.size(); i++) {  
            System.out.print(t.get(i));   
        }  
        //第四种  
        Iterator<String> it = t.iterator();  
        while (it.hasNext()) {  
            String string = (String) it.next();  
            System.err.print(string);  
        }  
        //第五种  
        Enumeration<String> enume = t.elements();  
        while(enume.hasMoreElements()){  
            System.out.print(enume.nextElement().toString());  
        }  
    }  
}
在java中访问容器时，需要和迭代器iterator配合使用。在上述方法中也有体现，接下来再举一个例子：
package suanFa01;

import java.util.*;

public class Day01 {
	public  static void main(String []args) {
		 Vector<Integer>  ivec = new Vector<Integer>();
		 System.out.println("请输入一个整数");
		 Scanner sc = new Scanner(System.in);
		 int n = sc.nextInt();
		 int k = 2;
		// Integer integer1 = new Integer(k);
		 System.out.println(n+"的质因数分解为:");
		 while(n>=2) {
			 if(n%k == 0) {
				 ivec.addElement(k);
				 n = n/k;
			 }
			 else {
				 ++k;
			 }
		 }
		Iterator<Integer> it = ivec.iterator();//通过迭代器来循环打印出容器中的元素
		while(it.hasNext()) {
			Integer nnn = it.next();
			System.out.print(nnn+"*");
		}
	 
	}

}



声明：原创文章，转载请注明出处。

Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：
 
Vector 是同步访问的。
Vector 包含了许多传统的方法，这些方法不属于集合框架。
Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。
 

一句话：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线程安全。