菜鸟谈——java集合之ArrayList

我会带着你远行 2024-02-18 18:47 28阅读 0赞

## java集合框架之ArrayList ##

### 1.ArrayList简介 ###

![这里写图片描述][Image 1]

public class ArrayList<E> extends AbstractList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
 }

Arraylist继承了AbstractList，实现了List。它是一个数组队列，相当于动态数组。提供了add delete set get等功能。

ArrayList实现了RandomAccess接口，提供了随机访问功能。。**下面进一步详解。**

ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

ArrayList实现了java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作是**非线程安全的**。

### 2.ArrayList源码分析 ###

public class ArrayList<E> extends AbstractList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 {
 
 //序列版本号
 private static final long serialVersionUID = 8683452581122892189L;
 //默认初始化容量
 private static final int DEFAULT_CAPACITY = 10;
 //空数组
 private static final Object[] EMPTY_ELEMENTDATA = {};
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 //Object[]类型的数组，它保存了添加到ArrayList中的元素。
 //实际上它是一个动态数组
 transient Object[] elementData; // non-private to simplify nested class access
 //动态数组的实际大小
 private int size;
 //默认构造函数
 public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; //使用空数组初始化
 }
 //initialCapacity是ArrayList的默认容量大小。
 //当由于增加数据导致容量不足时，容量会添加上一个容量的一半。
 public ArrayList(int initialCapacity) {
 if (initialCapacity > 0) {
 this.elementData = new Object[initialCapacity];
 } else if (initialCapacity == 0) {
 this.elementData = EMPTY_ELEMENTDATA;
 } else {
 throw new IllegalArgumentException("Illegal Capacity: "+
 initialCapacity);
 }
 }
 //用collection初始化ArrayList
 public ArrayList(Collection<? extends E> c) {
 elementData = c.toArray();//将collection中的内容转为数组，初始化elementData
 if ((size = elementData.length) != 0) {
 // c.toArray might (incorrectly) not return Object[] (see 6260652)
 if (elementData.getClass() != Object[].class)
 elementData = Arrays.copyOf(elementData, size, Object[].class);
 } else {
 // replace with empty array.
 this.elementData = EMPTY_ELEMENTDATA;
 }
 }
 //重新修整数组容量大小
 public void trimToSize() {
 modCount++;
 //当ArrayList中的元素个数小于elementData数组大小时，重新修整elementData到size大小
 if (size < elementData.length) {
 elementData = (size == 0)
 ? EMPTY_ELEMENTDATA
 : Arrays.copyOf(elementData, size);
 }
 }
 //给数组扩容，该方法是提供给外界调用的，是public的，真正扩容是在下面的private方法中
 public void ensureCapacity(int minCapacity) {
 int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
 // any size if not default element table
 ? 0
 // larger than default for default empty table. It's already
 // supposed to be at default size.
 : DEFAULT_CAPACITY;
 
 if (minCapacity > minExpand) {
 ensureExplicitCapacity(minCapacity);
 }
 }
 
 private void ensureCapacityInternal(int minCapacity) {
 //如果是个空数组
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
 //取minCapacity和10【DEFAULT_CAPACITY】中的较大者
 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 //如果数组已经有数据，则
 ensureExplicitCapacity(minCapacity);
 }
 //确保数组容量大于ArrayList中的元素个数
 private void ensureExplicitCapacity(int minCapacity) {
 modCount++;
 
 // overflow-conscious code
 //如果实际数据容量大于数组容量，就给数组扩容
 if (minCapacity - elementData.length > 0)
 grow(minCapacity);
 }
 
 //分配的最大数组空间
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 //增大数组空间
 private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = elementData.length;
 //oldCapacity >> 1 相当于 oldCapacity 除以2的1次方
 int newCapacity = oldCapacity + (oldCapacity >> 1); //在原来的容量基础上加上 oldCapacity/2
 if (newCapacity - minCapacity < 0)
 newCapacity = minCapacity;//最少保证容量和minCapacity一致
 if (newCapacity - MAX_ARRAY_SIZE > 0)
 newCapacity = hugeCapacity(minCapacity);//最大不能超过最大容量
 // minCapacity is usually close to size, so this is a win:
 elementData = Arrays.copyOf(elementData, newCapacity);
 }
 
 private static int hugeCapacity(int minCapacity) {
 if (minCapacity < 0) // overflow
 throw new OutOfMemoryError();
 return (minCapacity > MAX_ARRAY_SIZE) ?
 Integer.MAX_VALUE :
 MAX_ARRAY_SIZE;
 }
 //返回ArrayList的实际大小
 public int size() {
 return size;
 }
 //判断ArrayList是否为空
 public boolean isEmpty() {
 return size == 0;
 }
 
 //****************************查找操作函数*************************//
 //判断ArrayList是否包含元素o
 public boolean contains(Object o) {
 return indexOf(o) >= 0;
 }
 //正向查找，返回元素的索引值
 public int indexOf(Object o) {
 if (o == null) {
 for (int i = 0; i < size; i++)
 if (elementData[i]==null)
 return i;
 } else {
 for (int i = 0; i < size; i++)
 if (o.equals(elementData[i]))
 return i;
 }
 return -1;
 }
 //反向查找，返回元素的索引值
 public int lastIndexOf(Object o) {
 if (o == null) {
 for (int i = size-1; i >= 0; i--)
 if (elementData[i]==null)
 return i;
 } else {
 for (int i = size-1; i >= 0; i--)
 if (o.equals(elementData[i]))
 return i;
 }
 return -1;
 }
 //克隆函数
 public Object clone() {
 try {
 ArrayList<?> v = (ArrayList<?>) super.clone();
 //将当前ArrayList的全部元素拷贝到V中
 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);
 }
 @SuppressWarnings("unchecked")
 public <T> T[] toArray(T[] a) {
 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;
 }
 
 // Positional Access Operations
 
 @SuppressWarnings("unchecked")
 E elementData(int index) {
 return (E) elementData[index];
 }
 //获取index位置的元素
 public E get(int index) {
 rangeCheck(index);
 return elementData(index);
 }
 //把index位置的值设为element，并返回原来的值
 public E set(int index, E element) {
 rangeCheck(index);
 E oldValue = elementData(index);
 elementData[index] = element;
 return oldValue;
 }
 //将e添加到ArrayList末尾
 public boolean add(E e) {
 ensureCapacityInternal(size + 1); // Increments modCount!!
 elementData[size++] = e;
 return true;
 }
 
 //将e添加到ArrayList中指定的index位置
 public void add(int index, E element) {
 rangeCheckForAdd(index);
 ensureCapacityInternal(size + 1); // Increments modCount!!
 //将index以及index之后的数据复制到index＋1的位置往后，即从index开始向后挪了一位。
 System.arraycopy(elementData, index, elementData, index + 1,
 size - index);
 elementData[index] = element;//然后在index处插入element
 size++;
 }
 //删除ArrayList指定位置的元素
 public E remove(int index) {
 rangeCheck(index);
 modCount++;
 E oldValue = elementData(index);
 int numMoved = size - index - 1;
 if (numMoved > 0){
 //向左挪一位，index位置原来的数据已经被覆盖
 System.arraycopy(elementData, index+1, elementData, index,
 numMoved);
 }
 //多出来的最后一位删除掉
 elementData[--size] = null; // clear to let GC do its work
 return oldValue;
 }
 //删除ArrayList中指定的元素
 public boolean remove(Object o) {
 if (o == null) {
 for (int index = 0; index < size; index++)
 if (elementData[index] == null) {
 fastRemove(index);
 return true;
 }
 } else {
 for (int index = 0; index < size; index++)
 if (o.equals(elementData[index])) {
 fastRemove(index);
 return true;
 }
 }
 return false;
 }
 /*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 * 与上边的public普通删除区别在于，没有进行边界判断以及不返回删除值
 */
 private void fastRemove(int index) {
 modCount++;
 int numMoved = size - index - 1;
 if (numMoved > 0)
 System.arraycopy(elementData, index+1, elementData, index,
 numMoved);
 elementData[--size] = null; // clear to let GC do its work
 }
 //清空ArrayList，将全部元素置为null
 public void clear() {
 modCount++;
 // clear to let GC do its work
 for (int i = 0; i < size; i++)
 elementData[i] = null;
 size = 0;
 }
 
 //将集合C中的所有元素添加到ArrayList中
 public boolean addAll(Collection<? extends E> c) {
 Object[] a = c.toArray();
 int numNew = a.length;
 ensureCapacityInternal(size + numNew); // Increments modCount
 //在原来数组的后面添加C中所有的元素
 System.arraycopy(a, 0, elementData, size, numNew);
 size += numNew;
 return numNew != 0;
 }
 //从index位置开始，将集合C中所有的元素添加到ArrayList中
 public boolean addAll(int index, Collection<? extends E> c) {
 rangeCheckForAdd(index);
 Object[] a = c.toArray();
 int numNew = a.length;
 ensureCapacityInternal(size + numNew); // Increments modCount
 int numMoved = size - index;
 if (numMoved > 0){
 //将index开始向后的所有数据，向后移动numNew个位置，给新插的数据腾出空间
 System.arraycopy(elementData, index, elementData, index + numNew,
 numMoved);
 }
 //将集合a中的数据插到刚刚腾出的位置
 System.arraycopy(a, 0, elementData, index, numNew);
 size += numNew;
 return numNew != 0;
 }
 //删除从fromIndex到toIndex之间的数据，不包括toIndex位置数据
 protected void removeRange(int fromIndex, int toIndex) {
 modCount++;
 int numMoved = size - toIndex;
 System.arraycopy(elementData, toIndex, elementData, fromIndex,
 numMoved);
 
 // clear to let GC do its work
 int newSize = size - (toIndex-fromIndex);
 for (int i = newSize; i < size; i++) {
 elementData[i] = null;
 }
 size = newSize;
 }
 
 //范围检测
 private void rangeCheck(int index) {
 if (index >= size)
 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 }
 //add、addAll中的范围检测
 private void rangeCheckForAdd(int index) {
 if (index > size || index < 0)
 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 }
 /**
 * Constructs an IndexOutOfBoundsException detail message.
 * Of the many possible refactorings of the error handling code,
 * this "outlining" performs best with both server and client VMs.
 */
 private String outOfBoundsMsg(int index) {
 return "Index: "+index+", Size: "+size;
 }
 //删除ArrayList中所有集合C中包含的数据
 public boolean removeAll(Collection<?> c) {
 Objects.requireNonNull(c);
 return batchRemove(c, false);
 }
 
 //删除ArrayList中除了集合C中包含的数据外的其他所有数据
 //取交集
 public boolean retainAll(Collection<?> c) {
 Objects.requireNonNull(c);
 return batchRemove(c, true);
 }
 //批量删除 这里有点难理解。。。。。。
 private boolean batchRemove(Collection<?> c, boolean complement) {
 final Object[] elementData = this.elementData;
 int r = 0, w = 0;
 boolean modified = false;
 try {
 for (; r < size; r++)
 if (c.contains(elementData[r]) == complement)
 elementData[w++] = elementData[r];
 } finally {
 // Preserve behavioral compatibility with AbstractCollection,
 // even if c.contains() throws.
 if (r != size) {
 System.arraycopy(elementData, r,
 elementData, w,
 size - r);
 w += size - r;
 }
 if (w != size) {
 // clear to let GC do its work
 for (int i = w; i < size; i++)
 elementData[i] = null;
 modCount += size - w;
 size = w;
 modified = true;
 }
 }
 return modified;
 }
 
 //java.io.Serializable的写入函数
 //将ArrayList的“容量，所有的元素值”都写入到输出流中
 private void writeObject(java.io.ObjectOutputStream s)
 throws java.io.IOException{
 // Write out element count, and any hidden stuff
 int expectedModCount = modCount;
 s.defaultWriteObject();
 
 // Write out size as capacity for behavioural compatibility with clone()
 //写入数组的容量，保持与clone()的兼容性
 s.writeInt(size);
 
 // Write out all elements in the proper order.
 //写入数组的每一个元素
 for (int i=0; i<size; i++) {
 s.writeObject(elementData[i]);
 }
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 }
 
 //java.io.Serializable的读取函数：根据写入方式读出
 private void readObject(java.io.ObjectInputStream s)
 throws java.io.IOException, ClassNotFoundException {
 elementData = EMPTY_ELEMENTDATA;
 
 // Read in size, and any hidden stuff
 s.defaultReadObject();
 
 // Read in capacity
 s.readInt(); // ignored
 
 if (size > 0) {
 // be like clone(), allocate array based upon size not capacity
 ensureCapacityInternal(size);
 
 Object[] a = elementData;
 // Read in all elements in the proper order.
 for (int i=0; i<size; i++) {
 a[i] = s.readObject();
 }
 }
 }
 
 //*************该部分的方法重写了AbstractList抽象类，基本大同小异***************//
 /**
 * Returns a list iterator over the elements in this list (in proper
 * sequence), starting at the specified position in the list.
 * The specified index indicates the first element that would be
 * returned by an initial call to {@link ListIterator#next next}.
 * An initial call to {@link ListIterator#previous previous} would
 * return the element with the specified index minus one.
 *
 * The returned list iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
 public ListIterator<E> listIterator(int index) {
 if (index < 0 || index > size)
 throw new IndexOutOfBoundsException("Index: "+index);
 return new ListItr(index);
 }
 
 /**
 * Returns a list iterator over the elements in this list (in proper
 * sequence).
 *
 * The returned list iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @see #listIterator(int)
 */
 public ListIterator<E> listIterator() {
 return new ListItr(0);
 }
 
 /**
 * Returns an iterator over the elements in this list in proper sequence.
 *
 * The returned iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @return an iterator over the elements in this list in proper sequence
 */
 public Iterator<E> iterator() {
 return new Itr();
 }
 
 /**
 * An optimized version of AbstractList.Itr
 */
 private class Itr implements Iterator<E> {
 
 int cursor; // index of next element to return
 int lastRet = -1; // index of last element returned; -1 if no such
 int expectedModCount = modCount;
 
 public boolean hasNext() {
 return cursor != size;
 }
 
 @SuppressWarnings("unchecked")
 public E next() {
 checkForComodification();
 int i = cursor;
 if (i >= size)
 throw new NoSuchElementException();
 Object[] elementData = ArrayList.this.elementData;
 if (i >= elementData.length)
 throw new ConcurrentModificationException();
 cursor = i + 1;
 return (E) elementData[lastRet = i];
 }
 
 public void remove() {
 if (lastRet < 0)
 throw new IllegalStateException();
 checkForComodification();
 
 try {
 ArrayList.this.remove(lastRet);
 cursor = lastRet;
 lastRet = -1;
 expectedModCount = modCount;
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 
 @Override
 @SuppressWarnings("unchecked")
 public void forEachRemaining(Consumer<? super E> consumer) {
 Objects.requireNonNull(consumer);
 final int size = ArrayList.this.size;
 int i = cursor;
 if (i >= size) {
 return;
 }
 final Object[] elementData = ArrayList.this.elementData;
 if (i >= elementData.length) {
 throw new ConcurrentModificationException();
 }
 while (i != size && modCount == expectedModCount) {
 consumer.accept((E) elementData[i++]);
 }
 // update once at end of iteration to reduce heap write traffic
 cursor = i;
 lastRet = i - 1;
 checkForComodification();
 }
 
 final void checkForComodification() {
 if (modCount != expectedModCount)
 throw new ConcurrentModificationException();
 }
 }
 
 /**
 * An optimized version of AbstractList.ListItr
 */
 private class ListItr extends Itr implements ListIterator<E> {
 
 ListItr(int index) {
 super();
 cursor = index;
 }
 
 public boolean hasPrevious() {
 return cursor != 0;
 }
 
 public int nextIndex() {
 return cursor;
 }
 
 public int previousIndex() {
 return cursor - 1;
 }
 
 @SuppressWarnings("unchecked")
 public E previous() {
 checkForComodification();
 int i = cursor - 1;
 if (i < 0)
 throw new NoSuchElementException();
 Object[] elementData = ArrayList.this.elementData;
 if (i >= elementData.length)
 throw new ConcurrentModificationException();
 cursor = i;
 return (E) elementData[lastRet = i];
 }
 
 public void set(E e) {
 if (lastRet < 0)
 throw new IllegalStateException();
 checkForComodification();
 
 try {
 ArrayList.this.set(lastRet, e);
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 
 public void add(E e) {
 checkForComodification();
 
 try {
 int i = cursor;
 ArrayList.this.add(i, e);
 cursor = i + 1;
 lastRet = -1;
 expectedModCount = modCount;
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 }
 
 /**
 * Returns a view of the portion of this list between the specified
 * {@code fromIndex}, inclusive, and {@code toIndex}, exclusive. (If
 * {@code fromIndex} and {@code toIndex} are equal, the returned list is
 * empty.) The returned list is backed by this list, so non-structural
 * changes in the returned list are reflected in this list, and vice-versa.
 * The returned list supports all of the optional list operations.
 *
 * This method eliminates the need for explicit range operations (of
 * the sort that commonly exist for arrays). Any operation that expects
 * a list can be used as a range operation by passing a subList view
 * instead of a whole list. For example, the following idiom
 * removes a range of elements from a list:
 * <pre>
 * list.subList(from, to).clear();
 * </pre>
 * Similar idioms may be constructed for {@link #indexOf(Object)} and
 * {@link #lastIndexOf(Object)}, and all of the algorithms in the
 * {@link Collections} class can be applied to a subList.
 *
 * The semantics of the list returned by this method become undefined if
 * the backing list (i.e., this list) is structurally modified in
 * any way other than via the returned list. (Structural modifications are
 * those that change the size of this list, or otherwise perturb it in such
 * a fashion that iterations in progress may yield incorrect results.)
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 * @throws IllegalArgumentException {@inheritDoc}
 */
 public List<E> subList(int fromIndex, int toIndex) {
 subListRangeCheck(fromIndex, toIndex, size);
 return new SubList(this, 0, fromIndex, toIndex);
 }
 
 static void subListRangeCheck(int fromIndex, int toIndex, int size) {
 if (fromIndex < 0)
 throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
 if (toIndex > size)
 throw new IndexOutOfBoundsException("toIndex = " + toIndex);
 if (fromIndex > toIndex)
 throw new IllegalArgumentException("fromIndex(" + fromIndex +
 ") > toIndex(" + toIndex + ")");
 }
 
 private class SubList extends AbstractList<E> implements RandomAccess {
 
 private final AbstractList<E> parent;
 private final int parentOffset;
 private final int offset;
 int size;
 
 SubList(AbstractList<E> parent,
 int offset, int fromIndex, int toIndex) {
 this.parent = parent;
 this.parentOffset = fromIndex;
 this.offset = offset + fromIndex;
 this.size = toIndex - fromIndex;
 this.modCount = ArrayList.this.modCount;
 }
 
 public E set(int index, E e) {
 rangeCheck(index);
 checkForComodification();
 E oldValue = ArrayList.this.elementData(offset + index);
 ArrayList.this.elementData[offset + index] = e;
 return oldValue;
 }
 
 public E get(int index) {
 rangeCheck(index);
 checkForComodification();
 return ArrayList.this.elementData(offset + index);
 }
 
 public int size() {
 checkForComodification();
 return this.size;
 }
 
 public void add(int index, E e) {
 rangeCheckForAdd(index);
 checkForComodification();
 parent.add(parentOffset + index, e);
 this.modCount = parent.modCount;
 this.size++;
 }
 
 public E remove(int index) {
 rangeCheck(index);
 checkForComodification();
 E result = parent.remove(parentOffset + index);
 this.modCount = parent.modCount;
 this.size--;
 return result;
 }
 
 protected void removeRange(int fromIndex, int toIndex) {
 checkForComodification();
 parent.removeRange(parentOffset + fromIndex,
 parentOffset + toIndex);
 this.modCount = parent.modCount;
 this.size -= toIndex - fromIndex;
 }
 
 public boolean addAll(Collection<? extends E> c) {
 return addAll(this.size, c);
 }
 
 public boolean addAll(int index, Collection<? extends E> c) {
 rangeCheckForAdd(index);
 int cSize = c.size();
 if (cSize==0)
 return false;
 
 checkForComodification();
 parent.addAll(parentOffset + index, c);
 this.modCount = parent.modCount;
 this.size += cSize;
 return true;
 }
 
 public Iterator<E> iterator() {
 return listIterator();
 }
 
 public ListIterator<E> listIterator(final int index) {
 checkForComodification();
 rangeCheckForAdd(index);
 final int offset = this.offset;
 
 return new ListIterator<E>() {
 int cursor = index;
 int lastRet = -1;
 int expectedModCount = ArrayList.this.modCount;
 
 public boolean hasNext() {
 return cursor != SubList.this.size;
 }
 
 @SuppressWarnings("unchecked")
 public E next() {
 checkForComodification();
 int i = cursor;
 if (i >= SubList.this.size)
 throw new NoSuchElementException();
 Object[] elementData = ArrayList.this.elementData;
 if (offset + i >= elementData.length)
 throw new ConcurrentModificationException();
 cursor = i + 1;
 return (E) elementData[offset + (lastRet = i)];
 }
 
 public boolean hasPrevious() {
 return cursor != 0;
 }
 
 @SuppressWarnings("unchecked")
 public E previous() {
 checkForComodification();
 int i = cursor - 1;
 if (i < 0)
 throw new NoSuchElementException();
 Object[] elementData = ArrayList.this.elementData;
 if (offset + i >= elementData.length)
 throw new ConcurrentModificationException();
 cursor = i;
 return (E) elementData[offset + (lastRet = i)];
 }
 
 @SuppressWarnings("unchecked")
 public void forEachRemaining(Consumer<? super E> consumer) {
 Objects.requireNonNull(consumer);
 final int size = SubList.this.size;
 int i = cursor;
 if (i >= size) {
 return;
 }
 final Object[] elementData = ArrayList.this.elementData;
 if (offset + i >= elementData.length) {
 throw new ConcurrentModificationException();
 }
 while (i != size && modCount == expectedModCount) {
 consumer.accept((E) elementData[offset + (i++)]);
 }
 // update once at end of iteration to reduce heap write traffic
 lastRet = cursor = i;
 checkForComodification();
 }
 
 public int nextIndex() {
 return cursor;
 }
 
 public int previousIndex() {
 return cursor - 1;
 }
 
 public void remove() {
 if (lastRet < 0)
 throw new IllegalStateException();
 checkForComodification();
 
 try {
 SubList.this.remove(lastRet);
 cursor = lastRet;
 lastRet = -1;
 expectedModCount = ArrayList.this.modCount;
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 
 public void set(E e) {
 if (lastRet < 0)
 throw new IllegalStateException();
 checkForComodification();
 
 try {
 ArrayList.this.set(offset + lastRet, e);
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 
 public void add(E e) {
 checkForComodification();
 
 try {
 int i = cursor;
 SubList.this.add(i, e);
 cursor = i + 1;
 lastRet = -1;
 expectedModCount = ArrayList.this.modCount;
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 
 final void checkForComodification() {
 if (expectedModCount != ArrayList.this.modCount)
 throw new ConcurrentModificationException();
 }
 };
 }
 
 public List<E> subList(int fromIndex, int toIndex) {
 subListRangeCheck(fromIndex, toIndex, size);
 return new SubList(this, offset, fromIndex, toIndex);
 }
 
 private void rangeCheck(int index) {
 if (index < 0 || index >= this.size)
 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 }
 
 private void rangeCheckForAdd(int index) {
 if (index < 0 || index > this.size)
 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 }
 
 private String outOfBoundsMsg(int index) {
 return "Index: "+index+", Size: "+this.size;
 }
 
 private void checkForComodification() {
 if (ArrayList.this.modCount != this.modCount)
 throw new ConcurrentModificationException();
 }
 
 public Spliterator<E> spliterator() {
 checkForComodification();
 return new ArrayListSpliterator<E>(ArrayList.this, offset,
 offset + this.size, this.modCount);
 }
 }
 
 @Override
 public void forEach(Consumer<? super E> action) {
 Objects.requireNonNull(action);
 final int expectedModCount = modCount;
 @SuppressWarnings("unchecked")
 final E[] elementData = (E[]) this.elementData;
 final int size = this.size;
 for (int i=0; modCount == expectedModCount && i < size; i++) {
 action.accept(elementData[i]);
 }
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 }
 
 /**
 * Creates a <a href="Spliterator.html#binding">late-binding</a>
 * and fail-fast {@link Spliterator} over the elements in this
 * list.
 *
 * The {@code Spliterator} reports {@link Spliterator#SIZED},
 * {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
 * Overriding implementations should document the reporting of additional
 * characteristic values.
 *
 * @return a {@code Spliterator} over the elements in this list
 * @since 1.8
 */
 @Override
 public Spliterator<E> spliterator() {
 return new ArrayListSpliterator<>(this, 0, -1, 0);
 }
 
 /** Index-based split-by-two, lazily initialized Spliterator */
 static final class ArrayListSpliterator<E> implements Spliterator<E> {
 
 private final ArrayList<E> list;
 private int index; // current index, modified on advance/split
 private int fence; // -1 until used; then one past last index
 private int expectedModCount; // initialized when fence set
 
 /** Create new spliterator covering the given range */
 ArrayListSpliterator(ArrayList<E> list, int origin, int fence,
 int expectedModCount) {
 this.list = list; // OK if null unless traversed
 this.index = origin;
 this.fence = fence;
 this.expectedModCount = expectedModCount;
 }
 
 private int getFence() { // initialize fence to size on first use
 int hi; // (a specialized variant appears in method forEach)
 ArrayList<E> lst;
 if ((hi = fence) < 0) {
 if ((lst = list) == null)
 hi = fence = 0;
 else {
 expectedModCount = lst.modCount;
 hi = fence = lst.size;
 }
 }
 return hi;
 }
 
 public ArrayListSpliterator<E> trySplit() {
 int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
 return (lo >= mid) ? null : // divide range in half unless too small
 new ArrayListSpliterator<E>(list, lo, index = mid,
 expectedModCount);
 }
 
 public boolean tryAdvance(Consumer<? super E> action) {
 if (action == null)
 throw new NullPointerException();
 int hi = getFence(), i = index;
 if (i < hi) {
 index = i + 1;
 @SuppressWarnings("unchecked") E e = (E)list.elementData[i];
 action.accept(e);
 if (list.modCount != expectedModCount)
 throw new ConcurrentModificationException();
 return true;
 }
 return false;
 }
 
 public void forEachRemaining(Consumer<? super E> action) {
 int i, hi, mc; // hoist accesses and checks from loop
 ArrayList<E> lst; Object[] a;
 if (action == null)
 throw new NullPointerException();
 if ((lst = list) != null && (a = lst.elementData) != null) {
 if ((hi = fence) < 0) {
 mc = lst.modCount;
 hi = lst.size;
 }
 else
 mc = expectedModCount;
 if ((i = index) >= 0 && (index = hi) <= a.length) {
 for (; i < hi; ++i) {
 @SuppressWarnings("unchecked") E e = (E) a[i];
 action.accept(e);
 }
 if (lst.modCount == mc)
 return;
 }
 }
 throw new ConcurrentModificationException();
 }
 
 public long estimateSize() {
 return (long) (getFence() - index);
 }
 
 public int characteristics() {
 return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
 }
 }
 
 @Override
 public boolean removeIf(Predicate<? super E> filter) {
 Objects.requireNonNull(filter);
 // figure out which elements are to be removed
 // any exception thrown from the filter predicate at this stage
 // will leave the collection unmodified
 int removeCount = 0;
 final BitSet removeSet = new BitSet(size);
 final int expectedModCount = modCount;
 final int size = this.size;
 for (int i=0; modCount == expectedModCount && i < size; i++) {
 @SuppressWarnings("unchecked")
 final E element = (E) elementData[i];
 if (filter.test(element)) {
 removeSet.set(i);
 removeCount++;
 }
 }
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 
 // shift surviving elements left over the spaces left by removed elements
 final boolean anyToRemove = removeCount > 0;
 if (anyToRemove) {
 final int newSize = size - removeCount;
 for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
 i = removeSet.nextClearBit(i);
 elementData[j] = elementData[i];
 }
 for (int k=newSize; k < size; k++) {
 elementData[k] = null; // Let gc do its work
 }
 this.size = newSize;
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 modCount++;
 }
 
 return anyToRemove;
 }
 
 @Override
 @SuppressWarnings("unchecked")
 public void replaceAll(UnaryOperator<E> operator) {
 Objects.requireNonNull(operator);
 final int expectedModCount = modCount;
 final int size = this.size;
 for (int i=0; modCount == expectedModCount && i < size; i++) {
 elementData[i] = operator.apply((E) elementData[i]);
 }
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 modCount++;
 }
 
 @Override
 @SuppressWarnings("unchecked")
 public void sort(Comparator<? super E> c) {
 final int expectedModCount = modCount;
 Arrays.sort((E[]) elementData, 0, size, c);
 if (modCount != expectedModCount) {
 throw new ConcurrentModificationException();
 }
 modCount++;
 }
 }

### 3.ArrayList遍历方式 ###

ArrayList支持三种遍历方式

1）迭代器遍历

2）索引值遍历

3）for循环遍历

ArrayList<String> arrayList = new ArrayList<String>();
 arrayList.add("a");
 arrayList.add("b");
 arrayList.add("c");
 arrayList.add("d");
 arrayList.add("e");
 arrayList.add("f");
 Iterator<String> it = arrayList.iterator();
 while(it.hasNext()){
 System.out.print(it.next() + " ");
 }
 System.out.println();
 for(String s:arrayList){
 System.out.print(s + " ");
 }
 System.out.println();
 for(int i = 0; i < arrayList.size(); i++){
 System.out.print(arrayList.get(i) + " ");
 }

### 4.toArray()异常问题 ###

ArrayList中提供了2个toArray()

public Object[] toArray() {
 return Arrays.copyOf(elementData, size);
 }
 
 @SuppressWarnings("unchecked")
 public <T> T[] toArray(T[] a) {
 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;
 }

其中调用toArray会抛出java.lang.ClassCastException异常，但是调用`<T> T[] toArray(T[] a)`会正常返回T\[\]。

toArray会抛出异常是因为toArray()返回的是Object\[\]数组，将Object\[\]数组转为其他类型（Integer\[\]）则会抛出java.lang.ClassCastException异常，因为**java不支持向下转型。。**

## 补充知识 ##

### Arrays.copyOf() ###

<table> 
 <thead> 
 <tr> 
 <th align="right"><code>static boolean[]</code></th> 
 <th align="left">copyOf(boolean[] original, int newLength) 复制指定的数组，截取或用 <code>false</code> 填充（如有必要），以使副本具有指定的长度。</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="right"><code>static byte[]</code></td> 
 <td align="left">copyOf(byte[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static char[]</code></td> 
 <td align="left">copyOf(char[] original, int newLength) 复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static double[]</code></td> 
 <td align="left">copyOf(double[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static float[]</code></td> 
 <td align="left">copyOf(float[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static int[]</code></td> 
 <td align="left">copyOf(int[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static long[]</code></td> 
 <td align="left">copyOf(long[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static short[]</code></td> 
 <td align="left">copyOf(short[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static &lt;T&gt; T[]</code></td> 
 <td align="left">copyOf(T[] original, int newLength) 复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 <tr> 
 <td align="right"><code>static &lt;T,U&gt; T[]</code></td> 
 <td align="left">copyOf(U[] original, int newLength, Class newType) 复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。</td> 
 </tr> 
 </tbody> 
</table>

### arraycopy() ###

public static void arraycopy(Object src, int srcPos,
            Object dest,
            int destPos,
            int length)
    //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length 参数。源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。

如果参数 src 和 dest 引用相同的数组对象，则复制的执行过程就好像首先将 srcPos 到 srcPos+length-1 位置的组件复制到一个带有 length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的 destPos 到 destPos+length-1 位置一样。

If 如果 dest 为 null，则抛出 NullPointerException 异常。

如果 src 为 null, 则抛出 NullPointerException 异常，并且不会修改目标数组。

否则，只要下列任何情况为真，则抛出 ArrayStoreException 异常并且不会修改目标数组：

src 参数指的是非数组对象。  
dest 参数指的是非数组对象。  
src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。  
src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。  
src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。  
否则，只要下列任何情况为真，则抛出 IndexOutOfBoundsException 异常，并且不会修改目标数组：

srcPos 参数为负。  
destPos 参数为负。  
length 参数为负。  
srcPos+length 大于 src.length，即源数组的长度。  
destPos+length 大于 dest.length，即目标数组的长度。  
否则，如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型，则抛出 ArrayStoreException 异常。在这种情况下，将 k 设置为比长度小的最小非负整数，这样就无法将 src\[srcPos+k\] 转换为目标数组的组件类型；当抛出异常时，从 srcPos 到 srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到 destPos+k-1 位置，而目标数组中的其他位置不会被修改。（因为已经详细说明过的那些限制，只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。）

参数：  
src - 源数组。  
srcPos - 源数组中的起始位置。  
dest - 目标数组。  
destPos - 目标数据中的起始位置。  
length - 要复制的数组元素的数量。  
抛出：  
IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。  
ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。  
NullPointerException - 如果 src 或 dest 为 null。

[Image 1]: