1
/**
2
 * Default initial capacity.
3
 */
4
private static final int DEFAULT_CAPACITY = 10;
5
/**
6
 * Shared empty array instance used for empty instances.
7
 */
8
private static final Object[] EMPTY_ELEMENTDATA = {};
9
/**
10
 * The array buffer into which the elements of the ArrayList are stored.
11
 * The capacity of the ArrayList is the length of this array buffer. Any
12
 * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
13
 * DEFAULT_CAPACITY when the first element is added.
14
 */
15
private transient Object[] elementData;
16
/**
17
 * The size of the ArrayList (the number of elements it contains).
18
 *
19
 * @serial
20
 */
21
private int size;

1
/**
2
 * Constructs an empty list with the specified initial capacity.
3
 *
4
 * @param  initialCapacity  the initial capacity of the list
5
 * @throws IllegalArgumentException if the specified initial capacity
6
 *         is negative
7
 */
8
public ArrayList(int initialCapacity) {
9
  super();
10
  if (initialCapacity < 0)
11
      throw new IllegalArgumentException("Illegal Capacity: "+
12
                                         initialCapacity);
13
  this.elementData = new Object[initialCapacity];
14
}
15
/**
16
 * Constructs an empty list with an initial capacity of ten.
17
 */
18
public ArrayList() {
19
  super();
20
  this.elementData = EMPTY_ELEMENTDATA;
21
}
22
/**
23
 * Constructs a list containing the elements of the specified
24
 * collection, in the order they are returned by the collection's
25
 * iterator.
26
 *
27
 * @param c the collection whose elements are to be placed into this list
28
 * @throws NullPointerException if the specified collection is null
29
 */
30
public ArrayList(Collection<? extends E> c) {
31
  elementData = c.toArray();
32
  size = elementData.length;
33
  // c.toArray might (incorrectly) not return Object[] (see 6260652)
34
  if (elementData.getClass() != Object[].class)
35
      elementData = Arrays.copyOf(elementData, size, Object[].class);
36
}

1
/**
2
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
3
 * necessary, to ensure that it can hold at least the number of elements
4
 * specified by the minimum capacity argument.
5
 *
6
 * @param   minCapacity   the desired minimum capacity
7
 */
8
public void ensureCapacity(int minCapacity) {
9
  int minExpand = (elementData != EMPTY_ELEMENTDATA)
10
      // any size if real element table
11
      ? 0
12
      // larger than default for empty table. It's already supposed to be
13
      // at default size.
14
      : DEFAULT_CAPACITY;
15
  if (minCapacity > minExpand) {
16
      ensureExplicitCapacity(minCapacity);
17
  }
18
}
19
private void ensureCapacityInternal(int minCapacity) {
20
  if (elementData == EMPTY_ELEMENTDATA) {
21
      minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
22
  }
23
  ensureExplicitCapacity(minCapacity);
24
}
25
private void ensureExplicitCapacity(int minCapacity) {
26
  modCount++;
27
  // overflow-conscious code
28
  if (minCapacity - elementData.length > 0)
29
      grow(minCapacity);
30
}
31
/**
32
 * The maximum size of array to allocate.
33
 * Some VMs reserve some header words in an array.
34
 * Attempts to allocate larger arrays may result in
35
 * OutOfMemoryError: Requested array size exceeds VM limit
36
 */
37
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
38
/**
39
 * Increases the capacity to ensure that it can hold at least the
40
 * number of elements specified by the minimum capacity argument.
41
 *
42
 * @param minCapacity the desired minimum capacity
43
 */
44
private void grow(int minCapacity) {
45
  // overflow-conscious code
46
  int oldCapacity = elementData.length;
47
  int newCapacity = oldCapacity + (oldCapacity >> 1);
48
  if (newCapacity - minCapacity < 0)
49
      newCapacity = minCapacity;
50
  if (newCapacity - MAX_ARRAY_SIZE > 0)
51
      newCapacity = hugeCapacity(minCapacity);
52
  // minCapacity is usually close to size, so this is a win:
53
  elementData = Arrays.copyOf(elementData, newCapacity);
54
}
55
private static int hugeCapacity(int minCapacity) {
56
  if (minCapacity < 0) // overflow
57
      throw new OutOfMemoryError();
58
  return (minCapacity > MAX_ARRAY_SIZE) ?
59
      Integer.MAX_VALUE :
60
      MAX_ARRAY_SIZE;
61
}

1
/**
2
 * Appends the specified element to the end of this list.
3
 *
4
 * @param e element to be appended to this list
5
 * @return <tt>true</tt> (as specified by {@link Collection#add})
6
 */
7
public boolean add(E e) {
8
  ensureCapacityInternal(size + 1);  // Increments modCount!!
9
  elementData[size++] = e;
10
  return true;
11
}

1
/**
2
 * Inserts the specified element at the specified position in this
3
 * list. Shifts the element currently at that position (if any) and
4
 * any subsequent elements to the right (adds one to their indices).
5
 *
6
 * @param index index at which the specified element is to be inserted
7
 * @param element element to be inserted
8
 * @throws IndexOutOfBoundsException {@inheritDoc}
9
 */
10
public void add(int index, E element) {
11
  rangeCheckForAdd(index);
12
  ensureCapacityInternal(size + 1);  // Increments modCount!!
13
  System.arraycopy(elementData, index, elementData, index + 1,
14
                   size - index);
15
  elementData[index] = element;
16
  size++;
17
}

1
/**
2
 * Removes the element at the specified position in this list.
3
 * Shifts any subsequent elements to the left (subtracts one from their
4
 * indices).
5
 *
6
 * @param index the index of the element to be removed
7
 * @return the element that was removed from the list
8
 * @throws IndexOutOfBoundsException {@inheritDoc}
9
 */
10
public E remove(int index) {
11
  rangeCheck(index);
12
  modCount++;
13
  E oldValue = elementData(index);
14
  int numMoved = size - index - 1;
15
  if (numMoved > 0)
16
      System.arraycopy(elementData, index+1, elementData, index,
17
                       numMoved);
18
  elementData[--size] = null; // clear to let GC do its work
19
  return oldValue;
20
}

1
/**
2
 * 复制数组
3
 * 本地方法，基于C实现，性能更高
4
 *
5
 * @param      src      原数组
6
 * @param      srcPos   原数据的起始位置
7
 * @param      dest     目标数组
8
 * @param      destPos  目标数组的起始位置
9
 * @param      length   要copy的数组长度
10
 */
11
public static native void arraycopy(Object src,  int srcPos,
12
                                    Object dest, int destPos,
13
                                    int length);

1
private void grow(int minCapacity) {
2
  // overflow-conscious code
3
  int oldCapacity = elementData.length;
4
  int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
5
                                   capacityIncrement : oldCapacity);
6
  if (newCapacity - minCapacity < 0)
7
      newCapacity = minCapacity;
8
  if (newCapacity - MAX_ARRAY_SIZE > 0)
9
      newCapacity = hugeCapacity(minCapacity);
10
  elementData = Arrays.copyOf(elementData, newCapacity);
11
}

1
transient int size = 0;
2
/**
3
 * Pointer to first node.
4
 * Invariant: (first == null && last == null) ||
5
 *            (first.prev == null && first.item != null)
6
 */
7
transient Node<E> first;
8
/**
9
 * Pointer to last node.
10
 * Invariant: (first == null && last == null) ||
11
 *            (last.next == null && last.item != null)
12
 */
13
transient Node<E> last;
14

15
private static class Node<E> {
16
  E item;
17
  Node<E> next;
18
  Node<E> prev
19
  Node(Node<E> prev, E element, Node<E> next) {
20
    this.item = element;
21
    this.next = next;
22
    this.prev = prev;
23
  }
24
}

1
/**
2
 * Appends the specified element to the end of this list.
3
 *
4
 * <p>This method is equivalent to {@link #add}.
5
 *
6
 * @param e the element to add
7
 */
8
public void addLast(E e) {
9
  linkLast(e);
10
}
11

12
public boolean add(E e) {
13
  linkLast(e);
14
  return true;
15
}
16

17
void linkLast(E e) {
18
  final Node<E> l = last;
19
  final Node<E> newNode = new Node<>(l, e, null);
20
  last = newNode;
21
  if (l == null)
22
      first = newNode;
23
  else
24
      l.next = newNode;
25
  size++;
26
  modCount++;
27
}

1
/**
2
 * Inserts the specified element at the specified position in this list.
3
 * Shifts the element currently at that position (if any) and any
4
 * subsequent elements to the right (adds one to their indices).
5
 *
6
 * @param index index at which the specified element is to be inserted
7
 * @param element element to be inserted
8
 * @throws IndexOutOfBoundsException {@inheritDoc}
9
 */
10
public void add(int index, E element) {
11
  checkPositionIndex(index);
12
  if (index == size)
13
      linkLast(element);
14
  else
15
      linkBefore(element, node(index));
16
}
17
 /**
18
  * Returns the (non-null) Node at the specified element index.
19
  * Trick：由于链表是双向的，可以从开始往后找，也可以从结尾往前找
20
  *        具体朝那个方向找取决于条件index < (size >> 1)，也即是index是靠近前端还是后端
21
  */
22
Node<E> node(int index) {
23
  // assert isElementIndex(index);
24
  if (index < (size >> 1)) {
25
    Node<E> x = first;
26
    for (int i = 0; i < index; i++)
27
        x = x.next;
28
    return x;
29
  } else {
30
      Node<E> x = last;
31
    for (int i = size - 1; i > index; i--)
32
        x = x.prev;
33
    return x;
34
  }
35
}

1
/**
2
 * Removes the first occurrence of the specified element from this list,
3
 * if it is present.  If this list does not contain the element, it is
4
 * unchanged.  More formally, removes the element with the lowest index
5
 * {@code i} such that
6
 * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
7
 * (if such an element exists).  Returns {@code true} if this list
8
 * contained the specified element (or equivalently, if this list
9
 * changed as a result of the call).
10
 *
11
 * @param o element to be removed from this list, if present
12
 * @return {@code true} if this list contained the specified element
13
 */
14
public boolean remove(Object o) {
15
  if (o == null) {
16
    for (Node<E> x = first; x != null; x = x.next) {
17
      if (x.item == null) {
18
        unlink(x);
19
        return true;
20
      }
21
    }
22
  } else {
23
    for (Node<E> x = first; x != null; x = x.next) {
24
      if (o.equals(x.item)) {
25
        unlink(x);
26
        return true;
27
      }
28
    }
29
  }
30
  return false;
31
}
32
/**
33
 * Unlinks non-null node x.
34
 */
35
E unlink(Node<E> x) {
36
  // assert x != null;
37
  final E element = x.item;
38
  final Node<E> next = x.next;
39
  final Node<E> prev = x.prev;
40
  if (prev == null) {
41
    first = next;
42
  } else {
43
    prev.next = next;
44
    x.prev = null;
45
  }
46
  if (next == null) {
47
    last = prev;
48
  } else {
49
    next.prev = prev;
50
    x.next = null;
51
  }
52
  x.item = null;
53
  size--;
54
  modCount++;
55
  return element;
56
}

1
/**
2
 * Removes all of the elements from this list.
3
 * The list will be empty after this call returns.
4
 */
5
public void clear() {
6
  // Clearing all of the links between nodes is "unnecessary", but:
7
  // - helps a generational GC if the discarded nodes inhabit
8
  //   more than one generation
9
  // - is sure to free memory even if there is a reachable Iterator
10
  for (Node<E> x = first; x != null; ) {
11
      Node<E> next = x.next;
12
      x.item = null;
13
      x.next = null;
14
      x.prev = null;
15
      x = next;
16
  }
17
  first = last = null;
18
  size = 0;
19
  modCount++;
20
}

1
/**
2
 * 容量(capacity)
3
 * 必须是2的幂 而且小于2的30次方，默认为16
4
 */
5
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
6
static final int MAXIMUM_CAPACITY = 1 << 30;
7
/**
8
 * 加载因子(loadFactor)
9
 * 默认为0.75，越大哈希冲突几率越大(链表更长)
10
 * 另外0.75作为默认值时,与容量相乘时绝对会得到整数
11
 */
12
static final float DEFAULT_LOAD_FACTOR = 0.75f;
13
final float loadFactor;
14
/**
15
 * 主干数组(table)
16
 */
17
static final Entry<?,?>[] EMPTY_TABLE = {};
18
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
19
/**
20
 * 键值对个数(size)
21
 */
22
transient int size;
23
/**
24
 * 扩容阈值(capacity * loadFactor)
25
 * 如果 table == EMPTY_TABLE 那么是initialCapacity
26
 * size大于此值时，会进行扩容
27
 */
28
int threshold;

1
public HashMap(int initialCapacity, float loadFactor) {
2
  if (initialCapacity < 0)
3
      throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
4
  if (initialCapacity > MAXIMUM_CAPACITY)
5
      initialCapacity = MAXIMUM_CAPACITY;
6
  if (loadFactor <= 0 || Float.isNaN(loadFactor))
7
      throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
8
  this.loadFactor = loadFactor;
9
  threshold = initialCapacity;
10
  init();
11
}
12

13
public HashMap(int initialCapacity) {
14
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
15
}
16
public HashMap() {
17
  this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
18
}

1
public V put(K key, V value) {
2
  if (table == EMPTY_TABLE)
3
    inflateTable(threshold);
4
  //other code...
5
}
6

7
/**
8
 * 扩容table
9
 */
10
private void inflateTable(int toSize) {
11
  // Find a power of 2 >= toSize
12
  int capacity = roundUpToPowerOf2(toSize);
13
  threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
14
  table = new Entry[capacity];
15
  initHashSeedAsNeeded(capacity);
16
}
17

18
private static int roundUpToPowerOf2(int number) {
19
  // assert number >= 0 : "number must be non-negative";
20
  return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY
21
    : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
22
}
23

24
//Integer.highestOneBit
25
//这返回了一个与i最接近的2的幂
26
//jdk1.8中hashmap已将此方法直接称为tableSizeFor
27
public static int highestOneBit(int i) {
28
  // HD, Figure 3-1
29
  i |= (i >>  1);
30
  i |= (i >>  2);
31
  i |= (i >>  4);
32
  i |= (i >>  8);
33
  i |= (i >> 16);
34
  return i - (i >>> 1);
35
}

1
/**
2
 * Returns the entry associated with the specified key in the
3
 * HashMap.  Returns null if the HashMap contains no mapping
4
 * for the key.
5
 */
6
final Entry<K,V> getEntry(Object key) {
7
  if (size == 0) {
8
    return null;
9
  }
10
  int hash = (key == null) ? 0 : hash(key);
11
  ////依次遍历冲突链表中的每个entry
12
  for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
13
    Object k;
14
    //比较hash和key
15
    if (e.hash == hash &&
16
        ((k = e.key) == key || (key != null && key.equals(k))))
17
        return e;
18
  }
19
  return null;
20
}
21

22
/**
23
 * 根据hash值求下标
24
 * length为主干数组长度，也就是必然是2的幂
25
 * 二进制为 00000100 00001000 00010000
26
 * 减一就是 00000011 00000111 00001111（作为低位掩码）
27
 * 再进行位与&运算，hash值所有超过底位掩码的1都会被舍弃
28
 * 这样，返回值范围就固定在了length-1
29
 */
30
static int indexFor(int h, int length) {
31
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
32
    return h & (length-1);
33
}
34

35
static class Entry<K,V> implements Map.Entry<K,V> {
36
  final K key;
37
  V value;
38
  Entry<K,V> next;
39
  int hash;
40
  //more...
41
}

1
/**
2
 * Adds a new entry with the specified key, value and hash code to
3
 * the specified bucket.  It is the responsibility of this
4
 * method to resize the table if appropriate.
5
 *
6
 * Subclass overrides this to alter the behavior of put method.
7
 */
8
void addEntry(int hash, K key, V value, int bucketIndex) {
9
  //size超过阈值并且所要插入的下标不为空，则会进行扩容
10
  if ((size >= threshold) && (null != table[bucketIndex])) {
11
      resize(2 * table.length);
12
      hash = (null != key) ? hash(key) : 0;
13
      bucketIndex = indexFor(hash, table.length);
14
  }
15
  createEntry(hash, key, value, bucketIndex);
16
}
17
/**
18
 * Like addEntry except that this version is used when creating entries
19
 * as part of Map construction or "pseudo-construction" (cloning,
20
 * deserialization).  This version needn't worry about resizing the table.
21
 *
22
 * Subclass overrides this to alter the behavior of HashMap(Map),
23
 * clone, and readObject.
24
 */
25
void createEntry(int hash, K key, V value, int bucketIndex) {
26
    Entry<K,V> e = table[bucketIndex];
27
    table[bucketIndex] = new Entry<>(hash, key, value, e);
28
    size++;
29
}

1
void transfer(Entry[] newTable, boolean rehash) {
2
  int newCapacity = newTable.length;
3
  for (Entry<K,V> e : table) {
4
    //e为空时循环结束
5
    while(null != e) {
6
      Entry<K,V> next = e.next; // 记录oldhash表中e.next
7
      if (rehash) {
8
          e.hash = null == e.key ? 0 : hash(e.key);
9
      }
10
      int i = indexFor(e.hash, newCapacity); // rehash计算出数组的位置(hash表中桶的位置)
11
      // 成环的代码主要是在这三行代码
12
      // 首先插入是从头开始插入的
13
      e.next = newTable[i]; // e要插入链表的头部， 所以要先将e.next指向new hash表中的第一个元素
14
      newTable[i] = e; // 将e放入到new hash表的头部
15
      e = next; // 转移e到下一个节点， 继续循环下去
16
    }
17
  }
18
}

1
public Hashtable(int initialCapacity, float loadFactor) {
2
    if (initialCapacity < 0)
3
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
4
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
5
        throw new IllegalArgumentException("Illegal Load: " + loadFactor);
6
    if (initialCapacity==0)
7
        initialCapacity = 1;
8
    this.loadFactor = loadFactor;
9
    table = new Entry[initialCapacity];
10
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
11
    initHashSeedAsNeeded(initialCapacity);
12
}
13

14
public Hashtable(int initialCapacity) {
15
    this(initialCapacity, 0.75f);
16
}
17

18
//默认的initialCapacity是11
19
public Hashtable() {
20
    this(11, 0.75f);
21
}

1
/**
2
 * Increases the capacity of and internally reorganizes this
3
 * hashtable, in order to accommodate and access its entries more
4
 * efficiently.  This method is called automatically when the
5
 * number of keys in the hashtable exceeds this hashtable's capacity
6
 * and load factor.
7
 */
8
protected void rehash() {
9
  int oldCapacity = table.length;
10
  Entry<K,V>[] oldMap = table;
11
  // overflow-conscious code
12
  int newCapacity = (oldCapacity << 1) + 1;
13
  if (newCapacity - MAX_ARRAY_SIZE > 0) {
14
    if (oldCapacity == MAX_ARRAY_SIZE)
15
      // Keep running with MAX_ARRAY_SIZE buckets
16
      return;
17
    newCapacity = MAX_ARRAY_SIZE;
18
  }
19
  Entry<K,V>[] newMap = new Entry[newCapacity];
20
  modCount++;
21
  threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
22
  boolean rehash = initHashSeedAsNeeded(newCapacity);
23
  table = newMap;
24
  for (int i = oldCapacity ; i-- > 0 ;) {
25
    for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
26
      Entry<K,V> e = old;
27
      old = old.next;
28
      if (rehash) {
29
        e.hash = hash(e.key);
30
      }
31
      int index = (e.hash & 0x7FFFFFFF) % newCapacity;
32
      e.next = newMap[index];
33
      newMap[index] = e;
34
    }
35
  }
