Vector基于jdk1.8进行解析

jdk1.8中的vector底层我们能够看见是一个Object[] elementData数组这种结构

//由此我们能够看见就是vector底层数据结构就是数组 ，摈弃我们能够看见数组的初始容量就是10
protected Object[] elementData;

//在vecotr无参的构造中我们能够看见初始容量就是10
 public Vector() {
        this(10);
    }

//可以看见容量的增加值，它的类型是一个整形
 protected int capacityIncrement;

//有参构造中，有两个参数，一个是初始容量，一个是容量增加值
//代码逻辑就是判断初始容量是否小于0，如果小于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;
    }

//trimToSize方法是一个线程安全的方法，并且是一个简单粗暴的synchronized修饰词修饰的
//在这个方法中主要就是判断元素总数与长度的比较，如果小于就调用System.arraycopy方法进行数组复制的
//代码操作。同时记录数组的修改次数modcount
public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }

//确认数组的容量方法，在这个方法中其实就是两个步骤第一步记录数组的修改次数
//第二对数组进行扩容操作，下一步可以查看ensureCapcityHelper（minCapacity)方法
 public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }


//在这个方法中我们能够看见，是对数值的的大小进行了比较，真正的数组扩容是在grow方法中
//下一步主要的就是对grow方法进行具体的分析
private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

//在这个方法中是进行扩容的操作，其代码逻辑是其新建的一个值首先看下容器增量是否大于0，基本可以说是//扩容2倍
//第二阶段的代码逻辑就是说比较新的容器量与参数值比较取大的值赋值给最新的容器值，并且判断是否大于Integer类型的最大值，然后就是调用System.arraycopy方法进行数组复制
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }


 
//在方法上能够看见添加元素方法是一个线程安全的-synchronized关键词修饰的
//在方法中我们能够看见，记录数组的修改次数，并且进行了扩容操作
//将数组中的size+1索引处赋值为obj参数值
public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

//这个方法是指代删除一个元素的，并且是线程安全的-synchronized关键词修饰的
//记录数组的修改次数做到fast-fail机制
//看下里面的indexof方法
public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

//indexof方法源码解析
//代码逻辑就是首先判断目标参数是否为null，如果为null，找出第一次出现null的index位置，并且返回index
//如果目标参数不为null，那么就循环遍历利用object中的equals方法进行比较，返回等于的索引值
//如果在数组中没有找到index值，那么就会返回一个-1值
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;
    }


//接下来看下removeElementAt(int index)方法的源码
//首先判断index的临界条件判断，然后计算出需要移动的个数，再调用System.arraycopy数组复制
//然后再对数组元素个数进行自减1，同时数组复制，并且赋值size为null值
public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }