diff --git a/second/week_01/36/ArrayList.md b/second/week_01/36/ArrayList.md
new file mode 100644
index 0000000000000000000000000000000000000000..455391c005e4088bd1d52fac916984bdf5d8390d
--- /dev/null
+++ b/second/week_01/36/ArrayList.md
@@ -0,0 +1,1002 @@
+
+# ArrayList -- 查找快。
+
+
+# 1.继承关系：
+``` java
+   public class ArrayList<E> extends AbstractList<E>
+          implements List<E>, RandomAccess, Cloneable, java.io.Serializable
+```          
+    
+# 2. 属性：
+``` java
+    // 默认容量
+    private static final int DEFAULT_CAPACITY = 10;
+
+    // 空数组，第一次存入元素时更新大小为 DEFAULT_CAPACITY
+    private static final Object[] EMPTY_ELEMENTDATA = {};
+
+    // 空数组，默认设定大小为 DEFAULT_CAPACITY
+    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
+
+    // 添加第一个元素时扩展到默认容量，transient：关闭序列化
+    transient Object[] elementData;
+
+    // 数组中元素个数
+    private int size;
+```    
+    
+# 3.方法：
+
+``` java
+   // 构造函数：initialCapacity 集合容量，该值为0时设定集合为 EMPTY_ELEMENTDATA，否则取其正值。
+   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);
+        }
+    }
+  
+   // 无参构造：默认设定大小为 DEFAULT_CAPACITY
+   public ArrayList() {
+         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
+   }
+   
+   // 构造函数：拷贝已知集合，若参数为空集合则使用 EMPTY_ELEMENTDATA。
+   public ArrayList(Collection<? extends E> c) {
+           elementData = c.toArray();
+           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++;
+          if (size < elementData.length) {
+              elementData = (size == 0)
+                ? EMPTY_ELEMENTDATA
+                : Arrays.copyOf(elementData, size);
+          }
+      }
+      
+   // 增加此实例的容量，minCapacity 所需的最小容量
+   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 = Math.max(DEFAULT_CAPACITY, minCapacity);
+       }
+       ensureExplicitCapacity(minCapacity);
+   }
+
+   private void ensureExplicitCapacity(int minCapacity) {
+       modCount++;
+       // overflow-conscious code
+       if (minCapacity - elementData.length > 0)
+           grow(minCapacity);
+   }
+
+   // 数组最大容量（分配过大容量可能会导致 OOM 异常，因为超过了虚拟机限制）
+   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+   // 增加容量到可以容纳 minCapacity 个元素。
+   private void grow(int minCapacity) {
+       // overflow-conscious code
+       int oldCapacity = elementData.length;
+       int newCapacity = oldCapacity + (oldCapacity >> 1);
+       if (newCapacity - minCapacity < 0)
+           newCapacity = 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;
+   }
+   
+   // 返回集合元素个数
+   public int size() {
+       return size;
+   }
+
+   // 检查是否为空
+   public boolean isEmpty() {
+       return size == 0;
+   }
+
+   // 检查是否存在元素： o 
+   public boolean contains(Object o) {
+       return indexOf(o) >= 0;
+   }
+   
+   // 返回指定元素第一次出现的索引，无则返回 -1 。
+   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;
+   }
+   
+   // 返回指定元素最后一次出现的索引，无则返回 -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;
+   }
+   
+   // 浅clone，不会复制元素本身。
+   public Object clone() {
+       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);
+   }
+
+   // 拷贝原集合元素到指定数组。
+   @SuppressWarnings("unchecked")
+   public <T> T[] toArray(T[] a) {
+       if (a.length < size)
+           // 建一个 a 类型的新数组, 并填充当前集合的元素到其中。
+           return (T[]) Arrays.copyOf(elementData, size, a.getClass());
+       System.arraycopy(elementData, 0, a, 0, size);
+       if (a.length > size)
+           a[size] = null;
+       return a;
+   }
+
+   // 返回对应索引位的元素   
+   @SuppressWarnings("unchecked")
+   E elementData(int index) {
+       return (E) elementData[index];
+   }
+   
+   // 返回对应索引位的元素，提供对外访问，调用上一方法。 
+   public E get(int index) {
+       rangeCheck(index);
+       return elementData(index);
+   }
+   
+   // 替换对应索引位的元素
+   public E set(int index, E element) {
+       rangeCheck(index);
+
+       E oldValue = elementData(index);
+       elementData[index] = element;
+       return oldValue;
+   }
+   
+   // 于末尾新增指定元素
+   public boolean add(E e) {
+       ensureCapacityInternal(size + 1);  // Increments modCount!!
+       elementData[size++] = e;
+       return true;
+   }
+   
+   // 指定索引位插入式新增
+   public void add(int index, E element) {
+       rangeCheckForAdd(index);
+
+       ensureCapacityInternal(size + 1);  // Increments modCount!!
+       System.arraycopy(elementData, index, elementData, index + 1,
+                        size - index);
+       elementData[index] = element;
+       size++;
+   }
+   
+   // 移除对应索引位元素
+   public E remove(int index) {
+       rangeCheck(index);
+
+       modCount++;
+       E oldValue = elementData(index);
+
+       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
+
+       return oldValue;
+   }
+   
+   // 删除第一个匹配指定元素的元素，若不存在匹配元素则不变。
+   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 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
+   }
+   
+   // 清空集合
+   public void clear() {
+       modCount++;
+
+       // clear to let GC do its work
+       for (int i = 0; i < size; i++)
+           elementData[i] = null;
+
+       size = 0;
+   }
+   
+   // 追加指定非空集合所有元素到本集合末尾
+   public boolean addAll(Collection<? extends E> c) {
+       Object[] a = c.toArray();
+       int numNew = a.length;
+       ensureCapacityInternal(size + numNew);  // Increments modCount
+       System.arraycopy(a, 0, elementData, size, numNew);
+       size += numNew;
+       return numNew != 0;
+   }
+   
+   // 从指定位置开始插入指定非空集合中的所有元素
+   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)
+           System.arraycopy(elementData, index, elementData, index + numNew,
+                            numMoved);
+
+       System.arraycopy(a, 0, elementData, index, numNew);
+       size += numNew;
+       return numNew != 0;
+   }
+   
+   // 删除介于指定索引位之间的元素
+   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使用的 rangeCheck 版本
+   private void rangeCheckForAdd(int index) {
+       if (index > size || index < 0)
+           throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+   }
+   
+   // 构造索引越界（下标越界）的返回信息内容：索引值 + 集合总容量大小。
+   private String outOfBoundsMsg(int index) {
+       return "Index: "+index+", Size: "+size;
+   }
+
+   // 删除指定集合中的所有元素
+   public boolean removeAll(Collection<?> c) {
+       Objects.requireNonNull(c);
+       return batchRemove(c, false);
+   }
+   
+   // 仅保留指定集合中的元素，删除其余元素。
+   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;
+   }
+   
+   // 保存到流，即：序列化。
+   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()
+       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();
+       }
+   }
+   
+   // 从流重组为集合，即：反序列化。
+   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();
+           }
+       }
+   }
+   
+   // 返回从指定索引位开始的迭代器
+   public ListIterator<E> listIterator(int index) {
+       if (index < 0 || index > size)
+           throw new IndexOutOfBoundsException("Index: "+index);
+       return new ListItr(index);
+   }
+   
+   // 以适当的顺序，返回包含此集合所有元素的集合迭代器。
+   public ListIterator<E> listIterator() {
+       return new ListItr(0);
+   }
+   
+   // 以适当的顺序，返回包含此集合所有元素的迭代器。
+   public Iterator<E> iterator() {
+       return new Itr();
+   }
+   
+   // 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();
+       }
+   }
+   
+   // 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();
+           }
+       }
+   }
+   
+   // 返回子集合，前闭后开。fromIndex = toIndex 时返回空集合。
+   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();
+       }
+   }
+   
+   // 创建一个拆分器，@since 1.8。
+   @Override
+   public Spliterator<E> spliterator() {
+       return new ArrayListSpliterator<>(this, 0, -1, 0);
+   }
+
+   // 延迟初始化的拆分器。
+   static final class ArrayListSpliterator<E> implements Spliterator<E> {
+
+       // 如果集合结构是不变的，没有CRUD操作，则用 Arrays.spliterator 实现拆分. 
+       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;
+       }
+   }
+   
+   // Predicate 函数式编程，参见个人博客 ：https://blog.csdn.net/jiangyu1013/article/details/103500724 。
+   @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;
+   }
+
+   // Predicate 函数式编程，参见个人博客 ：https://blog.csdn.net/jiangyu1013/article/details/103500724
+   @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++;
+   }
+```  
\ No newline at end of file
diff --git a/second/week_01/36/HashMap.md b/second/week_01/36/HashMap.md
new file mode 100644
index 0000000000000000000000000000000000000000..c0b559b6270bc99fd6e192dd0fbab4d277d60f4d
--- /dev/null
+++ b/second/week_01/36/HashMap.md
@@ -0,0 +1,1851 @@
+
+# HashMap -- 查快 + 增删快。
+
+##### 以下4行出自;https://mp.weixin.qq.com/s?__biz=Mzg2ODA0ODM0Nw==&mid=2247483711&idx=3&sn=f0743c914e26695eb9c0d4cb0cab5e99&scene=21#wechat_redirect
+##### 在Java中，HashMap的实现采用了（数组 + 链表 + 红黑树）的复杂结构，数组的一个元素又称作桶。
+##### 在添加元素时，会根据hash值算出元素在数组中的位置，如果该位置没有元素，则直接把元素放置在此处，如果该位置有元素了，则把元素以链表的形式放置在链表的尾部。
+##### 当一个链表的元素个数达到一定的数量（且数组的长度达到一定的长度）后，则把链表转化为红黑树，从而提高效率。
+##### 数组的查询效率为O(1)，链表的查询效率是O(k)，红黑树的查询效率是O(log k)，k为桶中的元素个数，所以当元素数量非常多的时候，转化为红黑树能极大地提高效率。
+
+
+# 1.继承关系：
+``` java
+   public class HashMap<K,V> extends AbstractMap<K,V>
+      implements Map<K,V>, Cloneable, Serializable {
+```          
+    
+    
+# 2. 属性：
+``` java
+    // 默认初始容量：16（必须是 2 的幂，即 2 的 n 次方）
+    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 左移 4位，数值则为乘以2的4次方，即：16。
+
+    // 最大容量为 2 的 30 次方。
+    static final int MAXIMUM_CAPACITY = 1 << 30;
+
+    // 默认的装载因子(当容量占比大于这个值时，则扩容)
+    static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+    // 树化阈值。桶中元素 >=8 则树化。
+    static final int TREEIFY_THRESHOLD = 8;
+
+    // 树转化为链表的阈值。桶中的元素个数 <= 6。
+    static final int UNTREEIFY_THRESHOLD = 6;
+
+    // 以下4行注释出自学号20的同学：
+    // 哈希表的最小树形化容量
+    // 当哈希表中的容量大于这个值时，表中的桶才能进行树形化
+    // 否则桶内元素太多时会扩容，而不是树形化
+    // 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
+    static final int MIN_TREEIFY_CAPACITY = 64;
+```    
+    
+# 3.方法：
+
+``` java
+   // 
+   static class Node<K,V> implements Map.Entry<K,V> {
+       final int hash;
+       final K key;
+       V value;
+       Node<K,V> next;
+
+       Node(int hash, K key, V value, Node<K,V> next) {
+           this.hash = hash;
+           this.key = key;
+           this.value = value;
+           this.next = next;
+       }
+
+       public final K getKey()        { return key; }
+       public final V getValue()      { return value; }
+       public final String toString() { return key + "=" + value; }
+
+       public final int hashCode() {
+           return Objects.hashCode(key) ^ Objects.hashCode(value);
+       }
+
+       public final V setValue(V newValue) {
+           V oldValue = value;
+           value = newValue;
+           return oldValue;
+       }
+
+       public final boolean equals(Object o) {
+           if (o == this)
+               return true;
+           if (o instanceof Map.Entry) {
+               Map.Entry<?,?> e = (Map.Entry<?,?>)o;
+               if (Objects.equals(key, e.getKey()) &&
+                   Objects.equals(value, e.getValue()))
+                   return true;
+           }
+           return false;
+       }
+   }
+
+   /* ---------------- Static utilities -------------- */
+
+   // 计算key.hashCode（）并将（xor）高位散列扩展到低位。因为表使用两个掩蔽的能力，所以仅在当前掩蔽之上的位上变化的散列集总是会发生冲突。
+   //（在已知的例子中，有一组浮点键在小表中保存连续的整数）因此我们应用了一种转换，将高位的影响向下传播。比特扩展的速度、实用性和质量之间存在权衡。
+   // 因为许多常见的散列集已经被合理地分配了（所以不受益于扩展），而且由于我们使用树来处理容器中的大量冲突，所以我们只是以最便宜的方式异或一些移位的位来减少系统损失，
+   // 以及合并由于表边界而在索引计算中永远不会使用的最高位的影响。
+   static final int hash(Object key) {
+       int h;
+       return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
+   }
+
+   // 如果x的类的形式为“Class C implements Comparable<C>”，则返回x的类，否则返回null。
+   static Class<?> comparableClassFor(Object x) {
+       if (x instanceof Comparable) {
+           Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
+           if ((c = x.getClass()) == String.class) // bypass checks
+               return c;
+           if ((ts = c.getGenericInterfaces()) != null) {
+               for (int i = 0; i < ts.length; ++i) {
+                   if (((t = ts[i]) instanceof ParameterizedType) &&
+                       ((p = (ParameterizedType)t).getRawType() ==
+                        Comparable.class) &&
+                       (as = p.getActualTypeArguments()) != null &&
+                       as.length == 1 && as[0] == c) // type arg is c
+                       return c;
+               }
+           }
+       }
+       return null;
+   }
+
+   // 如果x与kc（k的筛选可比类）匹配，则返回k.compareTo（x），否则返回0 。
+   @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
+   static int compareComparables(Class<?> kc, Object k, Object x) {
+       return (x == null || x.getClass() != kc ? 0 :
+               ((Comparable)k).compareTo(x));
+   }
+
+   // 返回给定目标容量的两个大小的幂。
+   static final int tableSizeFor(int cap) {
+       int n = cap - 1;
+       n |= n >>> 1;
+       n |= n >>> 2;
+       n |= n >>> 4;
+       n |= n >>> 8;
+       n |= n >>> 16;
+       return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
+   }
+
+   /* ---------------- Fields -------------- */
+
+   // 表，在首次使用时初始化，并根据需要调整大小。分配时，长度总是2的幂。（在某些操作中，我们还允许长度为零，以允许当前不需要的引导机制。）
+   transient Node<K,V>[] table;
+
+   // 保存缓存的entrySet（）。注意，AbstractMap字段用于keySet（）和values（）。
+   transient Set<Map.Entry<K,V>> entrySet;
+
+   // 元素个数
+   transient int size;
+
+   // 修改次数
+   transient int modCount;
+
+   //需要调整大小的极限值（容量*装载因子）
+   int threshold;
+
+   // 装载因子
+   final float loadFactor;
+
+   /* ---------------- Public operations -------------- */
+
+   // 构造，指定初始容量和负载因子。
+   public HashMap(int initialCapacity, float loadFactor) {
+       if (initialCapacity < 0)
+           throw new IllegalArgumentException("Illegal initial capacity: " +
+                                              initialCapacity);
+       if (initialCapacity > MAXIMUM_CAPACITY)
+           initialCapacity = MAXIMUM_CAPACITY;
+       if (loadFactor <= 0 || Float.isNaN(loadFactor))
+           throw new IllegalArgumentException("Illegal load factor: " +
+                                              loadFactor);
+       this.loadFactor = loadFactor;
+       this.threshold = tableSizeFor(initialCapacity);
+   }
+
+   // 构造 。 
+   public HashMap(int initialCapacity) {
+       this(initialCapacity, DEFAULT_LOAD_FACTOR);
+   }
+
+   // 构造 。 
+   public HashMap() {
+       this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
+   }
+
+   // 构造 。 
+   public HashMap(Map<? extends K, ? extends V> m) {
+       this.loadFactor = DEFAULT_LOAD_FACTOR;
+       putMapEntries(m, false);
+   }
+
+   // 实现Map.putAll and Map constructor 。
+   final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
+       int s = m.size();
+       if (s > 0) {
+           if (table == null) { // pre-size
+               float ft = ((float)s / loadFactor) + 1.0F;
+               int t = ((ft < (float)MAXIMUM_CAPACITY) ?
+                        (int)ft : MAXIMUM_CAPACITY);
+               if (t > threshold)
+                   threshold = tableSizeFor(t);
+           }
+           else if (s > threshold)
+               resize();
+           for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
+               K key = e.getKey();
+               V value = e.getValue();
+               putVal(hash(key), key, value, false, evict);
+           }
+       }
+   }
+
+   // 查 map 元素个数。
+   public int size() {
+       return size;
+   }
+
+   // 检查 map 是否为空。
+   public boolean isEmpty() {
+       return size == 0;
+   }
+
+   // 根据 key 查值。
+   public V get(Object key) {
+       Node<K,V> e;
+       return (e = getNode(hash(key), key)) == null ? null : e.value;
+   }
+
+   // 实现Map.get。
+   final Node<K,V> getNode(int hash, Object key) {
+       Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
+       if ((tab = table) != null && (n = tab.length) > 0 &&
+           (first = tab[(n - 1) & hash]) != null) {
+           if (first.hash == hash && // always check first node
+               ((k = first.key) == key || (key != null && key.equals(k))))
+               return first;
+           if ((e = first.next) != null) {
+               if (first instanceof TreeNode)
+                   return ((TreeNode<K,V>)first).getTreeNode(hash, key);
+               do {
+                   if (e.hash == hash &&
+                       ((k = e.key) == key || (key != null && key.equals(k))))
+                       return e;
+               } while ((e = e.next) != null);
+           }
+       }
+       return null;
+   }
+
+   // 查 key 是否存在。
+   public boolean containsKey(Object key) {
+       return getNode(hash(key), key) != null;
+   }
+
+   // 新增。
+   public V put(K key, V value) {
+       return putVal(hash(key), key, value, false, true);
+   }
+
+   // 实现Map.put和相关方法。
+   final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
+                  boolean evict) {
+       Node<K,V>[] tab; Node<K,V> p; int n, i;
+       if ((tab = table) == null || (n = tab.length) == 0)
+           n = (tab = resize()).length;
+       if ((p = tab[i = (n - 1) & hash]) == null)
+           tab[i] = newNode(hash, key, value, null);
+       else {
+           Node<K,V> e; K k;
+           if (p.hash == hash &&
+               ((k = p.key) == key || (key != null && key.equals(k))))
+               e = p;
+           else if (p instanceof TreeNode)
+               e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
+           else {
+               for (int binCount = 0; ; ++binCount) {
+                   if ((e = p.next) == null) {
+                       p.next = newNode(hash, key, value, null);
+                       if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                           treeifyBin(tab, hash);
+                       break;
+                   }
+                   if (e.hash == hash &&
+                       ((k = e.key) == key || (key != null && key.equals(k))))
+                       break;
+                   p = e;
+               }
+           }
+           if (e != null) { // existing mapping for key
+               V oldValue = e.value;
+               if (!onlyIfAbsent || oldValue == null)
+                   e.value = value;
+               afterNodeAccess(e);
+               return oldValue;
+           }
+       }
+       ++modCount;
+       if (++size > threshold)
+           resize();
+       afterNodeInsertion(evict);
+       return null;
+   }
+
+   // 初始化。
+   final Node<K,V>[] resize() {
+       Node<K,V>[] oldTab = table;
+       int oldCap = (oldTab == null) ? 0 : oldTab.length;
+       int oldThr = threshold;
+       int newCap, newThr = 0;
+       if (oldCap > 0) {
+           if (oldCap >= MAXIMUM_CAPACITY) {
+               threshold = Integer.MAX_VALUE;
+               return oldTab;
+           }
+           else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
+                    oldCap >= DEFAULT_INITIAL_CAPACITY)
+               newThr = oldThr << 1; // double threshold
+       }
+       else if (oldThr > 0) // initial capacity was placed in threshold
+           newCap = oldThr;
+       else {               // zero initial threshold signifies using defaults
+           newCap = DEFAULT_INITIAL_CAPACITY;
+           newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
+       }
+       if (newThr == 0) {
+           float ft = (float)newCap * loadFactor;
+           newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
+                     (int)ft : Integer.MAX_VALUE);
+       }
+       threshold = newThr;
+       @SuppressWarnings({"rawtypes","unchecked"})
+           Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
+       table = newTab;
+       if (oldTab != null) {
+           for (int j = 0; j < oldCap; ++j) {
+               Node<K,V> e;
+               if ((e = oldTab[j]) != null) {
+                   oldTab[j] = null;
+                   if (e.next == null)
+                       newTab[e.hash & (newCap - 1)] = e;
+                   else if (e instanceof TreeNode)
+                       ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
+                   else { // preserve order
+                       Node<K,V> loHead = null, loTail = null;
+                       Node<K,V> hiHead = null, hiTail = null;
+                       Node<K,V> next;
+                       do {
+                           next = e.next;
+                           if ((e.hash & oldCap) == 0) {
+                               if (loTail == null)
+                                   loHead = e;
+                               else
+                                   loTail.next = e;
+                               loTail = e;
+                           }
+                           else {
+                               if (hiTail == null)
+                                   hiHead = e;
+                               else
+                                   hiTail.next = e;
+                               hiTail = e;
+                           }
+                       } while ((e = next) != null);
+                       if (loTail != null) {
+                           loTail.next = null;
+                           newTab[j] = loHead;
+                       }
+                       if (hiTail != null) {
+                           hiTail.next = null;
+                           newTab[j + oldCap] = hiHead;
+                       }
+                   }
+               }
+           }
+       }
+       return newTab;
+   }
+
+   // 替换给定哈希的索引处bin中的所有链接节点，除非表太小，否则将改为调整大小。
+   final void treeifyBin(Node<K,V>[] tab, int hash) {
+       int n, index; Node<K,V> e;
+       if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
+           resize();
+       else if ((e = tab[index = (n - 1) & hash]) != null) {
+           TreeNode<K,V> hd = null, tl = null;
+           do {
+               TreeNode<K,V> p = replacementTreeNode(e, null);
+               if (tl == null)
+                   hd = p;
+               else {
+                   p.prev = tl;
+                   tl.next = p;
+               }
+               tl = p;
+           } while ((e = e.next) != null);
+           if ((tab[index] = hd) != null)
+               hd.treeify(tab);
+       }
+   }
+
+   // 新增指定集合
+   public void putAll(Map<? extends K, ? extends V> m) {
+       putMapEntries(m, true);
+   }
+
+   // 根据键删除值。
+   public V remove(Object key) {
+       Node<K,V> e;
+       return (e = removeNode(hash(key), key, null, false, true)) == null ?
+           null : e.value;
+   }
+
+   // 实现Map.remove和相关方法。
+   final Node<K,V> removeNode(int hash, Object key, Object value,
+                              boolean matchValue, boolean movable) {
+       Node<K,V>[] tab; Node<K,V> p; int n, index;
+       if ((tab = table) != null && (n = tab.length) > 0 &&
+           (p = tab[index = (n - 1) & hash]) != null) {
+           Node<K,V> node = null, e; K k; V v;
+           if (p.hash == hash &&
+               ((k = p.key) == key || (key != null && key.equals(k))))
+               node = p;
+           else if ((e = p.next) != null) {
+               if (p instanceof TreeNode)
+                   node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
+               else {
+                   do {
+                       if (e.hash == hash &&
+                           ((k = e.key) == key ||
+                            (key != null && key.equals(k)))) {
+                           node = e;
+                           break;
+                       }
+                       p = e;
+                   } while ((e = e.next) != null);
+               }
+           }
+           if (node != null && (!matchValue || (v = node.value) == value ||
+                                (value != null && value.equals(v)))) {
+               if (node instanceof TreeNode)
+                   ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
+               else if (node == p)
+                   tab[index] = node.next;
+               else
+                   p.next = node.next;
+               ++modCount;
+               --size;
+               afterNodeRemoval(node);
+               return node;
+           }
+       }
+       return null;
+   }
+
+   // 清空所有元素。
+   public void clear() {
+       Node<K,V>[] tab;
+       modCount++;
+       if ((tab = table) != null && size > 0) {
+           size = 0;
+           for (int i = 0; i < tab.length; ++i)
+               tab[i] = null;
+       }
+   }
+
+   // 检查指定元素是否存在。
+   public boolean containsValue(Object value) {
+       Node<K,V>[] tab; V v;
+       if ((tab = table) != null && size > 0) {
+           for (int i = 0; i < tab.length; ++i) {
+               for (Node<K,V> e = tab[i]; e != null; e = e.next) {
+                   if ((v = e.value) == value ||
+                       (value != null && value.equals(v)))
+                       return true;
+               }
+           }
+       }
+       return false;
+   }
+
+   // 查所有的键。
+   public Set<K> keySet() {
+       Set<K> ks;
+       return (ks = keySet) == null ? (keySet = new KeySet()) : ks;
+   }
+
+   final class KeySet extends AbstractSet<K> {
+       public final int size()                 { return size; }
+       public final void clear()               { HashMap.this.clear(); }
+       public final Iterator<K> iterator()     { return new KeyIterator(); }
+       public final boolean contains(Object o) { return containsKey(o); }
+       public final boolean remove(Object key) {
+           return removeNode(hash(key), key, null, false, true) != null;
+       }
+       public final Spliterator<K> spliterator() {
+           return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
+       }
+       public final void forEach(Consumer<? super K> action) {
+           Node<K,V>[] tab;
+           if (action == null)
+               throw new NullPointerException();
+           if (size > 0 && (tab = table) != null) {
+               int mc = modCount;
+               for (int i = 0; i < tab.length; ++i) {
+                   for (Node<K,V> e = tab[i]; e != null; e = e.next)
+                       action.accept(e.key);
+               }
+               if (modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+   }
+
+   // 查所有的值。
+   public Collection<V> values() {
+       Collection<V> vs;
+       return (vs = values) == null ? (values = new Values()) : vs;
+   }
+
+   final class Values extends AbstractCollection<V> {
+       public final int size()                 { return size; }
+       public final void clear()               { HashMap.this.clear(); }
+       public final Iterator<V> iterator()     { return new ValueIterator(); }
+       public final boolean contains(Object o) { return containsValue(o); }
+       public final Spliterator<V> spliterator() {
+           return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
+       }
+       public final void forEach(Consumer<? super V> action) {
+           Node<K,V>[] tab;
+           if (action == null)
+               throw new NullPointerException();
+           if (size > 0 && (tab = table) != null) {
+               int mc = modCount;
+               for (int i = 0; i < tab.length; ++i) {
+                   for (Node<K,V> e = tab[i]; e != null; e = e.next)
+                       action.accept(e.value);
+               }
+               if (modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+   }
+
+   // 返回此映射中包含的映射关系的 Set 视图。 Map.Entry表示映射关系。entrySet()：迭代后可以e.getKey()，e.getValue()取key和value。返回的是Entry接口。
+   public Set<Map.Entry<K,V>> entrySet() {
+       Set<Map.Entry<K,V>> es;
+       return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
+   }
+
+   final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
+       public final int size()                 { return size; }
+       public final void clear()               { HashMap.this.clear(); }
+       public final Iterator<Map.Entry<K,V>> iterator() {
+           return new EntryIterator();
+       }
+       public final boolean contains(Object o) {
+           if (!(o instanceof Map.Entry))
+               return false;
+           Map.Entry<?,?> e = (Map.Entry<?,?>) o;
+           Object key = e.getKey();
+           Node<K,V> candidate = getNode(hash(key), key);
+           return candidate != null && candidate.equals(e);
+       }
+       public final boolean remove(Object o) {
+           if (o instanceof Map.Entry) {
+               Map.Entry<?,?> e = (Map.Entry<?,?>) o;
+               Object key = e.getKey();
+               Object value = e.getValue();
+               return removeNode(hash(key), key, value, true, true) != null;
+           }
+           return false;
+       }
+       public final Spliterator<Map.Entry<K,V>> spliterator() {
+           return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
+       }
+       public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
+           Node<K,V>[] tab;
+           if (action == null)
+               throw new NullPointerException();
+           if (size > 0 && (tab = table) != null) {
+               int mc = modCount;
+               for (int i = 0; i < tab.length; ++i) {
+                   for (Node<K,V> e = tab[i]; e != null; e = e.next)
+                       action.accept(e);
+               }
+               if (modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+   }
+
+   // Overrides of JDK8 Map extension methods 
+
+   @Override
+   public V getOrDefault(Object key, V defaultValue) {
+       Node<K,V> e;
+       return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
+   }
+
+   @Override
+   public V putIfAbsent(K key, V value) {
+       return putVal(hash(key), key, value, true, true);
+   }
+
+   @Override
+   public boolean remove(Object key, Object value) {
+       return removeNode(hash(key), key, value, true, true) != null;
+   }
+
+   @Override
+   public boolean replace(K key, V oldValue, V newValue) {
+       Node<K,V> e; V v;
+       if ((e = getNode(hash(key), key)) != null &&
+           ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
+           e.value = newValue;
+           afterNodeAccess(e);
+           return true;
+       }
+       return false;
+   }
+
+   @Override
+   public V replace(K key, V value) {
+       Node<K,V> e;
+       if ((e = getNode(hash(key), key)) != null) {
+           V oldValue = e.value;
+           e.value = value;
+           afterNodeAccess(e);
+           return oldValue;
+       }
+       return null;
+   }
+
+   @Override
+   public V computeIfAbsent(K key,
+                            Function<? super K, ? extends V> mappingFunction) {
+       if (mappingFunction == null)
+           throw new NullPointerException();
+       int hash = hash(key);
+       Node<K,V>[] tab; Node<K,V> first; int n, i;
+       int binCount = 0;
+       TreeNode<K,V> t = null;
+       Node<K,V> old = null;
+       if (size > threshold || (tab = table) == null ||
+           (n = tab.length) == 0)
+           n = (tab = resize()).length;
+       if ((first = tab[i = (n - 1) & hash]) != null) {
+           if (first instanceof TreeNode)
+               old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
+           else {
+               Node<K,V> e = first; K k;
+               do {
+                   if (e.hash == hash &&
+                       ((k = e.key) == key || (key != null && key.equals(k)))) {
+                       old = e;
+                       break;
+                   }
+                   ++binCount;
+               } while ((e = e.next) != null);
+           }
+           V oldValue;
+           if (old != null && (oldValue = old.value) != null) {
+               afterNodeAccess(old);
+               return oldValue;
+           }
+       }
+       V v = mappingFunction.apply(key);
+       if (v == null) {
+           return null;
+       } else if (old != null) {
+           old.value = v;
+           afterNodeAccess(old);
+           return v;
+       }
+       else if (t != null)
+           t.putTreeVal(this, tab, hash, key, v);
+       else {
+           tab[i] = newNode(hash, key, v, first);
+           if (binCount >= TREEIFY_THRESHOLD - 1)
+               treeifyBin(tab, hash);
+       }
+       ++modCount;
+       ++size;
+       afterNodeInsertion(true);
+       return v;
+   }
+
+   public V computeIfPresent(K key,
+                             BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+       if (remappingFunction == null)
+           throw new NullPointerException();
+       Node<K,V> e; V oldValue;
+       int hash = hash(key);
+       if ((e = getNode(hash, key)) != null &&
+           (oldValue = e.value) != null) {
+           V v = remappingFunction.apply(key, oldValue);
+           if (v != null) {
+               e.value = v;
+               afterNodeAccess(e);
+               return v;
+           }
+           else
+               removeNode(hash, key, null, false, true);
+       }
+       return null;
+   }
+
+   @Override
+   public V compute(K key,
+                    BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+       if (remappingFunction == null)
+           throw new NullPointerException();
+       int hash = hash(key);
+       Node<K,V>[] tab; Node<K,V> first; int n, i;
+       int binCount = 0;
+       TreeNode<K,V> t = null;
+       Node<K,V> old = null;
+       if (size > threshold || (tab = table) == null ||
+           (n = tab.length) == 0)
+           n = (tab = resize()).length;
+       if ((first = tab[i = (n - 1) & hash]) != null) {
+           if (first instanceof TreeNode)
+               old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
+           else {
+               Node<K,V> e = first; K k;
+               do {
+                   if (e.hash == hash &&
+                       ((k = e.key) == key || (key != null && key.equals(k)))) {
+                       old = e;
+                       break;
+                   }
+                   ++binCount;
+               } while ((e = e.next) != null);
+           }
+       }
+       V oldValue = (old == null) ? null : old.value;
+       V v = remappingFunction.apply(key, oldValue);
+       if (old != null) {
+           if (v != null) {
+               old.value = v;
+               afterNodeAccess(old);
+           }
+           else
+               removeNode(hash, key, null, false, true);
+       }
+       else if (v != null) {
+           if (t != null)
+               t.putTreeVal(this, tab, hash, key, v);
+           else {
+               tab[i] = newNode(hash, key, v, first);
+               if (binCount >= TREEIFY_THRESHOLD - 1)
+                   treeifyBin(tab, hash);
+           }
+           ++modCount;
+           ++size;
+           afterNodeInsertion(true);
+       }
+       return v;
+   }
+
+   @Override
+   public V merge(K key, V value,
+                  BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+       if (value == null)
+           throw new NullPointerException();
+       if (remappingFunction == null)
+           throw new NullPointerException();
+       int hash = hash(key);
+       Node<K,V>[] tab; Node<K,V> first; int n, i;
+       int binCount = 0;
+       TreeNode<K,V> t = null;
+       Node<K,V> old = null;
+       if (size > threshold || (tab = table) == null ||
+           (n = tab.length) == 0)
+           n = (tab = resize()).length;
+       if ((first = tab[i = (n - 1) & hash]) != null) {
+           if (first instanceof TreeNode)
+               old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
+           else {
+               Node<K,V> e = first; K k;
+               do {
+                   if (e.hash == hash &&
+                       ((k = e.key) == key || (key != null && key.equals(k)))) {
+                       old = e;
+                       break;
+                   }
+                   ++binCount;
+               } while ((e = e.next) != null);
+           }
+       }
+       if (old != null) {
+           V v;
+           if (old.value != null)
+               v = remappingFunction.apply(old.value, value);
+           else
+               v = value;
+           if (v != null) {
+               old.value = v;
+               afterNodeAccess(old);
+           }
+           else
+               removeNode(hash, key, null, false, true);
+           return v;
+       }
+       if (value != null) {
+           if (t != null)
+               t.putTreeVal(this, tab, hash, key, value);
+           else {
+               tab[i] = newNode(hash, key, value, first);
+               if (binCount >= TREEIFY_THRESHOLD - 1)
+                   treeifyBin(tab, hash);
+           }
+           ++modCount;
+           ++size;
+           afterNodeInsertion(true);
+       }
+       return value;
+   }
+
+   @Override
+   public void forEach(BiConsumer<? super K, ? super V> action) {
+       Node<K,V>[] tab;
+       if (action == null)
+           throw new NullPointerException();
+       if (size > 0 && (tab = table) != null) {
+           int mc = modCount;
+           for (int i = 0; i < tab.length; ++i) {
+               for (Node<K,V> e = tab[i]; e != null; e = e.next)
+                   action.accept(e.key, e.value);
+           }
+           if (modCount != mc)
+               throw new ConcurrentModificationException();
+       }
+   }
+
+   @Override
+   public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+       Node<K,V>[] tab;
+       if (function == null)
+           throw new NullPointerException();
+       if (size > 0 && (tab = table) != null) {
+           int mc = modCount;
+           for (int i = 0; i < tab.length; ++i) {
+               for (Node<K,V> e = tab[i]; e != null; e = e.next) {
+                   e.value = function.apply(e.key, e.value);
+               }
+           }
+           if (modCount != mc)
+               throw new ConcurrentModificationException();
+       }
+   }
+
+   /* ------------------------------------------------------------ */
+   // Cloning and serialization
+
+   // 浅clone 。 
+   @SuppressWarnings("unchecked")
+   @Override
+   public Object clone() {
+       HashMap<K,V> result;
+       try {
+           result = (HashMap<K,V>)super.clone();
+       } catch (CloneNotSupportedException e) {
+           // this shouldn't happen, since we are Cloneable
+           throw new InternalError(e);
+       }
+       result.reinitialize();
+       result.putMapEntries(this, false);
+       return result;
+   }
+
+   // 序列化哈希集时也使用这些方法。
+   final float loadFactor() { return loadFactor; }
+   final int capacity() {
+       return (table != null) ? table.length :
+           (threshold > 0) ? threshold :
+           DEFAULT_INITIAL_CAPACITY;
+   }
+
+   // 保存到流（序列化）。
+   private void writeObject(java.io.ObjectOutputStream s)
+       throws IOException {
+       int buckets = capacity();
+       // Write out the threshold, loadfactor, and any hidden stuff
+       s.defaultWriteObject();
+       s.writeInt(buckets);
+       s.writeInt(size);
+       internalWriteEntries(s);
+   }
+
+   // 从流重建{@code HashMap}实例（即反序列化它）。
+   private void readObject(java.io.ObjectInputStream s)
+       throws IOException, ClassNotFoundException {
+       // Read in the threshold (ignored), loadfactor, and any hidden stuff
+       s.defaultReadObject();
+       reinitialize();
+       if (loadFactor <= 0 || Float.isNaN(loadFactor))
+           throw new InvalidObjectException("Illegal load factor: " +
+                                            loadFactor);
+       s.readInt();                // Read and ignore number of buckets
+       int mappings = s.readInt(); // Read number of mappings (size)
+       if (mappings < 0)
+           throw new InvalidObjectException("Illegal mappings count: " +
+                                            mappings);
+       else if (mappings > 0) { // (if zero, use defaults)
+           // Size the table using given load factor only if within
+           // range of 0.25...4.0
+           float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
+           float fc = (float)mappings / lf + 1.0f;
+           int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
+                      DEFAULT_INITIAL_CAPACITY :
+                      (fc >= MAXIMUM_CAPACITY) ?
+                      MAXIMUM_CAPACITY :
+                      tableSizeFor((int)fc));
+           float ft = (float)cap * lf;
+           threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
+                        (int)ft : Integer.MAX_VALUE);
+           @SuppressWarnings({"rawtypes","unchecked"})
+               Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
+           table = tab;
+
+           // Read the keys and values, and put the mappings in the HashMap
+           for (int i = 0; i < mappings; i++) {
+               @SuppressWarnings("unchecked")
+                   K key = (K) s.readObject();
+               @SuppressWarnings("unchecked")
+                   V value = (V) s.readObject();
+               putVal(hash(key), key, value, false, false);
+           }
+       }
+   }
+
+   /* ------------------------------------------------------------ */
+   // iterators
+
+   abstract class HashIterator {
+       Node<K,V> next;        // next entry to return
+       Node<K,V> current;     // current entry
+       int expectedModCount;  // for fast-fail
+       int index;             // current slot
+
+       HashIterator() {
+           expectedModCount = modCount;
+           Node<K,V>[] t = table;
+           current = next = null;
+           index = 0;
+           if (t != null && size > 0) { // advance to first entry
+               do {} while (index < t.length && (next = t[index++]) == null);
+           }
+       }
+
+       public final boolean hasNext() {
+           return next != null;
+       }
+
+       final Node<K,V> nextNode() {
+           Node<K,V>[] t;
+           Node<K,V> e = next;
+           if (modCount != expectedModCount)
+               throw new ConcurrentModificationException();
+           if (e == null)
+               throw new NoSuchElementException();
+           if ((next = (current = e).next) == null && (t = table) != null) {
+               do {} while (index < t.length && (next = t[index++]) == null);
+           }
+           return e;
+       }
+
+       public final void remove() {
+           Node<K,V> p = current;
+           if (p == null)
+               throw new IllegalStateException();
+           if (modCount != expectedModCount)
+               throw new ConcurrentModificationException();
+           current = null;
+           K key = p.key;
+           removeNode(hash(key), key, null, false, false);
+           expectedModCount = modCount;
+       }
+   }
+
+   final class KeyIterator extends HashIterator
+       implements Iterator<K> {
+       public final K next() { return nextNode().key; }
+   }
+
+   final class ValueIterator extends HashIterator
+       implements Iterator<V> {
+       public final V next() { return nextNode().value; }
+   }
+
+   final class EntryIterator extends HashIterator
+       implements Iterator<Map.Entry<K,V>> {
+       public final Map.Entry<K,V> next() { return nextNode(); }
+   }
+
+   /* ------------------------------------------------------------ */
+   // spliterators
+
+   static class HashMapSpliterator<K,V> {
+       final HashMap<K,V> map;
+       Node<K,V> current;          // current node
+       int index;                  // current index, modified on advance/split
+       int fence;                  // one past last index
+       int est;                    // size estimate
+       int expectedModCount;       // for comodification checks
+
+       HashMapSpliterator(HashMap<K,V> m, int origin,
+                          int fence, int est,
+                          int expectedModCount) {
+           this.map = m;
+           this.index = origin;
+           this.fence = fence;
+           this.est = est;
+           this.expectedModCount = expectedModCount;
+       }
+
+       final int getFence() { // initialize fence and size on first use
+           int hi;
+           if ((hi = fence) < 0) {
+               HashMap<K,V> m = map;
+               est = m.size;
+               expectedModCount = m.modCount;
+               Node<K,V>[] tab = m.table;
+               hi = fence = (tab == null) ? 0 : tab.length;
+           }
+           return hi;
+       }
+
+       public final long estimateSize() {
+           getFence(); // force init
+           return (long) est;
+       }
+   }
+
+   static final class KeySpliterator<K,V>
+       extends HashMapSpliterator<K,V>
+       implements Spliterator<K> {
+       KeySpliterator(HashMap<K,V> m, int origin, int fence, int est,
+                      int expectedModCount) {
+           super(m, origin, fence, est, expectedModCount);
+       }
+
+       public KeySpliterator<K,V> trySplit() {
+           int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
+           return (lo >= mid || current != null) ? null :
+               new KeySpliterator<>(map, lo, index = mid, est >>>= 1,
+                                       expectedModCount);
+       }
+
+       public void forEachRemaining(Consumer<? super K> action) {
+           int i, hi, mc;
+           if (action == null)
+               throw new NullPointerException();
+           HashMap<K,V> m = map;
+           Node<K,V>[] tab = m.table;
+           if ((hi = fence) < 0) {
+               mc = expectedModCount = m.modCount;
+               hi = fence = (tab == null) ? 0 : tab.length;
+           }
+           else
+               mc = expectedModCount;
+           if (tab != null && tab.length >= hi &&
+               (i = index) >= 0 && (i < (index = hi) || current != null)) {
+               Node<K,V> p = current;
+               current = null;
+               do {
+                   if (p == null)
+                       p = tab[i++];
+                   else {
+                       action.accept(p.key);
+                       p = p.next;
+                   }
+               } while (p != null || i < hi);
+               if (m.modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+
+       public boolean tryAdvance(Consumer<? super K> action) {
+           int hi;
+           if (action == null)
+               throw new NullPointerException();
+           Node<K,V>[] tab = map.table;
+           if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
+               while (current != null || index < hi) {
+                   if (current == null)
+                       current = tab[index++];
+                   else {
+                       K k = current.key;
+                       current = current.next;
+                       action.accept(k);
+                       if (map.modCount != expectedModCount)
+                           throw new ConcurrentModificationException();
+                       return true;
+                   }
+               }
+           }
+           return false;
+       }
+
+       public int characteristics() {
+           return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
+               Spliterator.DISTINCT;
+       }
+   }
+
+   static final class ValueSpliterator<K,V>
+       extends HashMapSpliterator<K,V>
+       implements Spliterator<V> {
+       ValueSpliterator(HashMap<K,V> m, int origin, int fence, int est,
+                        int expectedModCount) {
+           super(m, origin, fence, est, expectedModCount);
+       }
+
+       public ValueSpliterator<K,V> trySplit() {
+           int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
+           return (lo >= mid || current != null) ? null :
+               new ValueSpliterator<>(map, lo, index = mid, est >>>= 1,
+                                         expectedModCount);
+       }
+
+       public void forEachRemaining(Consumer<? super V> action) {
+           int i, hi, mc;
+           if (action == null)
+               throw new NullPointerException();
+           HashMap<K,V> m = map;
+           Node<K,V>[] tab = m.table;
+           if ((hi = fence) < 0) {
+               mc = expectedModCount = m.modCount;
+               hi = fence = (tab == null) ? 0 : tab.length;
+           }
+           else
+               mc = expectedModCount;
+           if (tab != null && tab.length >= hi &&
+               (i = index) >= 0 && (i < (index = hi) || current != null)) {
+               Node<K,V> p = current;
+               current = null;
+               do {
+                   if (p == null)
+                       p = tab[i++];
+                   else {
+                       action.accept(p.value);
+                       p = p.next;
+                   }
+               } while (p != null || i < hi);
+               if (m.modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+
+       public boolean tryAdvance(Consumer<? super V> action) {
+           int hi;
+           if (action == null)
+               throw new NullPointerException();
+           Node<K,V>[] tab = map.table;
+           if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
+               while (current != null || index < hi) {
+                   if (current == null)
+                       current = tab[index++];
+                   else {
+                       V v = current.value;
+                       current = current.next;
+                       action.accept(v);
+                       if (map.modCount != expectedModCount)
+                           throw new ConcurrentModificationException();
+                       return true;
+                   }
+               }
+           }
+           return false;
+       }
+
+       public int characteristics() {
+           return (fence < 0 || est == map.size ? Spliterator.SIZED : 0);
+       }
+   }
+
+   static final class EntrySpliterator<K,V>
+       extends HashMapSpliterator<K,V>
+       implements Spliterator<Map.Entry<K,V>> {
+       EntrySpliterator(HashMap<K,V> m, int origin, int fence, int est,
+                        int expectedModCount) {
+           super(m, origin, fence, est, expectedModCount);
+       }
+
+       public EntrySpliterator<K,V> trySplit() {
+           int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
+           return (lo >= mid || current != null) ? null :
+               new EntrySpliterator<>(map, lo, index = mid, est >>>= 1,
+                                         expectedModCount);
+       }
+
+       public void forEachRemaining(Consumer<? super Map.Entry<K,V>> action) {
+           int i, hi, mc;
+           if (action == null)
+               throw new NullPointerException();
+           HashMap<K,V> m = map;
+           Node<K,V>[] tab = m.table;
+           if ((hi = fence) < 0) {
+               mc = expectedModCount = m.modCount;
+               hi = fence = (tab == null) ? 0 : tab.length;
+           }
+           else
+               mc = expectedModCount;
+           if (tab != null && tab.length >= hi &&
+               (i = index) >= 0 && (i < (index = hi) || current != null)) {
+               Node<K,V> p = current;
+               current = null;
+               do {
+                   if (p == null)
+                       p = tab[i++];
+                   else {
+                       action.accept(p);
+                       p = p.next;
+                   }
+               } while (p != null || i < hi);
+               if (m.modCount != mc)
+                   throw new ConcurrentModificationException();
+           }
+       }
+
+       public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {
+           int hi;
+           if (action == null)
+               throw new NullPointerException();
+           Node<K,V>[] tab = map.table;
+           if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
+               while (current != null || index < hi) {
+                   if (current == null)
+                       current = tab[index++];
+                   else {
+                       Node<K,V> e = current;
+                       current = current.next;
+                       action.accept(e);
+                       if (map.modCount != expectedModCount)
+                           throw new ConcurrentModificationException();
+                       return true;
+                   }
+               }
+           }
+           return false;
+       }
+
+       public int characteristics() {
+           return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
+               Spliterator.DISTINCT;
+       }
+   }
+
+   /* ------------------------------------------------------------ */
+   // LinkedHashMap support
+
+
+   // 以下受包保护的方法设计为由LinkedHashMap重写，但不被任何其他子类重写。
+   // 几乎所有其他内部方法都受包保护，但声明为final，因此可以由LinkedHashMap、视图类和哈希集使用。
+
+   // 创建常规（非树）节点。
+   Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
+       return new Node<>(hash, key, value, next);
+   }
+
+   // 用于从TreeNodes转换为普通节点。
+   Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
+       return new Node<>(p.hash, p.key, p.value, next);
+   }
+
+   // Create a tree bin node
+   TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
+       return new TreeNode<>(hash, key, value, next);
+   }
+
+   // For treeifyBin
+   TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
+       return new TreeNode<>(p.hash, p.key, p.value, next);
+   }
+
+   // 重置为初始默认状态。由clone和readObject调用。
+   void reinitialize() {
+       table = null;
+       entrySet = null;
+       keySet = null;
+       values = null;
+       modCount = 0;
+       threshold = 0;
+       size = 0;
+   }
+
+   // 回调以允许LinkedHashMap发布操作
+   void afterNodeAccess(Node<K,V> p) { }
+   void afterNodeInsertion(boolean evict) { }
+   void afterNodeRemoval(Node<K,V> p) { }
+
+   // 仅从writeObject调用，以确保排序兼容。
+   void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
+       Node<K,V>[] tab;
+       if (size > 0 && (tab = table) != null) {
+           for (int i = 0; i < tab.length; ++i) {
+               for (Node<K,V> e = tab[i]; e != null; e = e.next) {
+                   s.writeObject(e.key);
+                   s.writeObject(e.value);
+               }
+           }
+       }
+   }
+
+   // Tree bins
+
+   // 扩展LinkedHashMap.Entry（进而扩展节点），因此可以用作常规节点或链接节点的扩展。
+   static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
+       TreeNode<K,V> parent;  // red-black tree links
+       TreeNode<K,V> left;
+       TreeNode<K,V> right;
+       TreeNode<K,V> prev;    // needed to unlink next upon deletion
+       boolean red;
+       TreeNode(int hash, K key, V val, Node<K,V> next) {
+           super(hash, key, val, next);
+       }
+
+       // 返回包含此节点的树的根。
+       final TreeNode<K,V> root() {
+           for (TreeNode<K,V> r = this, p;;) {
+               if ((p = r.parent) == null)
+                   return r;
+               r = p;
+           }
+       }
+
+       // 确保给定的根是其bin的第一个节点。
+       static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
+           int n;
+           if (root != null && tab != null && (n = tab.length) > 0) {
+               int index = (n - 1) & root.hash;
+               TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
+               if (root != first) {
+                   Node<K,V> rn;
+                   tab[index] = root;
+                   TreeNode<K,V> rp = root.prev;
+                   if ((rn = root.next) != null)
+                       ((TreeNode<K,V>)rn).prev = rp;
+                   if (rp != null)
+                       rp.next = rn;
+                   if (first != null)
+                       first.prev = root;
+                   root.next = first;
+                   root.prev = null;
+               }
+               assert checkInvariants(root);
+           }
+       }
+
+       // 查找从根p开始的具有给定哈希和键的节点。kc参数在第一次使用比较键时缓存comparableClassFor（key）。
+       final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
+           TreeNode<K,V> p = this;
+           do {
+               int ph, dir; K pk;
+               TreeNode<K,V> pl = p.left, pr = p.right, q;
+               if ((ph = p.hash) > h)
+                   p = pl;
+               else if (ph < h)
+                   p = pr;
+               else if ((pk = p.key) == k || (k != null && k.equals(pk)))
+                   return p;
+               else if (pl == null)
+                   p = pr;
+               else if (pr == null)
+                   p = pl;
+               else if ((kc != null ||
+                         (kc = comparableClassFor(k)) != null) &&
+                        (dir = compareComparables(kc, k, pk)) != 0)
+                   p = (dir < 0) ? pl : pr;
+               else if ((q = pr.find(h, k, kc)) != null)
+                   return q;
+               else
+                   p = pl;
+           } while (p != null);
+           return null;
+       }
+
+       // 查找要节点
+       final TreeNode<K,V> getTreeNode(int h, Object k) {
+           return ((parent != null) ? root() : this).find(h, k, null);
+       }
+
+       // 用于在哈希码相等且不可比较时排序插入的断开连接实用程序。
+       // 我们不需要总订单，只需要一个一致的插入规则，以保持在重新平衡之间的等价性。断开领带比必要时更能简化测试。
+       static int tieBreakOrder(Object a, Object b) {
+           int d;
+           if (a == null || b == null ||
+               (d = a.getClass().getName().
+                compareTo(b.getClass().getName())) == 0)
+               d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
+                    -1 : 1);
+           return d;
+       }
+
+       // 返回树根，从该节点链接的节点的窗体树。
+       final void treeify(Node<K,V>[] tab) {
+           TreeNode<K,V> root = null;
+           for (TreeNode<K,V> x = this, next; x != null; x = next) {
+               next = (TreeNode<K,V>)x.next;
+               x.left = x.right = null;
+               if (root == null) {
+                   x.parent = null;
+                   x.red = false;
+                   root = x;
+               }
+               else {
+                   K k = x.key;
+                   int h = x.hash;
+                   Class<?> kc = null;
+                   for (TreeNode<K,V> p = root;;) {
+                       int dir, ph;
+                       K pk = p.key;
+                       if ((ph = p.hash) > h)
+                           dir = -1;
+                       else if (ph < h)
+                           dir = 1;
+                       else if ((kc == null &&
+                                 (kc = comparableClassFor(k)) == null) ||
+                                (dir = compareComparables(kc, k, pk)) == 0)
+                           dir = tieBreakOrder(k, pk);
+
+                       TreeNode<K,V> xp = p;
+                       if ((p = (dir <= 0) ? p.left : p.right) == null) {
+                           x.parent = xp;
+                           if (dir <= 0)
+                               xp.left = x;
+                           else
+                               xp.right = x;
+                           root = balanceInsertion(root, x);
+                           break;
+                       }
+                   }
+               }
+           }
+           moveRootToFront(tab, root);
+       }
+
+       // 返回一个非树节点列表，替换从该节点链接的树节点。
+       final Node<K,V> untreeify(HashMap<K,V> map) {
+           Node<K,V> hd = null, tl = null;
+           for (Node<K,V> q = this; q != null; q = q.next) {
+               Node<K,V> p = map.replacementNode(q, null);
+               if (tl == null)
+                   hd = p;
+               else
+                   tl.next = p;
+               tl = p;
+           }
+           return hd;
+       }
+
+       // 树版本的 put 方法
+       final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
+                                      int h, K k, V v) {
+           Class<?> kc = null;
+           boolean searched = false;
+           TreeNode<K,V> root = (parent != null) ? root() : this;
+           for (TreeNode<K,V> p = root;;) {
+               int dir, ph; K pk;
+               if ((ph = p.hash) > h)
+                   dir = -1;
+               else if (ph < h)
+                   dir = 1;
+               else if ((pk = p.key) == k || (k != null && k.equals(pk)))
+                   return p;
+               else if ((kc == null &&
+                         (kc = comparableClassFor(k)) == null) ||
+                        (dir = compareComparables(kc, k, pk)) == 0) {
+                   if (!searched) {
+                       TreeNode<K,V> q, ch;
+                       searched = true;
+                       if (((ch = p.left) != null &&
+                            (q = ch.find(h, k, kc)) != null) ||
+                           ((ch = p.right) != null &&
+                            (q = ch.find(h, k, kc)) != null))
+                           return q;
+                   }
+                   dir = tieBreakOrder(k, pk);
+               }
+
+               TreeNode<K,V> xp = p;
+               if ((p = (dir <= 0) ? p.left : p.right) == null) {
+                   Node<K,V> xpn = xp.next;
+                   TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
+                   if (dir <= 0)
+                       xp.left = x;
+                   else
+                       xp.right = x;
+                   xp.next = x;
+                   x.parent = x.prev = xp;
+                   if (xpn != null)
+                       ((TreeNode<K,V>)xpn).prev = x;
+                   moveRootToFront(tab, balanceInsertion(root, x));
+                   return null;
+               }
+           }
+       }
+
+       // 删除给定的节点，该节点必须在此调用之前存在。
+       // 这比典型的红黑删除代码更混乱，因为我们不能将内部节点的内容与叶后续节点交换，叶后续节点由在遍历期间可以独立访问的“下一个”指针固定。
+       // 所以我们交换树链接。如果当前树的节点太少，垃圾箱被转换回普通垃圾箱。（测试在2到6个节点之间触发，具体取决于树结构）。
+       final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
+                                 boolean movable) {
+           int n;
+           if (tab == null || (n = tab.length) == 0)
+               return;
+           int index = (n - 1) & hash;
+           TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
+           TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
+           if (pred == null)
+               tab[index] = first = succ;
+           else
+               pred.next = succ;
+           if (succ != null)
+               succ.prev = pred;
+           if (first == null)
+               return;
+           if (root.parent != null)
+               root = root.root();
+           if (root == null || root.right == null ||
+               (rl = root.left) == null || rl.left == null) {
+               tab[index] = first.untreeify(map);  // too small
+               return;
+           }
+           TreeNode<K,V> p = this, pl = left, pr = right, replacement;
+           if (pl != null && pr != null) {
+               TreeNode<K,V> s = pr, sl;
+               while ((sl = s.left) != null) // find successor
+                   s = sl;
+               boolean c = s.red; s.red = p.red; p.red = c; // swap colors
+               TreeNode<K,V> sr = s.right;
+               TreeNode<K,V> pp = p.parent;
+               if (s == pr) { // p was s's direct parent
+                   p.parent = s;
+                   s.right = p;
+               }
+               else {
+                   TreeNode<K,V> sp = s.parent;
+                   if ((p.parent = sp) != null) {
+                       if (s == sp.left)
+                           sp.left = p;
+                       else
+                           sp.right = p;
+                   }
+                   if ((s.right = pr) != null)
+                       pr.parent = s;
+               }
+               p.left = null;
+               if ((p.right = sr) != null)
+                   sr.parent = p;
+               if ((s.left = pl) != null)
+                   pl.parent = s;
+               if ((s.parent = pp) == null)
+                   root = s;
+               else if (p == pp.left)
+                   pp.left = s;
+               else
+                   pp.right = s;
+               if (sr != null)
+                   replacement = sr;
+               else
+                   replacement = p;
+           }
+           else if (pl != null)
+               replacement = pl;
+           else if (pr != null)
+               replacement = pr;
+           else
+               replacement = p;
+           if (replacement != p) {
+               TreeNode<K,V> pp = replacement.parent = p.parent;
+               if (pp == null)
+                   root = replacement;
+               else if (p == pp.left)
+                   pp.left = replacement;
+               else
+                   pp.right = replacement;
+               p.left = p.right = p.parent = null;
+           }
+
+           TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
+
+           if (replacement == p) {  // detach
+               TreeNode<K,V> pp = p.parent;
+               p.parent = null;
+               if (pp != null) {
+                   if (p == pp.left)
+                       pp.left = null;
+                   else if (p == pp.right)
+                       pp.right = null;
+               }
+           }
+           if (movable)
+               moveRootToFront(tab, r);
+       }
+
+       // 将树箱中的节点拆分为上下树箱，如果现在太小，则取消搜索。仅从resize调用；请参阅上面关于拆分位和索引的讨论。
+       final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
+           TreeNode<K,V> b = this;
+           // Relink into lo and hi lists, preserving order
+           TreeNode<K,V> loHead = null, loTail = null;
+           TreeNode<K,V> hiHead = null, hiTail = null;
+           int lc = 0, hc = 0;
+           for (TreeNode<K,V> e = b, next; e != null; e = next) {
+               next = (TreeNode<K,V>)e.next;
+               e.next = null;
+               if ((e.hash & bit) == 0) {
+                   if ((e.prev = loTail) == null)
+                       loHead = e;
+                   else
+                       loTail.next = e;
+                   loTail = e;
+                   ++lc;
+               }
+               else {
+                   if ((e.prev = hiTail) == null)
+                       hiHead = e;
+                   else
+                       hiTail.next = e;
+                   hiTail = e;
+                   ++hc;
+               }
+           }
+
+           if (loHead != null) {
+               if (lc <= UNTREEIFY_THRESHOLD)
+                   tab[index] = loHead.untreeify(map);
+               else {
+                   tab[index] = loHead;
+                   if (hiHead != null) // (else is already treeified)
+                       loHead.treeify(tab);
+               }
+           }
+           if (hiHead != null) {
+               if (hc <= UNTREEIFY_THRESHOLD)
+                   tab[index + bit] = hiHead.untreeify(map);
+               else {
+                   tab[index + bit] = hiHead;
+                   if (loHead != null)
+                       hiHead.treeify(tab);
+               }
+           }
+       }
+
+       // 红黑树方法，全部改编自CLR
+
+       static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
+                                             TreeNode<K,V> p) {
+           TreeNode<K,V> r, pp, rl;
+           if (p != null && (r = p.right) != null) {
+               if ((rl = p.right = r.left) != null)
+                   rl.parent = p;
+               if ((pp = r.parent = p.parent) == null)
+                   (root = r).red = false;
+               else if (pp.left == p)
+                   pp.left = r;
+               else
+                   pp.right = r;
+               r.left = p;
+               p.parent = r;
+           }
+           return root;
+       }
+
+       static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
+                                              TreeNode<K,V> p) {
+           TreeNode<K,V> l, pp, lr;
+           if (p != null && (l = p.left) != null) {
+               if ((lr = p.left = l.right) != null)
+                   lr.parent = p;
+               if ((pp = l.parent = p.parent) == null)
+                   (root = l).red = false;
+               else if (pp.right == p)
+                   pp.right = l;
+               else
+                   pp.left = l;
+               l.right = p;
+               p.parent = l;
+           }
+           return root;
+       }
+
+       static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
+                                                   TreeNode<K,V> x) {
+           x.red = true;
+           for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
+               if ((xp = x.parent) == null) {
+                   x.red = false;
+                   return x;
+               }
+               else if (!xp.red || (xpp = xp.parent) == null)
+                   return root;
+               if (xp == (xppl = xpp.left)) {
+                   if ((xppr = xpp.right) != null && xppr.red) {
+                       xppr.red = false;
+                       xp.red = false;
+                       xpp.red = true;
+                       x = xpp;
+                   }
+                   else {
+                       if (x == xp.right) {
+                           root = rotateLeft(root, x = xp);
+                           xpp = (xp = x.parent) == null ? null : xp.parent;
+                       }
+                       if (xp != null) {
+                           xp.red = false;
+                           if (xpp != null) {
+                               xpp.red = true;
+                               root = rotateRight(root, xpp);
+                           }
+                       }
+                   }
+               }
+               else {
+                   if (xppl != null && xppl.red) {
+                       xppl.red = false;
+                       xp.red = false;
+                       xpp.red = true;
+                       x = xpp;
+                   }
+                   else {
+                       if (x == xp.left) {
+                           root = rotateRight(root, x = xp);
+                           xpp = (xp = x.parent) == null ? null : xp.parent;
+                       }
+                       if (xp != null) {
+                           xp.red = false;
+                           if (xpp != null) {
+                               xpp.red = true;
+                               root = rotateLeft(root, xpp);
+                           }
+                       }
+                   }
+               }
+           }
+       }
+
+       static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
+                                                  TreeNode<K,V> x) {
+           for (TreeNode<K,V> xp, xpl, xpr;;)  {
+               if (x == null || x == root)
+                   return root;
+               else if ((xp = x.parent) == null) {
+                   x.red = false;
+                   return x;
+               }
+               else if (x.red) {
+                   x.red = false;
+                   return root;
+               }
+               else if ((xpl = xp.left) == x) {
+                   if ((xpr = xp.right) != null && xpr.red) {
+                       xpr.red = false;
+                       xp.red = true;
+                       root = rotateLeft(root, xp);
+                       xpr = (xp = x.parent) == null ? null : xp.right;
+                   }
+                   if (xpr == null)
+                       x = xp;
+                   else {
+                       TreeNode<K,V> sl = xpr.left, sr = xpr.right;
+                       if ((sr == null || !sr.red) &&
+                           (sl == null || !sl.red)) {
+                           xpr.red = true;
+                           x = xp;
+                       }
+                       else {
+                           if (sr == null || !sr.red) {
+                               if (sl != null)
+                                   sl.red = false;
+                               xpr.red = true;
+                               root = rotateRight(root, xpr);
+                               xpr = (xp = x.parent) == null ?
+                                   null : xp.right;
+                           }
+                           if (xpr != null) {
+                               xpr.red = (xp == null) ? false : xp.red;
+                               if ((sr = xpr.right) != null)
+                                   sr.red = false;
+                           }
+                           if (xp != null) {
+                               xp.red = false;
+                               root = rotateLeft(root, xp);
+                           }
+                           x = root;
+                       }
+                   }
+               }
+               else { // symmetric
+                   if (xpl != null && xpl.red) {
+                       xpl.red = false;
+                       xp.red = true;
+                       root = rotateRight(root, xp);
+                       xpl = (xp = x.parent) == null ? null : xp.left;
+                   }
+                   if (xpl == null)
+                       x = xp;
+                   else {
+                       TreeNode<K,V> sl = xpl.left, sr = xpl.right;
+                       if ((sl == null || !sl.red) &&
+                           (sr == null || !sr.red)) {
+                           xpl.red = true;
+                           x = xp;
+                       }
+                       else {
+                           if (sl == null || !sl.red) {
+                               if (sr != null)
+                                   sr.red = false;
+                               xpl.red = true;
+                               root = rotateLeft(root, xpl);
+                               xpl = (xp = x.parent) == null ?
+                                   null : xp.left;
+                           }
+                           if (xpl != null) {
+                               xpl.red = (xp == null) ? false : xp.red;
+                               if ((sl = xpl.left) != null)
+                                   sl.red = false;
+                           }
+                           if (xp != null) {
+                               xp.red = false;
+                               root = rotateRight(root, xp);
+                           }
+                           x = root;
+                       }
+                   }
+               }
+           }
+       }
+
+       // 递归检查
+       static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
+           TreeNode<K,V> tp = t.parent, tl = t.left, tr = t.right,
+               tb = t.prev, tn = (TreeNode<K,V>)t.next;
+           if (tb != null && tb.next != t)
+               return false;
+           if (tn != null && tn.prev != t)
+               return false;
+           if (tp != null && t != tp.left && t != tp.right)
+               return false;
+           if (tl != null && (tl.parent != t || tl.hash > t.hash))
+               return false;
+           if (tr != null && (tr.parent != t || tr.hash < t.hash))
+               return false;
+           if (t.red && tl != null && tl.red && tr != null && tr.red)
+               return false;
+           if (tl != null && !checkInvariants(tl))
+               return false;
+           if (tr != null && !checkInvariants(tr))
+               return false;
+           return true;
+       }
+   }
+```  
\ No newline at end of file
diff --git a/second/week_01/36/LinkedList.md b/second/week_01/36/LinkedList.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb06d04f3af9823cf632e21e6b5f6fc2158b0caa
--- /dev/null
+++ b/second/week_01/36/LinkedList.md
@@ -0,0 +1,817 @@
+
+# LinkedList -- 增删快。
+
+# 1.继承关系：
+``` java
+   public class LinkedList<E>
+       extends AbstractSequentialList<E>
+       implements List<E>, Deque<E>, Cloneable, java.io.Serializable
+```          
+    
+# 2. 属性：
+``` java
+    // 默认容量
+    transient int size = 0;
+    
+    // 首字节
+    transient Node<E> first;
+
+    // 尾字节
+    transient Node<E> last;
+```    
+    
+# 3.方法：
+
+``` java
+   // 无参构造函数
+   public LinkedList() {
+   }
+
+   // 返回包含指定集合元素的构造
+   public LinkedList(Collection<? extends E> c) {
+       this();
+       addAll(c);
+   }
+
+   // 添加第一个元素
+   private void linkFirst(E e) {
+       // 定义 f ，赋值为首节点。
+       final Node<E> f = first;
+       // 定义新节点 newNode ，设置其后一节点为原首节点：f。
+       final Node<E> newNode = new Node<>(null, e, f);
+       // 把原首节点赋值为新节点：newNode。
+       first = newNode;
+       if (f == null)
+           //　集合中无元素则，则新节点也是最后一节点。
+           last = newNode;
+       else
+       　　// 设置 f 的前一节点为新节点。（final 修饰的变量其引用指针不可改，但其属性可改。）
+           f.prev = newNode;
+       size++;
+       modCount++;
+   }
+
+   // 添加最后一个元素
+   void linkLast(E e) {
+       final Node<E> l = last;
+       final Node<E> newNode = new Node<>(l, e, null);
+       last = newNode;
+       if (l == null)
+           first = newNode;
+       else
+           l.next = newNode;
+       // 集合元素加1。
+       size++;
+       // 集合修改次数加1。
+       modCount++;
+   }
+
+   // 在指定的非空节点前添加元素
+   void linkBefore(E e, Node<E> succ) {
+       // succ 不为空。定义 pred ，赋值为 succ 的前一节点。
+       final Node<E> pred = succ.prev;
+       // 定义新节点 newNode，前一节点为：pred，后一节点为 succ。
+       final Node<E> newNode = new Node<>(pred, e, succ);
+       // 设置 succ 前一节点为 newNode 。
+       succ.prev = newNode;
+       if (pred == null)
+           first = newNode;
+       else
+           // 设置 pred 的后一节点为新节点：newNode。
+           pred.next = newNode;
+       size++;
+       modCount++;
+   }
+
+   // 删除第一个节点
+   private E unlinkFirst(Node<E> f) {
+       // assert f == first && f != null;
+       final E element = f.item;
+       final Node<E> next = f.next;
+       f.item = null;
+       f.next = null; // help GC
+       first = next;
+       if (next == null)
+           last = null;
+       else
+           next.prev = null;
+       size--;
+       modCount++;
+       return element;
+   }
+
+   // 删除最后一个节点
+   private E unlinkLast(Node<E> l) {
+       // assert l == last && l != null;
+       final E element = l.item;
+       final Node<E> prev = l.prev;
+       l.item = null;
+       l.prev = null; // help GC
+       last = prev;
+       if (prev == null)
+           first = null;
+       else
+           prev.next = null;
+       size--;
+       modCount++;
+       return element;
+   }
+
+   // 删除非空节点
+   E unlink(Node<E> x) {
+       // assert x != null;
+       // 把要删除的元素 x 赋值给 element，用于返回。
+       final E element = x.item;
+       // 定义 next，赋值为ｘ的后一节点。
+       final Node<E> next = x.next;
+       // 定义 prev，赋值为 x 的前一节点。
+       final Node<E> prev = x.prev;
+       // 无前节点，则 x 的后一节点为首节点。
+       if (prev == null) {
+           first = next;
+       } else {
+           // 设置（ｘ的前一节点）prev 的后一节点为ｘ的后一节点： next。（跳过 x 节点）
+           prev.next = next;
+           // x 的前节点置空。
+           x.prev = null;
+       }
+       //　不存在ｘ的后一节点，则最后节点为ｘ的前节点。
+       if (next == null) {
+           last = prev;
+       } else {
+           // 设置（ｘ的后一节点）next 的前一节点为ｘ的前一节点。（跳过 x 节点）
+           next.prev = prev;
+           // x 的后节点置空。
+           x.next = null;
+       }
+       // x 本身的值置空。
+       x.item = null;
+       // 集合元数个数减1。
+       size--;
+       modCount++;
+       return element;
+   }
+
+   // 查第一个节点。
+   public E getFirst() {
+       final Node<E> f = first;
+       if (f == null)
+           throw new NoSuchElementException();
+       return f.item;
+   }
+
+   // 查最后一节点。
+   public E getLast() {
+       final Node<E> l = last;
+       if (l == null)
+           throw new NoSuchElementException();
+       return l.item;
+   }
+
+   // 删除并返回第一个节点
+   public E removeFirst() {
+       final Node<E> f = first;
+       if (f == null)
+           throw new NoSuchElementException();
+       return unlinkFirst(f);
+   }
+
+   // 删除并返回最后一个节点
+   public E removeLast() {
+       final Node<E> l = last;
+       if (l == null)
+           throw new NoSuchElementException();
+       return unlinkLast(l);
+   }
+
+   // 新增第一个节点。
+   public void addFirst(E e) {
+       linkFirst(e);
+   }
+
+   // 新增最后一节点
+   public void addLast(E e) {
+       linkLast(e);
+   }
+
+   // 查是否存在指定节点
+   public boolean contains(Object o) {
+       return indexOf(o) != -1;
+   }
+
+   // 查集合中元素个数
+   public int size() {
+       return size;
+   }
+
+   // 新增最后一节点，并返回该节点。
+   public boolean add(E e) {
+       linkLast(e);
+       return true;
+   }
+
+   // 删除第一个和指定节点匹配的节点，指定节点不存在则不变。
+   public boolean remove(Object o) {
+       if (o == null) {
+           for (Node<E> x = first; x != null; x = x.next) {
+               if (x.item == null) {
+                   unlink(x);
+                   return true;
+               }
+           }
+       } else {
+           for (Node<E> x = first; x != null; x = x.next) {
+               if (o.equals(x.item)) {
+                   unlink(x);
+                   return true;
+               }
+           }
+       }
+       return false;
+   }
+
+   // 在原集合尾部追加指定的集合。
+   public boolean addAll(Collection<? extends E> c) {
+       return addAll(size, c);
+   }
+
+   // 在指定位置插入指定的集合。index：元素在集合中的位置
+   public boolean addAll(int index, Collection<? extends E> c) {
+       // 查 index 对应节点是否在元素中，不在则抛异常
+       checkPositionIndex(index);
+
+       Object[] a = c.toArray();
+       int numNew = a.length;
+       if (numNew == 0)
+           return false;
+
+       Node<E> pred, succ;
+       if (index == size) {
+           succ = null;
+           pred = last;
+       } else {
+           // 不断2分查找，至找到 index 对应节点。
+           succ = node(index);
+           pred = succ.prev;
+       }
+
+       for (Object o : a) {
+           @SuppressWarnings("unchecked") E e = (E) o;
+           Node<E> newNode = new Node<>(pred, e, null);
+           if (pred == null)
+               first = newNode;
+           else
+               pred.next = newNode;
+           pred = newNode;
+       }
+
+       if (succ == null) {
+           last = pred;
+       } else {
+           pred.next = succ;
+           succ.prev = pred;
+       }
+
+       size += numNew;
+       modCount++;
+       return true;
+   }
+
+   // 删除全部节点。有节点被引用也会释放内存。
+   public void clear() {
+       for (Node<E> x = first; x != null; ) {
+           Node<E> next = x.next;
+           x.item = null;
+           x.next = null;
+           x.prev = null;
+           x = next;
+       }
+       first = last = null;
+       size = 0;
+       modCount++;
+   }
+
+   // 查指定位置节点
+   public E get(int index) {
+       // 检查 index （ 即：>0，< size）
+       checkElementIndex(index);
+       return node(index).item;
+   }
+
+   // 替换指定位置节点。返回旧节点。
+   public E set(int index, E element) {
+       checkElementIndex(index);
+       Node<E> x = node(index);
+       E oldVal = x.item;
+       x.item = element;
+       return oldVal;
+   }
+
+   // 指定位置插入指定节点
+   public void add(int index, E element) {
+       checkPositionIndex(index);
+
+       if (index == size)
+           linkLast(element);
+       else
+           linkBefore(element, node(index));
+   }
+
+   // 删除指定位置节点。
+   public E remove(int index) {
+       checkElementIndex(index);
+       return unlink(node(index));
+   }
+
+   // 检查索引是否有效。
+   private boolean isElementIndex(int index) {
+       return index >= 0 && index < size;
+   }
+
+   // 检查索引是否有效。
+   private boolean isPositionIndex(int index) {
+       return index >= 0 && index <= size;
+   }
+
+   // 构造提示信息。
+   private String outOfBoundsMsg(int index) {
+       return "Index: "+index+", Size: "+size;
+   }
+
+   private void checkElementIndex(int index) {
+       if (!isElementIndex(index))
+           throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+   }
+
+   private void checkPositionIndex(int index) {
+       if (!isPositionIndex(index))
+           throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+   }
+
+   // 查指定非空节点。（不断2分查找）
+   Node<E> node(int index) {
+       // assert isElementIndex(index);
+
+       if (index < (size >> 1)) {
+           Node<E> x = first;
+           for (int i = 0; i < index; i++)
+               x = x.next;
+           return x;
+       } else {
+           Node<E> x = last;
+           for (int i = size - 1; i > index; i--)
+               x = x.prev;
+           return x;
+       }
+   }
+
+   // 正向检查指定节点是否存在。不存在返回-1。
+   public int indexOf(Object o) {
+       int index = 0;
+       if (o == null) {
+           for (Node<E> x = first; x != null; x = x.next) {
+               if (x.item == null)
+                   return index;
+               index++;
+           }
+       } else {
+           for (Node<E> x = first; x != null; x = x.next) {
+               if (o.equals(x.item))
+                   return index;
+               index++;
+           }
+       }
+       return -1;
+   }
+
+   // 反向检查指定节点是否存在。不存在返回-1。
+   public int lastIndexOf(Object o) {
+       int index = size;
+       if (o == null) {
+           for (Node<E> x = last; x != null; x = x.prev) {
+               index--;
+               if (x.item == null)
+                   return index;
+           }
+       } else {
+           for (Node<E> x = last; x != null; x = x.prev) {
+               index--;
+               if (o.equals(x.item))
+                   return index;
+           }
+       }
+       return -1;
+   }
+
+   // 查首节点
+   public E peek() {
+       final Node<E> f = first;
+       return (f == null) ? null : f.item;
+   }
+
+   // 查首节点，集合为空则抛异常。
+   public E element() {
+       return getFirst();
+   }
+
+   // 查并删除首节点。
+   public E poll() {
+       final Node<E> f = first;
+       return (f == null) ? null : unlinkFirst(f);
+   }
+
+   // 查并删除首节点，集合为空则抛异常。
+   public E remove() {
+       return removeFirst();
+   }
+
+   // 追加尾节点。
+   public boolean offer(E e) {
+       return add(e);
+   }
+
+   // 新增首节点。
+   public boolean offerFirst(E e) {
+       addFirst(e);
+       return true;
+   }
+
+   // 追加尾节点。
+   public boolean offerLast(E e) {
+       addLast(e);
+       return true;
+   }
+
+   // 查首节点。
+   public E peekFirst() {
+       final Node<E> f = first;
+       return (f == null) ? null : f.item;
+    }
+
+   // 查尾节点
+   public E peekLast() {
+       final Node<E> l = last;
+       return (l == null) ? null : l.item;
+   }
+
+   // 查并删除首节点。
+   public E pollFirst() {
+       final Node<E> f = first;
+       return (f == null) ? null : unlinkFirst(f);
+   }
+
+   // 查并删除尾节点。
+   public E pollLast() {
+       final Node<E> l = last;
+       return (l == null) ? null : unlinkLast(l);
+   }
+
+   // 新增首节点
+   public void push(E e) {
+       addFirst(e);
+   }
+
+   // 删除并返回首节点。
+   public E pop() {
+       return removeFirst();
+   }
+
+   // 正向删除指定节点。节点不存在则集合不变，返回 false 。
+   public boolean removeFirstOccurrence(Object o) {
+       return remove(o);
+   }
+
+   // 反向删除指定节点。节点不存在则集合不变，返回 false 。
+   public boolean removeLastOccurrence(Object o) {
+       if (o == null) {
+           for (Node<E> x = last; x != null; x = x.prev) {
+               if (x.item == null) {
+                   unlink(x);
+                   return true;
+               }
+           }
+       } else {
+           for (Node<E> x = last; x != null; x = x.prev) {
+               if (o.equals(x.item)) {
+                   unlink(x);
+                   return true;
+               }
+           }
+       }
+       return false;
+   }
+
+   // 返回迭代器
+   public ListIterator<E> listIterator(int index) {
+       checkPositionIndex(index);
+       return new ListItr(index);
+   }
+
+   private class ListItr implements ListIterator<E> {
+       private Node<E> lastReturned;
+       private Node<E> next;
+       private int nextIndex;
+       private int expectedModCount = modCount;
+
+       ListItr(int index) {
+           // assert isPositionIndex(index);
+           next = (index == size) ? null : node(index);
+           nextIndex = index;
+       }
+
+       public boolean hasNext() {
+           return nextIndex < size;
+       }
+
+       public E next() {
+           checkForComodification();
+           if (!hasNext())
+               throw new NoSuchElementException();
+
+           lastReturned = next;
+           next = next.next;
+           nextIndex++;
+           return lastReturned.item;
+       }
+
+       public boolean hasPrevious() {
+           return nextIndex > 0;
+       }
+
+       public E previous() {
+           checkForComodification();
+           if (!hasPrevious())
+               throw new NoSuchElementException();
+
+           lastReturned = next = (next == null) ? last : next.prev;
+           nextIndex--;
+           return lastReturned.item;
+       }
+
+       public int nextIndex() {
+           return nextIndex;
+       }
+
+       public int previousIndex() {
+           return nextIndex - 1;
+       }
+
+       public void remove() {
+           checkForComodification();
+           if (lastReturned == null)
+               throw new IllegalStateException();
+
+           Node<E> lastNext = lastReturned.next;
+           unlink(lastReturned);
+           if (next == lastReturned)
+               next = lastNext;
+           else
+               nextIndex--;
+           lastReturned = null;
+           expectedModCount++;
+       }
+
+       public void set(E e) {
+           if (lastReturned == null)
+               throw new IllegalStateException();
+           checkForComodification();
+           lastReturned.item = e;
+       }
+
+       public void add(E e) {
+           checkForComodification();
+           lastReturned = null;
+           if (next == null)
+               linkLast(e);
+           else
+               linkBefore(e, next);
+           nextIndex++;
+           expectedModCount++;
+       }
+
+       public void forEachRemaining(Consumer<? super E> action) {
+           Objects.requireNonNull(action);
+           while (modCount == expectedModCount && nextIndex < size) {
+               action.accept(next.item);
+               lastReturned = next;
+               next = next.next;
+               nextIndex++;
+           }
+           checkForComodification();
+       }
+
+       final void checkForComodification() {
+           if (modCount != expectedModCount)
+               throw new ConcurrentModificationException();
+       }
+   }
+
+   private static class Node<E> {
+       E item;
+       Node<E> next;
+       Node<E> prev;
+
+       Node(Node<E> prev, E element, Node<E> next) {
+           this.item = element;
+           this.next = next;
+           this.prev = prev;
+       }
+   }
+
+   /**
+    * @since 1.6
+    */
+   public Iterator<E> descendingIterator() {
+       return new DescendingIterator();
+   }
+
+   // 返回降序迭代器。
+   private class DescendingIterator implements Iterator<E> {
+       private final ListItr itr = new ListItr(size());
+       public boolean hasNext() {
+           return itr.hasPrevious();
+       }
+       public E next() {
+           return itr.previous();
+       }
+       public void remove() {
+           itr.remove();
+       }
+   }
+
+   @SuppressWarnings("unchecked")
+   private LinkedList<E> superClone() {
+       try {
+           return (LinkedList<E>) super.clone();
+       } catch (CloneNotSupportedException e) {
+           throw new InternalError(e);
+       }
+   }
+
+   // 浅clone 。
+   public Object clone() {
+       LinkedList<E> clone = superClone();
+
+       // Put clone into "virgin" state
+       clone.first = clone.last = null;
+       clone.size = 0;
+       clone.modCount = 0;
+
+       // Initialize clone with our elements
+       for (Node<E> x = first; x != null; x = x.next)
+           clone.add(x.item);
+       return clone;
+   }
+
+   // 转为 Object 数组
+   public Object[] toArray() {
+       Object[] result = new Object[size];
+       int i = 0;
+       for (Node<E> x = first; x != null; x = x.next)
+           result[i++] = x.item;
+       return result;
+   }
+
+   // 拷贝原集合元素到指定数组。
+   @SuppressWarnings("unchecked")
+   public <T> T[] toArray(T[] a) {
+       if (a.length < size)
+           a = (T[])java.lang.reflect.Array.newInstance(
+                               a.getClass().getComponentType(), size);
+       int i = 0;
+       Object[] result = a;
+       for (Node<E> x = first; x != null; x = x.next)
+           result[i++] = x.item;
+
+       if (a.length > size)
+           a[size] = null;
+
+       return a;
+   }
+
+   private static final long serialVersionUID = 876323262645176354L;
+
+   // 写出到流，序列化。
+   private void writeObject(java.io.ObjectOutputStream s)
+       throws java.io.IOException {
+       // Write out any hidden serialization magic
+       s.defaultWriteObject();
+
+       // Write out size
+       s.writeInt(size);
+
+       // Write out all elements in the proper order.
+       for (Node<E> x = first; x != null; x = x.next)
+           s.writeObject(x.item);
+   }
+
+   // 从流读入，反序列化。
+   @SuppressWarnings("unchecked")
+   private void readObject(java.io.ObjectInputStream s)
+       throws java.io.IOException, ClassNotFoundException {
+       // Read in any hidden serialization magic
+       s.defaultReadObject();
+
+       // Read in size
+       int size = s.readInt();
+
+       // Read in all elements in the proper order.
+       for (int i = 0; i < size; i++)
+           linkLast((E)s.readObject());
+   }
+
+   // 创建拆分器
+   @Override
+   public Spliterator<E> spliterator() {
+       return new LLSpliterator<E>(this, -1, 0);
+   }
+
+   static final class LLSpliterator<E> implements Spliterator<E> {
+       static final int BATCH_UNIT = 1 << 10;  // batch array size increment
+       static final int MAX_BATCH = 1 << 25;  // max batch array size;
+       final LinkedList<E> list; // null OK unless traversed
+       Node<E> current;      // current node; null until initialized
+       int est;              // size estimate; -1 until first needed
+       int expectedModCount; // initialized when est set
+       int batch;            // batch size for splits
+
+       LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
+           this.list = list;
+           this.est = est;
+           this.expectedModCount = expectedModCount;
+       }
+
+       final int getEst() {
+           int s; // force initialization
+           final LinkedList<E> lst;
+           if ((s = est) < 0) {
+               if ((lst = list) == null)
+                   s = est = 0;
+               else {
+                   expectedModCount = lst.modCount;
+                   current = lst.first;
+                   s = est = lst.size;
+               }
+           }
+           return s;
+       }
+
+       public long estimateSize() { return (long) getEst(); }
+
+       public Spliterator<E> trySplit() {
+           Node<E> p;
+           int s = getEst();
+           if (s > 1 && (p = current) != null) {
+               int n = batch + BATCH_UNIT;
+               if (n > s)
+                   n = s;
+               if (n > MAX_BATCH)
+                   n = MAX_BATCH;
+               Object[] a = new Object[n];
+               int j = 0;
+               do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
+               current = p;
+               batch = j;
+               est = s - j;
+               return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
+           }
+           return null;
+       }
+
+       public void forEachRemaining(Consumer<? super E> action) {
+           Node<E> p; int n;
+           if (action == null) throw new NullPointerException();
+           if ((n = getEst()) > 0 && (p = current) != null) {
+               current = null;
+               est = 0;
+               do {
+                   E e = p.item;
+                   p = p.next;
+                   action.accept(e);
+               } while (p != null && --n > 0);
+           }
+           if (list.modCount != expectedModCount)
+               throw new ConcurrentModificationException();
+       }
+
+       public boolean tryAdvance(Consumer<? super E> action) {
+           Node<E> p;
+           if (action == null) throw new NullPointerException();
+           if (getEst() > 0 && (p = current) != null) {
+               --est;
+               E e = p.item;
+               current = p.next;
+               action.accept(e);
+               if (list.modCount != expectedModCount)
+                   throw new ConcurrentModificationException();
+               return true;
+           }
+           return false;
+       }
+
+       public int characteristics() {
+           return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
+       }
+   }
+  
+```  
\ No newline at end of file