java 集合Vector 的扩容机制

来自上海的这位朋友 2022-08-06 08:51:26 阅读数:239

java集合vector机制扩容

java 集合Vector 的扩容机制

1,首先我们可以看到它的构造方法

 /** * Constructs an empty vector so that its internal data array * has size {@code 10} and its standard capacity increment is * zero. */
public Vector() {

// 当前是无参构造方法 Vector vector = new Vector();
// 其实你不给参数,它默认就是10,它会去调用一个有参方法
this(10);
}

2,它会去调用一个有参方法

 /** * Constructs an empty vector with the specified initial capacity and * with its capacity increment equal to zero. * * @param initialCapacity the initial capacity of the vector * @throws IllegalArgumentException if the specified initial capacity * is negative */
public Vector(int initialCapacity) {

// 这句话好比如 Vector vector = new Vector(5);
// 意思代表着如果你没有参数我默认就是10,如何调用有参方法
// 如果构造方法有值的话,则直接走当前方法
this(initialCapacity, 0);
}

3,来到第三个构造方法

 /** * Constructs an empty vector with the specified initial capacity and * capacity increment. * * @param initialCapacity the initial capacity of the vector * @param capacityIncrement the amount by which the capacity is * increased when the vector overflows * @throws IllegalArgumentException if the specified initial capacity * is negative */
// 由此看出我们在创建Vector的时候
// 可以这样 Vector vector = new Vector(5,1); 则直接回略过
// 之前的方法,直接调用该方法
public Vector(int initialCapacity, int capacityIncrement) {

super();
// 判断当前的值是否为负数,则会抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
/** * 第一个值代表当前数组初始化的大小 * 第二个值代表待会儿我们可以在扩容的那个地方说,它起到了关键 * 性作用 */
this.elementData = new Object[initialCapacity];
// 如果我们在刚刚开始构建Vector的时候你没有传入参数
// 或者说你只传了一个参数,在调用当前方法的时候,它是
// 默认传入0的
this.capacityIncrement = capacityIncrement;
}

4,当我们进行添加的时候

 /** * Appends the specified element to the end of this Vector. * * @param e element to be appended to this Vector * @return {@code true} (as specified by {@link Collection#add}) * @since 1.2 */
// 可以看见该方法synchronized修饰,则是线程安全的
public synchronized boolean add(E e) {

modCount++;// 修改次数 加加
// protected int elementCount; 则记录当前,每次加1
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}

5,往里追ensureCapacityHelper

 /** * This implements the unsynchronized semantics of ensureCapacity. * Synchronized methods in this class can internally call this * method for ensuring capacity without incurring the cost of an * extra synchronization. * * @see #ensureCapacity(int) */
private void ensureCapacityHelper(int minCapacity) {

// overflow-conscious code
// 如果在无参构造方法在第一次进行添加的时候,
// 此时的minCapacity 等于1 而elementDta.length等于10
// 1-10 = -9; -9不大于0 所以说不满足条件
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

6,如果我们进行多次添加后,则当前会满足条件,看一下grow方法是如何完成扩容的

 // 假设当前已经进入到该方法,上面条件已经成立
private void grow(int minCapacity) {

// overflow-conscious code
// 此时我们的elementData.length是等于10 
int oldCapacity = elementData.length;
/** * 这边 运用了一个三元运算符就行判断 * capacityIncrement 就是前面说的起到关键性作用的变量 * 假设,我们在创建Vector的时候是一个无参的构造器,或者说只有一个 * 参数,那么此时的capacityIncrement 等于0,前面提到过 默认传给 * 它的就是0,0不大于0所以结果为 oldCapacity + oldCapacity * 也就是10加上10 等于20,以2倍的速度进行增加 * 如果你是Vector vector = new Vector(5,5);这样创建 * 结果明显而知,5肯定大于0的 */
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 = 2147483639
// 判断当前是否超出了一个最大值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 调用了Arrays.copyOf方法,
// 为什么调用Arrays.copyOf,为了就是保留原有的数据
// 把新的newCapacity赋值给它后再copy给原来的elementData
// 则当前扩容完成
elementData = Arrays.copyOf(elementData, newCapacity);
}
版权声明:本文为[来自上海的这位朋友]所创,转载请带上原文链接,感谢。 https://tanyongpeng.blog.csdn.net/article/details/122757884