package com.example.demo.test;
import java.util.Vector;
/**
*
* VectorTest
*
* Description: JDK 1.8
* 测试Vector的扩容方式，通过测试可以看出其每次以2的倍数形式扩充Object数组
*
* @author Jalen
* @date 2019/8/27 13:31
*/
public class VectorTest {
public static void main(String[] args) {
createEmptyVector();
}
/**
* 创建Vector
* 调用链1(初始化)：
*      {@link java.util.Vector#Vector(int)}
*          传入capacity为2，如果为空，默认capacity是10
*      {@link java.util.Vector#Vector(int, int)}
*          第一个参数为初始容量initialCapacity，为2，第二个参数是capacityIncrement，默认在初始化时传0
*          该操作创建一个2个长度的Object数组，且capacityIncrement赋值为0
*          代码：
*              super();
*              if (initialCapacity < 0)
*                  throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
*              this.elementData = new Object[initialCapacity];
*              this.capacityIncrement = capacityIncrement;
* 调用链2：
*      {@link java.util.Vector#add(Object)}
*          synchronized修饰，modCount自增，计算容量(如果不够会执行扩容)，根据下标为elementData赋值
*          代码：
*              modCount++;
*              ensureCapacityHelper(elementCount + 1);  //elementCount=0,只需确保有一个空间可用
*              elementData[elementCount++] = e;
*              return true;
*      {@link java.util.Vector#ensureCapacity(int)}
*          这里传入的参数minCapacity为1，即我们需要的最小容量是1，elementData length是我们初始化时的容量2，此时不会扩容
*              if (minCapacity - elementData.length > 0)
*                  grow(minCapacity);
*      elementData[elementCount++] = e; //因为无需扩容，直接根据数组下标赋值就好啦
* 调用链3：
*      此时和调用链2是一样的，不存在扩容
* 调用链4：
*      {@link java.util.Vector#add(Object)}
*          synchronized修饰，modCount自增，计算容量(如果不够会执行扩容)，根据下标为elementData赋值
*          代码：
*              modCount++;
*              ensureCapacityHelper(elementCount + 1);  //elementCount=0,只需确保有一个空间可用
*              elementData[elementCount++] = e;
*              return true;
*      {@link java.util.Vector#ensureCapacity(int)}
*          这里传入的参数minCapacity为3，即我们需要的最小容量是3，elementData length是我们初始化时的容量2，此时会扩容
*              if (minCapacity - elementData.length > 0)
*                  grow(minCapacity);
*      {@link java.util.Vector#grow(int)}
*          计算新的容量，因为capacityIncrement初始化时是0，所以newCapacity = oldCapacity + oldCapacity，
*          即新容量等于旧容量的2倍，elementData扩容为原来的2倍数，即4
*          代码：
*              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); //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
*              elementData = Arrays.copyOf(elementData, newCapacity);
*      最后根据下标赋值就好啦
*          代码：
*              elementData[elementCount++] = e;
* 调用链5：
*      因为上一步扩容到4，此时不会扩容
* 调用链6：
*      此时因为容量4已用完，会触发扩容，容量扩大到8
*/
private static void createEmptyVector(){
Vectorvector = new Vector<>(2); //1
vector.add("aaa"); //2
vector.add("bbb"); //3
vector.add("ccc"); //4
vector.add("ddd"); //5
vector.add("eee"); //6
System.out.println(vector.toString());
}
/**
* 这里初始化时指定每次扩容的大小，交给用户设置
*/
private static void createEmptyVectorWithIncrement(){
Vectorvector = new Vector<>(2, 3);//初始容量为2，每次扩容空间为3
vector.add("aaa"); //不扩容，容量为2
vector.add("bbb"); //不扩容，容量为2
vector.add("ccc"); //扩容，扩容为5
vector.add("ddd"); //不扩容，容量为5
vector.add("eee"); //不扩容，容量为5
System.out.println(vector.toString());
}
}
扩容方法：
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
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);
}
注意不同于ArrayList的扩容方式
ArrayList扩容公式为：newCapacity  =  oldCapacity + oldCapacity >> 1

【侯捷-SL体系结构内核分析-vector探索】
查看vs2017中vector源码时，发现vs中vector容量的扩充并不是2 * oldCapacity的增长方式，而是oldCapacity + oldCapacity / 2的增长方式，相关源代码如下：


附：vector源代码位于文件夹：file://…/VC/Tools/MSVC/14.15.26726/include

ArryList
ArrayList的默认初始容量为10
可以自定义指定初始容量(构造方法)
扩容：
new.size = old.size*1.5
Vector
Vector初始大小为10
扩容：
new.size = old.size*2
HashMap
HashMap初始大小为16
扩容：
new.size = old.size*2
通过移位翻倍

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold

vector<int> vecInt;
	int a =1;
	vecInt.push_back(a);
 
	int* pA = &vecInt[0];
 
	cout << pA << ":" << *pA << endl;
 
	for (int i = 0; i < 16; i++)
	{
		vecInt.push_back(i);
	}
 
	cout << pA << ":" << *pA << endl;

 
看上面一段代码，输出结果为：
0025DC8:1
0025DC8:-17891602
 
当vector扩充容量以后，vector申请新的空间，所有原来的数据复制到新的空间上，旧的空间删除。所以数据指针尽量不要指向经常变动的vector数据之上。
 
解决办法有2个：
1、直接复制元素实体出去使用。
2、估算vector在工程中的大小，初始化时初始化足够大的大小来存储vector元素。