Vectory 源码分析

Vector

vector是java很早就出来的一个继承list的子类，基本属于淘汰级别，它与ArrayList相比实现级别相同，但Vector是线程安全的，基本上所有的方法都添加了Synchronized关键字来实现方法级别的同步锁，虽然控制了线程安全但性能也受到了大大的影响

看Vectory之前建议先看ArrayList源码分析

1. 先看一下Vector的全局变量、构造方法以及继承那些和实现那些接口

   //可以看到Vectors和ArrayList一样继承了AbstractList抽象类，和随机访问接口
   public class Vector<E>
       extends AbstractList<E>
       implements List<E>, RandomAccess, Cloneable, java.io.Serializable
   {
       /**
        *实际存储数据的数组
        */
       protected Object[] elementData;
   
       /**
        *元素的个数
        */
       protected int elementCount;
   
       /*
       *扩展的增长大小
        */
       protected int capacityIncrement;
   //根据初始化容量大小来 创建对象数组，并初始化容量增长变量
       public Vector(int initialCapacity, int capacityIncrement) {
           super();
           if (initialCapacity < 0)
               throw new IllegalArgumentException("Illegal Capacity: "+
                                                  initialCapacity);
           this.elementData = new Object[initialCapacity];
           this.capacityIncrement = capacityIncrement;
       }
   
       /**
        *
        */
       public Vector(int initialCapacity) {
           this(initialCapacity, 0);
       }
   
       /**
        * 默认初始是10 和ArrayList是一致的
        */
       public Vector() {
           this(10);
       }
   
       /**
        * 初始化带有集合的构造器
        */
       public Vector(Collection<? extends E> c) {
           elementData = c.toArray();
           elementCount = elementData.length;
           //如果不同类型通调用CopyOf来实现转换
           if (elementData.getClass() != Object[].class)
               elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
       }
       //这个方法是初始化带有集合的vector调用的通过系统底层类System通过数组拷贝实现
    public synchronized Object[] toArray() {
           return Arrays.copyOf(elementData, elementCount);
       }
       //可以看到上面的构造方法以及相关实现基本上和ArrayList是一模一样的只是在方法上添加了同步锁来保证线程安全
   

2. 然后看一下Vector的扩容和ArrayList的区别

     //最大的数组容量
     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   
       /**
        * 手动扩容，通过传入一个数值进行扩容。
        */
       private Object[] grow(int minCapacity) {
       //先通过newCapacity获取真正扩容的大小，然后通过调用Arrays.copyof方法进行数组拷贝来实现扩容，该方法在ArrayList中是一致的，可以前去看ArrayList分析。
           return elementData = Arrays.copyOf(elementData,
                                              newCapacity(minCapacity));
       }
   //该方法是Vectory内部进行扩容，比如进行添加进行判断是否需要扩容
       private Object[] grow() {
       //调用的是上面那个方法传入的数值是当前元素的个数+1和ArrayList也是一致的
           return grow(elementCount + 1);
       }
   
       /**
        * 获取扩容的真正大小
        */
       private int newCapacity(int minCapacity) {
           // 获取数组的长度
           int oldCapacity = elementData.length;
           //新的容量是：如果Vectory创建时有初始扩容参数则新容量是旧容量+上扩容参数，否则就是旧容量的两倍。
           int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                            capacityIncrement : oldCapacity);
          //如果新容量小于传入的数值则用传入的数值作为真正扩容大小
          if (newCapacity - minCapacity <= 0) {
               if (minCapacity < 0) // overflow
                   throw new OutOfMemoryError();
                  
               return minCapacity;
           }
       //  如果计算的新容量小于最大容量则直接返回，否则用传入的扩容数值与最大容量比较获取较小的一个
           return (newCapacity - MAX_ARRAY_SIZE <= 0)
               ? newCapacity
               : hugeCapacity(minCapacity);
       }
   
       private static int hugeCapacity(int minCapacity) {
           if (minCapacity < 0) // overflow
               throw new OutOfMemoryError();
           return (minCapacity > MAX_ARRAY_SIZE) ?
               Integer.MAX_VALUE :
               MAX_ARRAY_SIZE;
       }
   
   

3. 拷贝一个集合到Vector

    //该方法是传入一个数组，然后把vector中的数据拷贝到该数组中，方法加了同步锁  通过System系统底层类来实现数组拷贝，elementData是源数组，0是源素组开始拷贝的下标，anArray是目标数组，0是目标数组开始存放拷贝数据开始的位置，elementCount是拷贝的长度
    public synchronized void copyInto(Object[] anArray) {
           System.arraycopy(elementData, 0, anArray, 0, elementCount);
       }
   

4. 其他那些基本和ArrayList中实现方法没有多大差异，只是在方法上加了Synchronized同步锁。

   总结：感觉Vector基本就是jdk官方直接那ArrayList来来修改加了同步锁来进行控制线程安全，或者说是ArrayList是Vectory的修改版，为了加快速度而丢掉线程安全问题而诞生的哈哈。
   HashTable源码分析
   LinkedList源码分析
   Vector源码分析
   CopyOnWriteArrayList源码分析
   SynchorincedList源码分析