Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。 比如，indexOf方法就增加了synchronized同步标记。
1、Vector的用法
import java.util.Iterator;
import java.util.Vector;

public class TestVector {
	
	public static void main(String[] args) {
		Vector vector = new Vector();
            System.out.println("集合的容量：" + vector.capacity());
           System.out.println("元素的个数:"+vector.size());
		//添加元素
		vector.add("hello");
		vector.add(1, "world");
		vector.addElement("java");
		System.out.println(vector);		
		//删除元素
//		vector.remove(0);
//		vector.remove("java");
//		vector.removeElement("world");
//		vector.clear();
		
		//获取元素
		System.out.println(vector.get(0));
		//遍历集合
           //建议---节约内存，Iterator对象存在周期短
		System.out.println("------使用Iterator（for）遍历------");
		for(Iterator iterator = vector.iterator();iterator.hasNext();){
			System.out.println(iterator.next());
		}
		System.out.println("------使用Iterator（while）遍历------");
		Iterator ite = vector.iterator();
		while(ite.hasNext()) {
			System.out.println(ite.next());
		}
	}
}
2、JDK源码分析
（1）构造方法
public Vector() {
    this(10);
}
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "
                + initialCapacity);
   this.elementData = new Object[initialCapacity];//new Object[10];
   this.capacityIncrement = capacityIncrement;//0
}
（2）容量扩充
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity 
        + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);//20
    if (newCapacity - minCapacity < 0)//健壮性
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)//健壮性
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}
3、Vector与ArrayList的区别：
(1) Vector 的 add()方法是同步方法,ArrayList 的 add() 方法是非同步方法
(2) Vector 扩容每次扩充 1 倍 ,ArrayList 每次扩充 0. 5 倍 
(3) Vector是在调用构造方法时，直接初始化容量为10，ArrayList 是在第一次调用添加方法时，初始化容量为 10 
(4) Vector 的版本是 JDK1.0,ArrayList，JDK1.2 版 
(5) Vector 是线程同步的，安全性高，效率低， ArrayList 是线程非同步的，安全性低，效率高 
4、如何选用ArrayList、LinkedList、Vector
1. 需要线程安全时，用Vector。
2. 不存在线程安全问题时，并且查找较多用ArrayList(一般使用它)。
3. 不存在线程安全问题时，增加或删除元素较多用LinkedList。
尚学堂百战程序员
百战程序员_IT6000集_影响6000万学习IT的中国人【官网】

ArrayList,LinkedList和Vector都继承自List接口。ArrayList和Vector的底层是动态数组，LinkedList的底层是双向链表.
ArrayList和Vector的区别就是ArrayList是线程不安全的，Vector是线程安全的，Vector中的方法都是同步方法(synchronized),所以ArrayList的执行效率要高于Vector,它也是用的最广泛的一种集合。
我们重点比较一下ArrayList和LinkedList的区别，其实ArrayList和LinkedList之间的区别就是数组和双向链表之间的区别。
数组的特点：因为数组分配的是一块连续的内存空间，使用索引来查找元素是非常快速的。但是插入，删除数据性能比较低。
要把邓丽君删掉需要先把从王志文开始的元素挨个往前移，将邓丽君覆盖掉。
再来看一下双向链表的结构：
在该链表中每一个元素除了存储本身的内容之外还存储指向前一个元素的指针和指向后一个元素的指针，下图展示了一个包含三个元素的双向链表，每个链表都有一个头部，头部指向第一个元素，尾部元素也指向头部。
双向链表的特点，查询效率较低，因为查询一个元素需要从头部开始查询，挨个遍历每一个元素直到找到所需元素，插入，删除效率高比如我们删掉一个元素直接把它前一个元素的指针指向它后一个元素就可以了：
我们通过源码来比价一下这两种数据结构集合的特点
1. 添加元素到集合尾部：List接口提供了一个方法可以将元素添加到集合的尾部boolean add(E e),ArrayList和LinkedList都实现了这个方法：
先看ArrayList是如何实现的：
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  //判断当前数组的容量是否够大如果不够大则扩容 elementData[size++] = e;//将元素添加到数组尾部return true;
}
这里的执行效率取决于：ensureCapacityInternal(size+ 1)方法的执行,在该方法中会判断数组容量是否足够，如果不够则进行扩容到原来的1.5倍。在扩容的过程中会生成一个新的数组，将原数组中的元素复制到新数组中。所以在这种情况下如果数组容量足够大ArrayList的效率是非常高的，我们也可以根据实际情况给它一个合适的初始值。
再来看一下LinkedList集合:
public boolean add(E e) {
    linkLast(e);
    return true;
}
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
l.next = newNode;
    size++;
    modCount++;
}
我们可以看到每新增一个元素就要创建一个Node对象，进行频繁的赋值操作 “final Node<E> newNode = new Node<>(l, e, null);”对效率有一定的影响。

我们再来看一下在特定的位置插入元素：
List接口中提供的方式是这样的：void add(int index,E element)
在ArrayList中是这样实现的：
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
从代码中我们可以看出，每插入一个元素就要进行大量元素复制操作：“System.arraycopy(elementData, index, elementData, index + 1，size - index);”
从插入点往后的元素依次后移将新元素插入到空出来的位置上。效率非常低下。
而在LinkedList中开销和在集合最后插入元素开销差不多，只需要把它前一个元素的指针指向自己，自己的指针指向下一个元素就可以了。
总结一下：
1. ArrayList和Vector结构一样都是动态数组，区别是ArrayList是线程不安全的，Vector是线程安全的，ArrayList性能好于Vector,ArrayList是应用最多的集合。
2. ArrayList和LinkedList的区别是他们的数据结构不同，ArrayList是动态数组，LinkedList是双向链表，在查询操作较多，在特定位置插入数据和删除数据较少的情况下一般选用ArrayList，在特定位置插入数据，删除数据操作较多，查询较少的情况下一般选用LinkedList，但是在大多数应用中都是对查询效率要求较高，所以ArrayList集合应用更广泛一些。
如果该文章对你有帮助别忘了 点赞，收藏加关注，你的支持就是我持续更新的动力！

1.ArrayList的总结

      

    //1.底层数组实现，使用默认的构造方法，初始化出来的容量是10（JDK 8 无参构造容量为0）
    //2.扩容的长度是元长度的基础上加二分之一
    //3.实现了RandomAccess接口，底层有事数组，get读取元素的性能很好
    //4.线程不安全，所有的方法均不是同步方法，也没有加锁，因此，多线程下慎用
    //5.顺序添加很方便    
    //6.删除和插入需要赋值数组性能很差（可以使用LinkindList）

ArrayList和Vector的区别

标准答案

    //1.ArrayList是线程不安全的，Vector是线程安全的
    //2.扩容时候ArrayList扩0.5倍，Vector扩1倍
    

那么问题来了

ArrayList有没有办法使线程安全？

Collection工具类有一个synchronizedList方法

可以把list变为线程安全的集合，但是意义不大，因为可以使用Vector

Vector为什么是线程安全的？

老实讲，抛开线程，它们两个的区别不大，但是多线程就不一样了，nameVectyor是如何实现线程安全的，我们来看几个关键的方法

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;
}

就代码的实现上来说，和ArrayList并没有很多逻辑上的区别，但是Vector的关键方法都是用了synchronized修饰

 

List接口 有序,不唯一(java.util)
API用法与ArrayList相同
API用法点击此处直达
底层数据结构与ArrayList相同都是 Object 类型的数组
Vector 与 ArrayList 的区别 :
(1) 
Vector 的 add()方法是同步方法
ArrayList 的 add() 方法是非同步方法 
(2)
Vector 扩容每次扩充 1 倍 ,
ArrayList 每次扩充 0.5 倍
(3) 
Vector 是在调用构造方法时，直接初始化容量为 10，
ArrayList 是在第一次调用添加方法时，初始化 容量为 10 
(4) 
Vector 的版本是 JDK1.0,
ArrayList，JDK1.2 版 
(5) 
Vector 是线程同步的，安全性高，效率低，
ArrayList 是线程非同步的，安全性低，效率高
 public static void main(String[] args) {
    //创建了集合对象
    Vector vector=new Vector();
    System.out.println(vector.capacity()+"t集合中元素的个数:"+vector.size());
    //ArrayList al=new ArrayList();
    //al.add("hello");
    //添加
    vector.add("hello");
    vector.add(0, "world");
    vector.addElement("java"); //添加元素
    
    System.out.println(vector.capacity()+"t集合中元素的个数:"+vector.size());
    System.out.println("集合中元素的个数:"+vector.size());
    System.out.println(vector);
    //删除
    //vector.remove(1);
    //vector.remove("java");
    //vector.clear();
    //vector.removeElement("java");
    //获取元素的方法
    System.out.println(vector.get(1));
    
    System.out.println(vector);
    System.out.println("加强for循环");
    for(Object obj:vector){
      System.out.println(obj);
    }
    System.out.println("使用迭代器遍历集合:");
    for(Iterator ite=vector.iterator();ite.hasNext();){
      System.out.println(ite.next());
    }
    
    Iterator ite=vector.iterator(); 
    while(ite.hasNext()){
      System.out.println(ite.next());
    }
  }
}