对于ArrayList源码，我是初次阅读，可能有很多地方理解不正确，如果有错的话还请大家多多指教。
然后声明一下的我的JDK版本：openjdk11。(可以直接打开链接查看，链接的jdk11和我的版本稍有不同，但基本上一致)
首先说明一下ArrayList变量的含义
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData;
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
对于这个值，需要说明一点，当你使用ArrayList<Integer> list = new ArrayList<>();定义一个list时，不是说你不给它赋值，它默认的容量大小就是10了,它是在第一次add时进行初始化的。
这个变量主要是当elementData.length为0或者size为0时，为elementData赋一个空数组用的。
对于这个变量，看着好像和EMPTYELEMENTDATA没什么区别，但是他俩的作用是不一样的，当我们不指定initialCapacity时，他会用DEFAULTCAPACITYEMPTY_ELEMENTDATA为elementData进行初始化，之后会通过判断elementData与该变量是不是相等来确定是不是第一次操作。
这个变量应该没什么问题，就是用来存储数据的
这个变量用于存储当前ArrayList有多少个元素（注：不是elementData数组的大小）
这个变量是来自AbstractList，我感觉很有必要说一下，它是用来记录数组变化的次数（添加删除等操作都算）
add函数
public void add(int index, E element) {
this.rangeCheckForAdd(index);
++this.modCount;
int s;
Object[] elementData;
if ((s = this.size) == (elementData = this.elementData).length) {
elementData = this.grow();
}
System.arraycopy(elementData, index, elementData, index + 1, s - index);
elementData[index] = element;
this.size = s + 1;
}
这里System.arraycopy(elementData, index, elementData, index + 1, s - index)我觉得与必要说一下，结合System类的注释，大概了解了这个函数的意义。
在add函数中，source array和target array其实是同一个数组，这里我为了便于理解，做成了两个。
其中srcPos是拷贝开始的位置，destPos是“粘贴”开始的位置，length是需要拷贝的长度。这里需要注意一下，add函数是确保了数组的容量一定是够的，因为它先进行了扩容的判断，空间不足时，会先进行扩容。
grow()函数
private Object[] grow(int minCapacity) {
return this.elementData = Arrays.copyOf(this.elementData, this.newCapacity(minCapacity));
}
从这可以看出ArrayList扩容还是比较耗时的，如果一开始能够确认数组的大小，那就为它赋一个初始容量，防止它多次扩容而影响性能。
newCapacity()函数
private int newCapacity(int minCapacity) {
int oldCapacity = this.elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
if (this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(10, minCapacity);
} else if (minCapacity < 0) {
throw new OutOfMemoryError();
} else {
return minCapacity;
}
} else {
return newCapacity - 2147483639 <= 0 ? newCapacity : hugeCapacity(minCapacity);
}
}
对于this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA这句我说是第一次扩容，其实也不完全正确，这里必须是在new一个ArrayList时候没有给它赋初始值，那elementData才会等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA。
上面三段代码就一块分析了，整个添加流程大概如下图：
这幅图可能并不是很准确，有些细节我并没有体现，因为怕图越来越臃肿。
get()函数
public E get(int index) {
Objects.checkIndex(index, this.size);
return this.elementData(index);
}
这个函数很简单，基本没有要介绍的，其中有个Objects.checkIndex(index, this.size)检查下标是否越界。
hashCode()函数
public int hashCode() {
int expectedModCount = this.modCount;
int hash = this.hashCodeRange(0, this.size);
this.checkForComodification(expectedModCount);
return hash;
}
int hashCodeRange(int from, int to) {
Object[] es = this.elementData;
if (to > es.length) {
throw new ConcurrentModificationException();
} else {
int hashCode = 1;
for(int i = from; i < to; ++i) {
Object e = es[i];
hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
}
return hashCode;
}
}
这里解释一下hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode())为什么要乘31.
在Effective Java中作者是这样解释的：
乘法部分使得散列值依赖于域的顺序，如果一个类包含多个相似的域，这样的乘法运算就会产生一个更好的散列函数。例如，ArrayList中添加了1,2,3,4这四个元素，另一个ArrayList也添加了这四个元素，但是和第一个顺序不一致，不用乘法的话，那这两个ArrayList的hashCode就是一样的（这里是我自己的理解，下面我也给出了一个例子）。之所以选31是因为他是一个奇素数，如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价与移位运算，使用素数的好处并不明显，但习惯上都使用素数来计算散列结果。31有个很好特性，即用移位和减法来代替乘法：31 * i == (i << 5) - i
示例1：
测试结果：
我一开始起了10个线程，发现并没有出现想要的异常，于是直接起1000个线程，不出意外，出现了想要的结果。当然我也不能100%确定只有这个作用，但是依照目前测试结果来看，肯定是有这么个作用的。如果大家有别的见解欢迎指出。
示例1：
测试结果为true。
示例2：
结果为false。
可以知道循序不同，hashCode确实是不同的，这也就是乘31所起的作用。
remove函数
public E remove(int index) {
Objects.checkIndex(index, this.size);
Object[] es = this.elementData;
E oldValue = es[index];
this.fastRemove(es, index);
return oldValue;
}
private void fastRemove(Object[] es, int i) {
++this.modCount;
int newSize;
if ((newSize = this.size - 1) > i) {
System.arraycopy(es, i + 1, es, i, newSize - i);
}
es[this.size = newSize] = null;
}
public boolean remove(Object o) {
Object[] es = this.elementData;
int size = this.size;
int i = 0;
if (o == null) {
while(true) {
if (i >= size) {
return false;
}
if (es[i] == null) {
break;
}
++i;
}
} else {
while(true) {
if (i >= size) {
return false;
}
if (o.equals(es[i])) {
break;
}
++i;
}
}
this.fastRemove(es, i);
return true;
}
评论