ArrayList-添加，删除原理-源码扩容grow(int minCapacity)
文章目录
- 总结
- 1预备知识
- 2源码分析
- 源码：add(E e) 原理实现
- 源码：grow(minCapacity) ArrayList核心
- 源码：remove(int index)删除实现
赠人玫瑰，手有余香，你的点赞，我的动力
更多分享可见：
总结
所谓动态数组的扩容，就是包装下面这个api 。
Arrays.copyOf(elementData, newCapacity);
没有耐心的小伙伴直接跳转到 grow(minCapacity) 目录处
1预备知识
运用：
1 Arrays.copyOf(elementData, newCapacity); //扩容数组的api
2 System.arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length); //复制数组的api
- 1
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = Arrays.copyOf(arr1, 5);
int[] arr3 = Arrays.copyOf(arr1, 10);
for(int i = 0; i < arr2.length; i++)
System.out.print("arr2:"+arr2[i] + " ");
System.out.println();
for(int i = 0; i < arr3.length; i++)
System.out.print("arr3:"+arr3[i] + " ");
}
}
运行结果：
arr2：1 2 3 4 5
arr3：1 2 3 4 5 0 0 0 0 0
可见扩容后的数组 补充了几个零，如果数组是对象，应该是补充几个null
- 2
System.arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
参数说明：
src：源对象
srcPos：源数组中的起始位置
dest：目标数组对象
destPos：目标数据中的起始位置
length：要拷贝的数组元素的数量
简单说：
我要复制一个名字为src 的数组，
从src 数组下标为srcPos 的位置开始复制，
复制的个数是 length ，
复制的内容写到哪里 dest 数组中！
从dest 数组的的destPos 下标位置开始复制！
2源码分析
源码：add(E e) 原理实现
add(E e)：添加一个元素到列表的末尾。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 确保数组大小够不是否，需要扩容不。
/*1 elementData 是Arraylist中存放元素的真正数组，size是当前数组中存了几个元素，而不是数组的长度！！！
*2 把添加的元素放入数组中已存入元素个数的+1位置！
*/
elementData[size++] = e;
return true;
}
记住size+1 代表加入一个元素后当前总元素的数量 很重要！！！！
- 下一步
看ensureCapacityInternal(size + 1); 如何扩容
private void ensureCapacityInternal(int minCapacity) {
//如果new ArrayList() 这样的实例对象，则ArrayList大小就是DEFAULT_CAPACITY--> 10大小
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//确定是否需要扩容，下一步进入
ensureExplicitCapacity(minCapacity);
}
- 下一步
要注意：当前的minCapacity 除了无惨构造实例化设置10 ，其他情况就是等于 size+1 ,代表当前list列表中的需要存储的总元素个数
ensureExplicitCapacity(minCapacity);
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 如果小存储的的总元素个数大于当前数组的长度，则扩容执行grow(minCapacity)
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
源码：grow(minCapacity) ArrayList核心
- 下一步 grow
grow(minCapacity)
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//表示扩容一半,>>1 代表右移一位，在数学上就等同于除2，所以本身长度 oldCapactiy+自身一半， 这是扩容后的长度。
int newCapacity = oldCapacity + (oldCapacity >> 1);
//扩容前有两个情况需要注意下：
//情况1 如果扩容后的长度还是小于当前需要存入的个数minCapacity ，为扩容的大小
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//情况2 如果扩容后的长度，大于ArrayList 类中规定的最大长度，处理情况，暂时不看
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//程序走到这里就代表老老实实的扩容了，怎么样看到Arrays.copyOf() 很熟悉了吧
elementData = Arrays.copyOf(elementData, newCapacity);
}
- 下一步
我们在继续分析Arrays.copyOf(elementData, newCapacity);
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());//点击下一步
}
- 下一步
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
/*下边三元表达式，代码看起来很恶心，表达的意思是：要被复制的目标是不是Object[] 类型的
*如果是重新建一个Object[newLength] 数组，记着newLength 传递的是我们需要扩容数组的大小！！
*如果不是则把目标包装成一个数组，大小也是newLength
*最终目的就是保证传入给System.arraycopy() 方法中参数"copy" 的值是一个我们扩容后的新数组
*/
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//眼熟吧！！！上面例子中有解释
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
源码：remove(int index)删除实现
如果删除23 这个数字，要把位置在7,8，9上的元素移动到6，7,8的位置上！
所以源码分析
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
//复制的个数
int numMoved = size - index - 1;//删除23，则后面的元素的位置index 7 8 9，所以需要3个
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);//numMoved代表需要复制几个！
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
更多记录请看：