private static final long serialVersionUID = 8683452581122892189L;//唯一序列号ID private static final int DEFAULT_CAPACITY = 10;//jdk7之前初始容量为10，类似饿汉式，jdk8以后初始容量为0，类似懒汉式 private static final Object[] EMPTY_ELEMENTDATA = {};//有参构造且传入大小为0时的空数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//无参构造的空数组 transient Object[] elementData; //实际存储元素的数组 private int size;//实际存储的元素个数
//构造函数
public ArrayList(int initialCapacity) { if (initialCapacity > 0) {//懒汉式 this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {//饿汉式 this.elementData = EMPTY_ELEMENTDATA;
} else {//传入的初始容量小于0，非法，抛出异常 throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
} public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}public ArrayList(Collection<? extends E> c) {//传入一个集合，首先转换为Object数组。数组长度不为0时，如果传入的集合时ArrayList，那么直接赋值底层数组，否则复制底层数组。如果长度为0，那么类似有参构造方法参数为0的情况。 Object[] a = c.toArray(); if ((size = a.length) != 0) { if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else { // replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
public int size() {//返回实际元素个数 return size;
} public boolean isEmpty() {//判断实际元素个数是否为0 return size == 0;
} public boolean contains(Object o) {//查找元素o在数组中第一次出现的下标，如果为-1就不存在。 return indexOf(o) >= 0;
} public int indexOf(Object o) {//调用indexOfRange(查找对象，0，实际元素个数) return indexOfRange(o, 0, size);
} int indexOfRange(Object o, int start, int end) {//在存储元素的数组中查找，范围是[start,end)。如果查找null对象，使用==比较。如果查找非null对象，那么调用Object.equals()方法判断是否相等。找到则返回下标，找不到返回-1。 Object[] es = elementData; if (o == null) { for (int i = start; i < end; i++) { if (es[i] == null) { return i;
}
}
} else { for (int i = start; i < end; i++) { if (o.equals(es[i])) { return i;
}
}
} return -1;
} public int lastIndexOf(Object o) {//调用lastIndexOfRange() return lastIndexOfRange(o, 0, size);
} int lastIndexOfRange(Object o, int start, int end) {//与indexOfRange()类似，但是是逆序查找。 Object[] es = elementData; if (o == null) { for (int i = end - 1; i >= start; i--) { if (es[i] == null) { return i;
}
}
} else { for (int i = end - 1; i >= start; i--) { if (o.equals(es[i])) { return i;
}
}
} return -1;
}
public Object clone() {//调用父类的clone()方法，并且转换为(ArrayList<?>)类型，新对象的数组复制原来的数组，并将新对象的修改次数设置为0。如果克隆失败，抛出CloneNotSupportedException。E try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0; return v;
} catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
} public Object[] toArray() {//返回元素数组的复制。 return Arrays.copyOf(elementData, size);
} public <T> T[] toArray(T[] a) {//泛型类型的数组复制。如果传入数组的长度小于实际元素个数，那么返回泛型数组类型的，列表中元素数组的复制。如果相等，直接复制，如果传入数组的长度大于实际元素个数，多余的位置用null填充。 if (a.length < size) // Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size); if (a.length > size)
a[size] = null; return a;
}E elementData(int index) {//以泛型类型返回数组中指定位置的元素 return (E) elementData[index];
}
@SuppressWarnings("unchecked") static <E> E elementAt(Object[] es, int index) { //以泛型类型返回给定数组中指定位置的元素 return (E) es[index];
} public E get(int index) { //泛型方法get()首先调用Objects工具类中的checkIndex()方法，判断index是否在数组有效范围内。该方法实际上是另一个定义相同的方法的调用，如果不在范围内，抛出OutOfBoundsCheckIndex异常。否则返回下标对应的元素。
Objects.checkIndex(index, size); return elementData(index);
} public E set(int index, E element) { //泛型方法set()首先判断是否越界。不越界就修改下标处元素的值，并返回原来下标处的值。
Objects.checkIndex(index, size);
E oldValue = elementData(index);
elementData[index] = element; return oldValue;
} privatevoid add(E e, Object[] elementData, int s) { //如果当前元素个数和长读相等，那么自动扩容一个长度。放入元素并使size++。 if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
} publicboolean add(E e) { //修改次数+1，调用add()重载方法，返回true。
modCount++;
add(e, elementData, size); returntrue;
} publicvoid add(int index, E element) { //调用rangeCheckForAdd()
rangeCheckForAdd(index);
modCount++; finalint s;
Object[] elementData; if ((s = size) == (elementData = this.elementData).length)
elementData = grow();
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
} public E remove(int index) { //首先判断index是否合法，如果合法，定义一个final数组等于当前元素数组，然后保留泛型元素，调用fastRemove()，并将泛型元素返回。
Objects.checkIndex(index, size); final Object[] es = elementData;
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
fastRemove(es, index); return oldValue;
} publicboolean equals(Object o) { //如果是同一个对象，返回true。如果不是List或其子类，返回false。如果是，判断对象的Clas是否是ArrayList，如果是就调用equalsArrayList()方法，否则调用equlsRange()方法
//最后调用checkForComodification()方法。 //在比较两个List的过程中不能改变List的元素。否则会抛出并发修改异常。 if (o == this) { returntrue;
} if (!(o instanceof List)) { returnfalse;
} finalint expectedModCount = modCount; // ArrayList can be subclassed and given arbitrary behavior, but we can // still deal with the common case where o is ArrayList preciselyboolean equal = (o.getClass() == ArrayList.class) ? equalsArrayList((ArrayList<?>) o)
: equalsRange((List<?>) o, 0, size);
checkForComodification(expectedModCount); return equal;
} boolean equalsRange(List<?> other, int from, int to) { //首先定义静态变量指向当前元素数组，如果范围上界大于数组长度，就抛出并发修改异常（ArrayList线程不同步）。调用传入List的迭代器，判断每一个元素是否相等，元素个数是否相等。一致返回true，否则返回false。 final Object[] es = elementData; if (to > es.length) { thrownew ConcurrentModificationException();
}
var oit = other.iterator(); for (; from < to; from++) { if (!oit.hasNext() || !Objects.equals(es[from], oit.next())) { returnfalse;
}
} return !oit.hasNext();
} privateboolean equalsArrayList(ArrayList<?> other) { //如果是两个ArrayList判断，先判断两个al的元素个数是否相等，如果相等，静态定义两个数组保存元素数组。如果当前元素个数超过数组长度，抛出并发修改异常。 //否则判断每个元素是否相等。最后调用checkForComodification()方法。返回判断结果。 finalint otherModCount = other.modCount; finalint s = size; boolean equal; if (equal = (s == other.size)) { final Object[] otherEs = other.elementData; final Object[] es = elementData; if (s > es.length || s > otherEs.length) { thrownew ConcurrentModificationException();
} for (int i = 0; i < s; i++) { if (!Objects.equals(es[i], otherEs[i])) {
equal = false; break;
}
}
}
other.checkForComodification(otherModCount); return equal;
} privatevoid checkForComodification(finalint expectedModCount) { //判断列表的修改次数是否相等。（主要用于多线程时） if (modCount != expectedModCount) { thrownew ConcurrentModificationException();
}
} publicint hashCode() { //调用hashCodeRange()方法，再判断列表有没有修改，如果修改抛出并发修改异常。返回hash值。 int expectedModCount = modCount; int hash = hashCodeRange(0, size);
checkForComodification(expectedModCount); return hash;
} int hashCodeRange(int from, int to) { //如果元素个数大于数组长度，抛出并发修改异常。定义hash初值为1，遍历每个数组元素，以31进制的方式返回hash和（数组元素为null时返回0）。返回hash和就是lisr的hash值。 final Object[] es = elementData; if (to > es.length) { thrownew ConcurrentModificationException();
} int hashCode = 1; for (int i = from; i < to; i++) {
Object e = es[i];
hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
} return hashCode;
} publicboolean remove(Object o) { //定义一个标记found，如果找到一个相等的元素就终止这次循环，但不重新进入循环。即找到第一个相等的元素，调用fastRemove()，并返回true。如果循环没有找到就返回false。
//注意如果o是整型，ArrayList会调用删除指定下标方法。因为它是适合更小范围的。 //迭代器遍历时不能调用remove方法，会引起并发修改异常。 final Object[] es = elementData; finalint size = this.size; int i = 0;
found: { if (o == null) { for (; i < size; i++) if (es[i] == null) break found;
} else { for (; i < size; i++) if (o.equals(es[i])) break found;
} returnfalse;
}
fastRemove(es, i); returntrue;
} privatevoid fastRemove(Object[] es, int i) { //修改次数++，如果不是删除最后一个元素，就复制后面的元素到前面。将最后一个元素赋值为null，将size-1。
modCount++; finalint newSize; if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
} publicvoid clear() { //修改次数++，将元素数组全赋值为null，同时size赋值为0。
modCount++; final Object[] es = elementData; for (int to = size, i = size = 0; i < to; i++)
es[i] = null;
} publicboolean addAll(Collection<? extends E> c) { //修改次数++，判断c转为数组的长度是否为0。如果为0直接返回false。如果数组剩余长度不足集合元素个数，扩容至刚好足够。将数组复制到元素数组汇总，修改size为当前个数，返回true。
Object[] a = c.toArray();
modCount++; int numNew = a.length; if (numNew == 0) returnfalse;
Object[] elementData; finalint s; if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew);
System.arraycopy(a, 0, elementData, s, numNew);
size = s + numNew; returntrue;
} publicboolean addAll(int index, Collection<? extends E> c) { //调用rangeCheckForAdd()，修改次数++，与addAll()重载方法类似，是从index处插入。
rangeCheckForAdd(index);
Object[] a = c.toArray();
modCount++; int numNew = a.length; if (numNew == 0) returnfalse;
Object[] elementData; finalint s; if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew); int numMoved = s - index; if (numMoved > 0)
System.arraycopy(elementData, index,
elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size = s + numNew; returntrue;
} protectedvoid removeRange(int fromIndex, int toIndex) { //如果下界大于上界，抛出数组下标越界异常。否则修改次数++，调用shiftTrailOverGap()方法。 if (fromIndex > toIndex) { thrownew IndexOutOfBoundsException(
outOfBoundsMsg(fromIndex, toIndex));
}
modCount++;
shiftTailOverGap(elementData, fromIndex, toIndex);
}
