分析 + 手写 ArrayList 源码 （增删查询）

import java.util.Arrays;

/**
* @description: 实现基本的 ArrayList 的查询删除增加覆盖操作
* @author: Rule
* @date: 2018-09-09 16:37
**/
public class TestArrayList<E> {

//定义一个存放数据的数组
transient Object[] elementData;

//定义数组的初始化的容量
private static final int DEFAULT_CAPACITY = 10;

//定义空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

//定义一个默认的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};

//定义一个数组最大的长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//记录数组中的实际使用的大小
private int size;

//具有初始化容量的构造函数
public TestArrayList(int initialCapacity){
if (initialCapacity > 0){
this.elementData = new Object[initialCapacity];
}else if (initialCapacity == 0){
this.elementData = this.EMPTY_ELEMENTDATA;
}else {
//如果初始的容量 < 0，则抛出异常
throw new IllegalArgumentException("初始的容量不能小于0！！");
}
}

//不含初始化容量的搞糟参数，采用默认的初始化容量
public TestArrayList(){
elementData = new Object[DEFAULT_CAPACITY];
}

//根据下标 index 查询出对应的对象
public E get(int index){

//首先 对于下标 index，首先执行检查下标是否合法
checkIndex(index);
return (E) this.elementData[index];
}

private void checkIndex(int index) {
if (index < 0 || index >= size){
throw new IndexOutOfBoundsException("index 越界啦！！");
}
}

//添加操作 (不含下标 index 的添加)
public void add(E e){

//首先执行添加操作，确定是否进行扩容
//这句话的意思是，确定容量能否再加一个
ensureCapacity(size + 1);

//扩容后，直接执行添加操作
elementData[size++] = e;

}

//添加操作 (含下标 index 的添加)
public void add(int index, E e){
//首先含下标的 add() 方法，就是将 index 后面的元素依次后移
//还是要计算是否能进行扩容操作
ensureCapacity(size + 1);
//首先要判断 index 是在什么位置上进行添加操作
//这个index 就是在数组的末尾进行添加，但是 checkIndex ()检查不包含 index == size 这个条件
if (index == size){
//接着执行在末尾继续添加操作
elementData[size] = e;
}else{
//检查下标是否合法
checkIndex(index);
/**
* arraycopy(src, srcPos, dest, destPos, length)这个方法包含了5个参数在这里代表的意思如下
* src: 原数组
* srcPos: 原数组的 srcPos 起始位置
* dest: 目标数组
* destPos: 目标数组从 destPos 位置开始覆盖
*length: 是原数组的 从 srcPos 位置起始到后面的长度
*/
//将 index 后的数据依次往后移动一位
System.arraycopy(elementData, index, elementData, index+1,size - index);
//然后对 elementData数组插入 index 位置上的数据
elementData[index] = e;
}
size++;
}

//删除操作 (含下标的删除)
public void remove(int index){

//首先还是对 index 进行检查
checkIndex(index);

// 将需要删除的元素，进行覆盖。 index 后面的元素依次向前进行覆
System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
//size实际长度-1
size--;
}

//比较需要的容量和默认的容量
private void ensureCapacity(int minCapacity) {
//判断 elementData 还没有进行添加操作
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

//判断需要的容量如果大于
ensureExplicitCapacity(minCapacity);
}

//判断需要的容量如果大于数组的长度
private void ensureExplicitCapacity(int minCapacity) {
if (minCapacity > elementData.length){
//执行扩容操作
grow(minCapacity);
}
}

//扩容操作,一般是再原基础上扩容 1.5倍
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//扩容 1 + 0.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//出现这种情况，说明内存溢出了
if (newCapacity < minCapacity){
newCapacity = minCapacity;
}
//如果得到的容量比限定的容量还要大
if (newCapacity - MAX_ARRAY_SIZE > 0){
newCapacity = hugeCapacity(minCapacity);
}

//对扩容后的容量进行检查后，直接对 elementData 进行扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}

//这个方法告诉我们，elementData 的实际大小为 Integer.MAX_VALUE,而不是定义的 MAX_ARRAY_SIZE;
private int hugeCapacity(int minCapacity) {
//minCapacity < 0 说明了，需要的容量小于0，抛出内存溢出异常
if (minCapacity < 0){
throw new OutOfMemoryError("需要的容量不能小于0");
}

return minCapacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

//得到 elementData的 实际容量
public int size(){
return this.size;

}
}