java ArrayList

该类相当于vector，但是vector是同步的，而ArrayList是不同步的，说白了就是一个数组，通过数组来当链表使

size isEmpty get set iterator listIterator这些方法都是常数复杂度

{@code add}操作在<i>分摊的常量时间</ i>中运行，也就是说，添加n个元素需要O（n）时间。 所有其他操作都以线性时间运行（粗略地说）

 

初始默认容量10
static final Object[] EMPTY_ELEMENTDATA = {};//用于空实例的共享空数组实例。

static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//用于默认大小的空实例的共享空数组实例。 我们将此与EMPTY_ELEMENTDATA区分开来，以便了解在添加第一个元素时要膨胀多少。

transient Object[] elementData; // non-private to simplify nested class access
存储ArrayList元素的数组缓冲区。 ArrayList的容量是此数组缓冲区的长度。 添加第一个元素时，任何带有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都将扩展为DEFAULT_CAPACITY。//

不用多说的size成员

构造函数 传入容量，如果容量不合法则按默认容量初始化elementData

也可以往构造函数传入collection，那样就会调用参数的toArray()方法，然后判断元素类型和ArrayList的元素类型是否一样，一样就elementData = Arrays.copyOf(elementData, size, Object[].class);
不一样就构造空的elementData

方法trimToSize把大小变成刚刚好能装下现有元素，会递增一次modcount

方法ensureCapacity(int minCapacity)如果elementData的长度比参数长而且里面是非空的且参数比默认容量小，那么递增modcount，调用grow(minCapacity);

不用多说static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

方法Object[] grow(int minCapacity)返回elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
方法Object[] grow() { return grow(size + 1); }

 

方法int newCapacity(int minCapacity)

返回至少与给定最小容量一样大的容量。 如果满足，则返回当前容量增加50％。 除非给定的最小容量大于MAX_ARRAY_SIZE，否则不会返回大于MAX_ARRAY_SIZE的容量。

 

方法static int hugeCapacity(int minCapacity)

参数小于0抛出异常，大于MAX_ARRAY_SIZE返回最大整数，否则返回MAX_ARRAY_SIZE

 

方法boolean contains(Object o) { return indexOf(o) >= 0; }

 

方法int indexOf(Object o) { return indexOfRange(o, 0, size); }

 

方法int indexOfRange(Object o, int start, int end)
初始化对象数组，赋值为elementData；如果对象o是null，那么遍历start到end，找到null就返回下标；
如果不为null，那么遍历start到end，o.equals(es[i])的时候返回下标；
都做不到返回-1

 

方法int lastIndexOf(Object o) { return lastIndexOfRange(o, 0, size); }

 

int lastIndexOfRange(Object o, int start, int end)
从end-1向start遍历，跟indexOfRange差不多

 

Object clone()
用父类的clone方法获得一个ArrayList对象，然后对象的elementData赋值为Arrays.copyOf(elementData, size);
对象的modecount赋值为0，返回对象

 

方法Object[] toArray() { return Arrays.copyOf(elementData, size); }

 

方法<T> T[] toArray(T[] a)
看不懂

 

方法E elementData(int index) { return (E) elementData[index]; }

方法static <E> E elementAt(Object[] es, int index) { return (E) es[index]; }

这两个方法都没怎么检查下标什么合法性之类的

 

方法E get(int index)

先检查合法性，然后调用elementData

 

方法E set(int index, E element)

检查合法性，将对应index替换为element参数，然后返回旧的值

 

方法void add(E e, Object[] elementData, int s)

如果s超出了长度，那么要先自增，然后将下标s的值设为e；最后有一句size = s + 1;看不懂

 

方法boolean add(E e)

递增了modcount，然后add(e, elementData, size);

 

方法void add(int index, E element)

rangeCheckForAdd(index);检查下标合法性，递增modcount；如果已经装满了，将新的elementData赋值为grow();然后System.arraycopy(elementData, index, elementData, index + 1, s - index);将index位置设为参数element，size = s + 1;

 

方法E remove(int index)

检查下标，保存index对应元素，fastRemove(es, index);返回原来的元素

 

方法boolean equals(Object o)

判地址和类型；同样也记录modecount来判断异常；如果对象是ArrayList类，那么调用equalsArrayList((ArrayList<?>) o)

如果对象不是ArrayList类，调用equalsRange((List<?>) o, 0, size);

 

方法boolean equalsRange(List<?> other, int from, int to)

判下标范围，遍历other内元素和elementData元素，用元素的equals方法判断是否相等

 

方法boolean equalsArrayList(ArrayList<?> other)

记录下参数的modcount，记录下size，如果参数的size和this的size相等，并且每个元素都equals，返回true
 

方法void checkForComodification(final int expectedModCount)

如果modcount跟参数不一样抛出异常

 

方法int hashCode()

记录modcount，然后调用int hash = hashCodeRange(0, size);，返回hash

 

方法int hashCodeRange(int from, int to)

判断to跟范围，如果超出了抛出异常，遍历每个元素执行hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());，返回hashcode

 

方法boolean remove(Object o)

如果o是null，那么从头到尾找null，如果不是null，那么从头到尾找equals的，找到之后fastRemove(es, i);

 

方法void fastRemove(Object[] es, int i)

递增modcount；如果i在减少元素后的范围内，那么System.arraycopy(es, i + 1, es, i, newSize - i);将数组最后一个元素设为null

 

方法void clear()

递增modcount；逐个逐个元素设为null，size设为0

 

方法boolean addAll(Collection<? extends E> c)

用c的toArray()方法拿到对象数组，递增modcount， 看对象数组的长度加上后是否会超过，如果会超过调用grow()，然后System.arraycopy(a, 0, elementData, s, numNew);重置长度；就是把c的元素加到现在数组的后面

 

方法boolean addAll(int index, Collection<? extends E> c)

检查合法性，然后先计算是否要增长长度，然后把需要移动的元素调用System.arraycopy(elementData, index, elementData, index + numNew, numMoved);然后把要加的元素调用System.arraycopy(a, 0, elementData, index, numNew);；重置size

 

方法removeRange(int fromIndex, int toIndex)

判断下标，递增modcount，然后shiftTailOverGap(elementData, fromIndex, toIndex);

 

方法void shiftTailOverGap(Object[] es, int lo, int hi)

将hi及以后的元素移动到以lo下标为开头的位置，然后hi最后一个元素后面设为null

 

方法rangeCheckForAdd(int index)

判断下标是否小于0或者大于size

 

方法boolean removeAll(Collection<?> c) { return batchRemove(c, false, 0, size); }

 

方法boolean retainAll(Collection<?> c) { return batchRemove(c, true, 0, size); }