Vector源码分析以及ArrayList比较

源码分析如下：
package easyExcel;

import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {

        /**
             protected Object[] elementData; 数组存储元素

             elementCount 元素大小

             capacityIncrement 容量增量  构造的时候可以指定，若为0 则扩容为原有的2倍，否则为原容量+容量增量

             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]; 初始化数组长度
                 this.capacityIncrement = capacityIncrement; 元素个数
            }
            Vector和ArrayList 都是基于动态数组组成的
            Vector无参构造函数的时候会初始化数组大小 默认长度为10 ArrayList 使用无参构造函数的时候会构造一个空数组在add的时候才会去初始化数组长度 默认长度为10
         */
        Vector vector = new Vector();

        /**
         public synchronized boolean add(E e) {
             modCount++;
             ensureCapacityHelper(elementCount + 1); 元素个数加1
             elementData[elementCount++] = e;
             return true;
         }

         private void ensureCapacityHelper(int minCapacity) {
         // overflow-conscious code
             if (minCapacity - elementData.length > 0) 判断元素个数加1 与数组的长度作比较 >0 则需要扩容 与ArrayList里面一样不过ArrayList第一次添加元素的时候minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); //取最大值
                grow(minCapacity); 扩容
         }

         private void grow(int minCapacity) {
             int oldCapacity = elementData.length; 获取数组的长度
             capacityIncrement（扩容矢量）大于0 容器容量则为原始容量+capacityIncrement 否则容量为原有的2倍 ArrayList扩容 oldCapacity + (oldCapacity>>2) 相当于1.5倍
             int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
             if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
             if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
             elementData = Arrays.copyOf(elementData, newCapacity); //jvm 进行扩容
         }

         添加元素 用了synchronized 关键字修饰 是线程安全的 这是与ArrayList最大的区别
         */

        vector.add("1");

        /**
         public void add(int index, E element) {
            insertElementAt(element, index);
         }
         synchronized 关键字 线程安全
         public synchronized void insertElementAt(E obj, int index) {
             modCount++;
             if (index > elementCount) {
                throw new ArrayIndexOutOfBoundsException(index+ " > " + elementCount);
             }
             ensureCapacityHelper(elementCount + 1); 判断是否扩容
             System.arraycopy(elementData, index, elementData, index + 1, elementCount - index); //移动index后面的元素 然后再index位置复制 跟ArrayList是一样的
             elementData[index] = obj;
             elementCount++;
         }

         */
        vector.add(1,"2");

        /**
         synchronized 修饰
         public synchronized E get(int index) {
             if (index >= elementCount)
             throw new ArrayIndexOutOfBoundsException(index);

             return elementData(index);
         }
         */
        vector.get(1);

        //根据索引删除

        /**
         synchronized 修饰 保证线程安全
         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)
                 复制元素从elementData的index+1到末尾 复制到elementData从index开始 相当于index后面的元素向前移动一位与ArrayList一致
                System.arraycopy(elementData, index+1, elementData, index,numMoved);
             elementData[--elementCount] = null; // Let gc do its work

             return oldValue;
         }
         */
        vector.remove(1);

        /**
         public synchronized boolean removeElement(Object obj) {
             modCount++;
             int i = indexOf(obj);
             if (i >= 0) {
                removeElementAt(i);
                return true;
             }
             return false;
         }
         先使用indexOf获取索引的位置 然后根据索引删除
         */
        //根据元素删除
        vector.remove("0");

        /**
         synchronized 修饰
         public synchronized int indexOf(Object o, int index) {
             if (o == null) {
                for (int i = index ; i < elementCount ; i++)
                    if (elementData[i]==null)
                    return i;
                } else {
                    for (int i = index ; i < elementCount ; i++)
                        if (o.equals(elementData[i]))
                            return i;
             }
             return -1;
         }
         循环遍历 判断元素是否相等 返回索引的位置
         注：只删除第一个匹配的元素 而ArrayList会删除所有匹配的元素
         */
        vector.contains("o");
    }
}

总结：
Vector和ArrayList的主要区别在于vector的方法是用synchronized关键字修饰的，保证了线程安全；使用无参构造方法的时候vector会初始化容器大小而ArrayList只会定义一个空数组，在添加的时候才会初始化容器大小；扩容算法不一样vector有一个容量增量，指定的有则扩容的大小为（原有容量的长度+容量增量）否则为原有容量的2倍，ArrayList为1.5倍的容量（oldCapacity + （oldCapacity>>1））。