Java小白一文讲清Java中集合相关的知识点（三）

本文链接：https://blog.csdn.net/Kerwin_D/article/details/141827200

Vector底层结构和源码剖析

基本介绍

定义说明

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{.....}

Vector底层也是一个对象数组----protected Object[] elementData;
Vector 是线程同步的，即线程安全，Vector类的操作方法带有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;
    }

在开发中，需要线程同步安全时，考虑使用Vector
Vector扩容如果是无参，默认是10，满了之后，就按2倍扩容；

如果指定大小，则每次直接按2倍扩容；

//进入无参构造内部
    public Vector() {
        this(10);
    }
//加了10个元素，尝试继续添加1个元素时，此时的minCapacity为11
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//11-10>0,进入扩容机制
            grow(minCapacity);
    }
//扩容机制方法内部具体实现如下：
    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);
    }

调用无参构造，加了10个元素，再尝试加一个元素时，此时的vector的空间存储情况如下：

在这里插入图片描述

//进入有参构造器内部，初始指定vector大小为9

//加了9个后，尝试加第10个元素，
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);//此时的elementCount为9
        elementData[elementCount++] = e;
        return true;
    }
//进入确保容量的辅助函数内部
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//minCapacity为10，ele.length为9，结果大于0
            grow(minCapacity);
    }
//进入扩容机制内部具体实现
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//9
        //newCap = 9+9 = 18,动态数组中，capacityIncrement其实就是自己想扩容多少空间，
        //不写的话，默认设置为0；
        /*比如,创建Vector的时候
       	Vector vector = new Vector(9,5);
       	那么，此时放了9个元素在vector中，再想放一个元素进去，
       	不显式初始化capacityIncrement的话，其底层会自动地2倍扩容，成18个空间
       	而显式初始化capacityIncrement为5之后，其底层会扩容成9+5=14个空间
        */
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)//18-9
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//18-2147483639
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }