ArrayList是动态数组,底层为java中的数组。
既然底层为数组,那么
1.数组的类型是什么?
Object[] empty={};
2.arrayList的最大容量是多少和初始化容量是多少?
//需要8byte来存储集合本身信息
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //(2^31-1)-8
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//1.防止栈溢出和越界
//2.提前达到最大,减少一次扩容的机会
//这个时候元素数量达到集合存储的极限,任何一次数组迁徙和复制都可能引发内存溢出
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
初始化容量:
/**
* 默认初始化容量
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
但是,使用ArrayList和HashMap的无参构造器时都是采用延迟加载来完成初始化的。
jdk1.8之前,都是直接默认容量为10;
this.elementData = new Object[initialCapacity];//初始化长度为10
1.8之后,为了优化内存使用采用了延迟加载。
ArrayList在add()的时候初始化数组( 初始化容量为10 ),HashMap在put()的时候初始化数组( 初始化容量为16 )。
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//与EMPTY_ELEMENTDATA区分开来以了解添加第一个元素时扩容多少
//transient修饰的成员变量在被序列化后不能被保存
transient Object[] elementData;//不能private修饰
//有参构造器
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;//空数组
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造器
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//默认的空数组
}
3.如何进行动态扩容的?扩容的时机又是什么?
ArrayList<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
list.add("8");
list.add("9");
list.add("10");
System.out.println(list);
public boolean add(E e) { //e为存储的元素
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e; //size为存储的元素个数
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //判断是否使用的无参构造器
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); //minCapacity:size+1 取较大的一方
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0) //判断是否进行扩容 elementData.length为当前容量
grow(minCapacity);
}
//扩容方法
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容1.5倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
关于int newCapacity = oldCapacity + (oldCapacity >> 1);
//把oldCapacity(二进制)右移一位 == oldCapacity(十进制)* 1.5
int newCapacity = oldCapacity + (oldCapacity >> 1);
//转换为二进制
int a=10;
System.out.println(Integer.toBinaryString(a));//打印结果:1010
4.remove()
int[] array={1,2,3,4,5,6,7,8,9};
//移除下标为6的元素。或者remove("7")
remove(6);
//array:{1,2,3,4,5,6,8,9,null};
被删除元素后的所有元素往前移动,最后的元素被赋null,最后被GC回收。所以数组查询快,增删慢