36
}

1
/**
2
 * 并发级别(concurrencyLevel)，实际上就是Segment的数量，默认16
3
 * 理论上，可以同时支持 16 个线程并发写，只要它们的操作分布在不同的 Segment 上。
4
 */
5
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
6
/**
7
 * segments[i]中的table的容量
8
 */
9
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
10
/**
11
 * Mask value for indexing into segments. The upper bits of a
12
 * key's hash code are used to choose the segment.
13
 */
14
final int segmentMask;
15
/**
16
 * Shift value for indexing within segments.
17
 */
18
final int segmentShift;
19
/**
20
 * final修饰的Segment数组，不可扩容
21
 */
22
final Segment<K,V>[] segments;
23

24
/**
25
 * 哈希表的特殊版本。这个ReentrantLock的子类只是为了简化一些锁并避免单独的构造。
26
 */
27
static final class Segment<K,V> extends ReentrantLock implements Serializable {
28
  transient volatile HashEntry<K,V>[] table;
29
  //more...
30
}
31

32
static final class HashEntry<K,V> {
33
  final int hash;
34
  final K key;
35
  volatile V value;
36
  volatile HashEntry<K,V> next;
37
  //more...
38
}

1
public Iterator<E> iterator() {
2
  return new Itr();
3
}
4

5
/**
6
 * An optimized version of AbstractList.Itr
7
 */
8
private class Itr implements Iterator<E> {
9
  int cursor;       // 遍历过程中的【即将遍历】的元素的索引
10
  int lastRet = -1; // 记录【刚刚遍历】的元素的索引，不存在上一个时，为-1
11
  int expectedModCount = modCount; //fail-fast判断的关键变量，
12
                                   //初始值为ArrayList中的modCount（操作数）
13
                                   //请看最下方的checkForComodification方法
14

15
  public boolean hasNext() {
16
    return cursor != size;
17
  }
18

19
  @SuppressWarnings("unchecked")
20
  public E next() {
21
    checkForComodification();
22
    int i = cursor;
23
    if (i >= size)
24
        throw new NoSuchElementException();
25
    Object[] elementData = ArrayList.this.elementData;
26
    if (i >= elementData.length)
27
        throw new ConcurrentModificationException();
28
    cursor = i + 1;
29
    return (E) elementData[lastRet = i];
30
  }
31

32
  public void remove() {
33
    if (lastRet < 0)
34
        throw new IllegalStateException();
35
    checkForComodification();
36
    try {
37
        ArrayList.this.remove(lastRet);
38
        cursor = lastRet;
39
        lastRet = -1;
40
        expectedModCount = modCount;
41
    } catch (IndexOutOfBoundsException ex) {
42
        throw new ConcurrentModificationException();
43
    }
44
  }
45

46
  @Override
47
  @SuppressWarnings("unchecked")
48
  public void forEachRemaining(Consumer<? super E> consumer) {
49
    Objects.requireNonNull(consumer);
50
    final int size = ArrayList.this.size;
51
    int i = cursor;
52
    if (i >= size) {
53
        return;
54
    }
55
    final Object[] elementData = ArrayList.this.elementData;
56
    if (i >= elementData.length) {
57
        throw new ConcurrentModificationException();
58
    }
59
    while (i != size && modCount == expectedModCount) {
60
        consumer.accept((E) elementData[i++]);
61
    }
62
    // update once at end of iteration to reduce heap write traffic
63
    cursor = i;
64
    lastRet = i - 1;
65
    checkForComodification();
66
  }
67

68
  /**
69
   * expectedModCount只在遍历开始的时候被赋予了modCount的值
70
   * 如果有程序修改了modCount，就会抛出 并发修改异常
71
   */
72
  final void checkForComodification() {
73
    if (modCount != expectedModCount)
74
      throw new ConcurrentModificationException();
75
  }
76
}