【两万字】面试官：听说你精通集合源码，接我二十个问题！

Collection<String> c = ...;
Iterator<String> iter = c.iterator();
while (iter.hasNext()) {
    String s = iter.next();
    System.out.println(s);
}

//适用于JDK1.8以后的版本
iter.forEachRemaining(element -> System.out.println(element));

Collection<String> c = ...;
Iterator<String> iter = c.iterator();
iter.next();
iter.remove();

iter.remove();
iter.next();
iter.remove();

iter.remove();
iter.remove();

public interface Iterable<T> {
   
    Iterator<T> iterator();
    
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Collection<String> collection = ...;
collection.forEach(String s -> System.out.println(s));

    
    /**
    * 分配了一个等大空间的数组，然后依次对数组元素进行赋值
    */
    public Object[] toArray() {
        //新建等大的数组
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            //判断是否遍历结束，以防多线程操作的时候集合变得更小
            if (! it.hasNext()) 
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
         //判断是否遍历未结束，以防多线程操作的时候集合变得更大，进行扩容
        return it.hasNext() ? finishToArray(r, it) : r;
    }


    /**
    * 泛型方法的`toArray(T[] a)`方法在处理里，会先判断参数数组的大小，
    * 如果空间足够就使用参数作为元素存储，如果不够则新分配一个。
    * 在循环中的判断也是一样，如果参数a能够存储则返回a,如果不能再新分配。
    */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        int size = size();
        //当数组a的长度大于等于a，直接将a赋予给r，否则使用反射API获取一个长度为size的数组
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            //判断是否遍历结束
            if (! it.hasNext()) { 
                //如果 a == r，将r的每项值赋空，并将a返回
                if (a == r) {
                    r[i] = null;
                } else if (a.length < i) {
                    //如果a的长度小于r，直接调用Arrays.copyOf进行复制获取一个新的数组
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            //如果遍历结束，将迭代器获取的值赋给r
            r[i] = (T)it.next();
        }
        //判断是否遍历未结束，以防多线程操作的时候集合变得更大，进行扩容
        return it.hasNext() ? finishToArray(r, it) : r;
    }
    
    /**
    * 设定该容器的最大值
    */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
    *   用于动态扩容
    */
    @SuppressWarnings("unchecked")
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

//参数original代表你传入的需要复制的泛型数组，newLength复制得到数组的大小
public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

 //src数组里从索引为srcPos的元素开始, 复制到数组dest里的索引为destPos的位置, 复制的元素个数为length个. 
 public static native void arraycopy(Object src, int srcPos, Object dest, int destPos,int length);

package java.util.function;

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

List<String> strList = new ArrayList<>();
strList.add("Hungary");
strList.add("Foolish");

strList.replaceAll(t -> "Stay " + t);
strList.forEach(s -> System.out.println(s));

List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
 
humans.sort((Human h1, Human h2) -> h1.getName().compareTo(h2.getName()))

public static <T> void sort(T[] a, Comparator<? super T> c) {
    if (c == null) {
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

   //由于该集合是不可变的，所以一切可能会改变集合元素的操作都会抛出一个UnsupportedOperationException()
    public E set(int index, E element) {
        throw new UnsupportedOperationException();
    }

    //获取某个元素在集合中的索引
    public int indexOf(Object o) {
        //这里是由AbstractList内部已经提供了Iterator, ListIterator迭代器的实现类，分别为Itr，ListItr。这里是调用了一个实例化ListItr的方法
        ListIterator<E> it = listIterator();
        if (o == null) {
            while (it.hasNext())
                if (it.next()==null)
                    return it.previousIndex();
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return it.previousIndex();
        }
        //如果集合中不存在该元素，返回-1
        return -1;
    }

    /**
     * 内部实现了Iterator接口的实现类Itr
     */
    private class Itr implements Iterator<E> {
       
        //光标位置
        int cursor = 0;
  
        //上一次迭代到的元素的光标位置，如果是末尾会置为-1
        int lastRet = -1;
 
        //并发标志，如果两个值不一致，说明发生了并发操作，就会报错
        int expectedModCount = modCount;

        //删除上一次迭代器越过的元素
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
          //调用需要子类去实现的remove方法
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                //每次删除后，将lastRet置为-1，防止连续的删除
                lastRet = -1;
                //将修改次数赋给迭代器对对象的结构修改次数这个会在下面进行详解
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                //如果出现索引越界，说明发生了并发的操作导致，所以抛出一个并发操作异常。
                throw new ConcurrentModificationException();
            }
        }

        //判断是否发生了并发操作
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    //继承自Itr的ListIterator的实现类ListItr
    private class ListItr extends Itr implements ListIterator<E> {

        //获取上一位的元素，这里在后面会有画图帮助理解
        public E previous() {
            checkForComodification();
            try {
                //这里和父类的写法略有不同，先将光标的位置进行减一
                int i = cursor - 1;
                E previous = get(i);
                //因为需要返回的是前一位的元素，所以这里的光标值和上一次迭代到的光标的位置实际上是一样的
                lastRet = cursor = i;
                return previous;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        //设置元素
        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                //默认设置的位置是上一次迭代器越过的元素
                AbstractList.this.set(lastRet, e);
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
  
        //添加元素
        public void add(E e) {
            checkForComodification();
            try {
                //设置添加的位置为当前光标所在的位置
                int i = cursor;
                AbstractList.this.add(i, e);
                //这里讲lastRet设置为-1，即添加的元素不允许立即删除
                lastRet = -1;
                //添加后，将光标移到
                cursor = i + 1;
                //迭代器并发标志和集合并发标志统一
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                //如果出现了索引越界，说明发生了并发操作
                throw new ConcurrentModificationException();
            }
        }
    }

    //切取子List
    public List<E> subList(int fromIndex, int toIndex) {
        //是否支持随机访问
        return (this instanceof RandomAccess ?
                new RandomAccessSubList<>(this, fromIndex, toIndex) :
                new SubList<>(this, fromIndex, toIndex));
    }

    //使用迭代器成段删除集合中的元素
    protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
    }
}

//继承自AbstractList的内部类SubList，代表了它父类的一部分
class SubList<E> extends AbstractList<E> {
   
    private final AbstractList<E> l;
    private final int offset;
    private int size;

    //根据父类来构造一个SubList
    SubList(AbstractList<E> list, int fromIndex, int toIndex) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > list.size())
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
        l = list;
        offset = fromIndex;
        size = toIndex - fromIndex;
        //修改次数（并发标志）和父类保持一致
        this.modCount = l.modCount;
    }

    //实际上还是调用的父类的set方法和get方法
    public E set(int index, E element) {
        rangeCheck(index);
        checkForComodification();
        return l.set(index+offset, element);
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        checkForComodification();
        //实际上还是在父类上进行添加
        l.add(index+offset, element);
        this.modCount = l.modCount;
        //然后把size + 1
        size++;
    }
}

//相较于SubList内部类，多了一个是否可以随机访问的标志
class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
    RandomAccessSubList(AbstractList<E> list, int fromIndex, int toIndex) {
        super(list, fromIndex, toIndex);
    }

    public List<E> subList(int fromIndex, int toIndex) {
        return new RandomAccessSubList<>(this, fromIndex, toIndex);
    }
}

   //下一位的索引值等于光标值
        public int nextIndex() {
            return cursor;
        }

        //上一位的索引值等于光标值减一
        public int previousIndex() {
            //其实这里并不理解，为啥不去检查索引越界。。
            return cursor-1;
        }

//获取上一位的元素，这里在后面会有画图帮助理解
public E previous() {
    checkForComodification();
    try {
        //这里和父类的写法略有不同，先将光标的位置进行减一
        int i = cursor - 1;
        E previous = get(i);
        //因为需要返回的是前一位的元素，所以这里的光标值和上一次迭代到的光标的位置实际上是一样的
        lastRet = cursor = i;
        return previous;
    } catch (IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

//这个变量是transient的，也就说序列化的时候是不需要储存的 
protected transient int modCount = 0;

 //删除上一次迭代器越过的元素
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
          //调用需要子类去实现的remove方法
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                //每次删除后，将lastRet置为-1，防止连续的删除
                lastRet = -1;
                //将修改次数赋给迭代器对对象的结构修改次数这个会在下面进行详解
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                //如果出现索引越界，说明发生了并发的操作导致，所以抛出一个并发操作异常。
                throw new ConcurrentModificationException();
            }
        }

public class Stack<E> extends Vector<E> {

    /**
     * Stack的无参构造函数
     */
    public Stack() {
    }

    /**
     * 把项压入堆栈顶部
     */
    public E push(E item) {
        addElement(item);
        return item;
    }

    /**
     * 移除堆栈顶部的对象，并作为此函数的值返回该对象。
     * @return  被移除的对象
     */
    public synchronized E pop() {
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    /**
     * 查看堆栈顶部的对象
     * @return
     */
    public synchronized E peek() {
        int len = size();
        if (len == 0) {
            throw new EmptyStackException();
        }
        return elementAt(len - 1);
    }

    /**
     * 测试堆栈是否为空
     * @return
     */
    public boolean empty() {
        return size() == 0;
    }

    /**
     * 返回对象在堆栈中的位置，以 1 为基数
     * @param o 需要查找位置的对象
     * @return
     */
    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

    /**
     * 版本id
     */
    private static final long serialVersionUID = 1224463164541339165L;

}

    /**
     * 共享空数组对象
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 和上面的区别在于，
     * 第一次添加元素时知道该 elementData 从空的构造函数还是有参构造函数被初始化的。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

 /**
     * 用于盛放集合元素的数组对象
     */
    transient Object[] elementData;

 /**
     * 有参构造，参数为初始长度，如果参数为0，调用EMPTY_ELEMENTDATA来初始化
     *
     * @param  initialCapacity  该集合的初始化长度
     * @throws IllegalArgumentException 如果参数小于0，抛出该错误
     */
    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);
        }
    }

    /**
     * 无参构造，调用了DEFAULTCAPACITY_EMPTY_ELEMENTDATA来初始化
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

 
 /**
     * 提升该ArrayList对象容器的容量，确保可以提供一个该容器存放数据最低所需的容量
     *
     * @param   minCapacity   最低所需容量
     */
    public void ensureCapacity(int minCapacity) {
        //这里可以看出，如果是默认的无参构造，最低容量是10，如果不是，最小是0。这里体现了代码设计的严谨性！
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0: DEFAULT_CAPACITY;
        //如果最低所需的容量大于容器初始的最小容量，去调用扩容的方法，这里就体现出了两个不同常量的作用
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }


    /**
     * 计算最小所需容量
     * @param elementData   需要计算的数组
     * @param minCapacity   期望的最小所需容量
     * @return  最小所需容量
     */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //判断该容器是否是默认无参构造，如果不是，直接返回传入的minCapacity
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //如果是，返回默认容量和期望的最小所需容量中的最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    /**
     * 扩容到最小所需容量方法
     * @param minCapacity   最小容量
     */
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
     * 扩容到最小所需容量的方法，这里的参数是经过计算后的最小容量
     * @param minCapacity   经过计算后的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
        //这里关于modCount的疑问可以去看前面AbstractList中的实现
        modCount++;
        //这里进行一个关于最小容量和数组的长度比较，如果最小容量大于数组的长度，才会进行扩容
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }

    /**
     * 数组的最大容量
     * 因为数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8 byte
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 动态扩容，确保数组的容量可以装下所有的元素
     *
     * @param 最低容量
     */
    private void grow(int minCapacity) {
        //首先获取当前的数组的容量
        int oldCapacity = elementData.length;
        //将数组扩容50%，比如原容量是4，扩容后为 4 + 4 / 2 = 6
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果扩容后的容量小于最小所需的容量
        if (newCapacity - minCapacity < 0) {
            //直接将最小容量作为该容器的容量
            newCapacity = minCapacity;
        }
        //如果扩容后的容量大于数组最大的容量
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            //将经过处理后的最小所需容量作为新的容量，最大不超过Integer的最大值
            newCapacity = hugeCapacity(minCapacity);
        }
        //使用Arrays.copyOf将原数组复制到一个新容量的数组，并将拷贝的结果返回给原数组，完成动态扩容。
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
     * 防止数组的容量过大导致内存溢出的方法，程序基本上不会走到这里，只是以防万一
     * @param minCapacity
     * @return
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) {
            throw new OutOfMemoryError();
        }
        //如果最小所需容量大于数组最大容量，返回Integer的最大值，否则返回数组的最大容量值
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

  /**
     * 清除集合中的空元素所占的空间，一般在动态扩容后会产生空余的空间
     */
    public void trimToSize() {
        modCount++;
        //如果数组中数据的个数小于数组所占的空间，说明产生了多余的空间
        if (size < elementData.length) {
            //如果没有数据，返回一个EMPTY_ELEMENTDATA对象，否则将数据拷贝一个新的size长度的数组，并赋给原数组
            elementData = (size == 0)
                    ? EMPTY_ELEMENTDATA
                    : Arrays.copyOf(elementData, size);
        }
    }

 /**
     * 返回用于存储元素的数组位于某个索引上的元素
     * @param index 需要返回元素的索引
     * @return  返回该索引位置上的元素
     */
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 返回该集合指定位置的元素
     *
     * @param  index 需要返回元素的索引
     * @return 该集合指定位置的元素
     * @throws IndexOutOfBoundsException 当索引超过集合的长度时，抛出该异常
     */
    @Override
    public E get(int index) {
        //这一步调用的是检查索引越界的方法
        rangeCheck(index);
        //这一步调用的是上面的elementData()方法，本质上还是根据索引去用于存储数据的数组中取
        return elementData(index);
    }

src:源数组；
srcPos:源数组要复制的起始位置；
dest:目的数组；
destPos:目的数组放置的起始位置；
length:复制的长度。

 /**
     * 删除位于某个索引位置的元素
     *
     * @param index 即将被删除的元素的索引
     * @return 返回的是被删除的元素
     * @throws IndexOutOfBoundsException 当索引超过集合的长度时，抛出该异常
     */
    @Override
    public E remove(int index) {
        //首先进行索引越界的检查
        rangeCheck(index);
        //由于这个操作会引起结构的变化，所以要将modCount+1
        modCount++;
        //获取原本位于该位置的元素，用于返回
        E oldValue = elementData(index);
        //获取位于被删除索引的前一位的索引
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            //这里的原理是 elementData = {1 ,2 ,3 ,4} ===>
            // 删除索引为1 的元素，然后 0(numMoved)的元素{1}作为头，将{3, 4}(index+1)后的部分拼接到原本的index的位置 ==>
            // {1, 3, 4}，
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        }
        //将原本最后一位，置为null ==> {1,3,4,null},再将size-1，完成删除
        elementData[--size] = null;
        return oldValue;
    }

    /**
     * 删除集合中的指定元素，如果集合中包含该元素，返回true
     *
     * @param o 被删除的元素
     * @return 如果集合中包含该指定元素，返回true
     */
    @Override
    public boolean remove(Object o) {
        //分为两种情况 为null和不为null
        if (o == null) {
            for (int index = 0; index < size; index++) {
                //为null的时候使用 == 判断
                if (elementData[index] == null) {
                    //这里调用的这个方法其实和上面的方法类似，只不过没有返回值，而且没有进行索引的判断
                    fastRemove(index);
                    return true;
                }
            }
        } else {
            for (int index = 0; index < size; index++) {
                //不为null的时候使用 equals 判断
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 这里没有进行索引的越界判断，也没有返回被删除的值，其他的原理和remove(int index)类似
     * @param index 被删除元素的索引，这里之所以不用判断，是因为在调用这个方法的时候就已经进行了判断，不存在越界的可能
     */
    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;
    }

 /**
     * 删除指定集合与collection的交集
     *
     * @param c 需要与集合进行判断的collection
     * @return 如果这次操作改变了集合的结构，返回true
     * @throws ClassCastException 如果集合的元素类型和该集合的元素类型不一致，抛出该异常
     * @throws NullPointerException 如果参数collection为空，抛出空指针异常
     */
    @Override
    public boolean removeAll(Collection<?> c) {
        //首先进行非空校验
        Objects.requireNonNull(c);
        //调用封装好的批量删除的方法，这里传入的参数为false的时候，删除的是交集
        return batchRemove(c, false);
    }

    /**
     * 删除collection元素和该集合交集之外的元素
     *
     * @param c 需要将元素保留在该集合中的collection对象
     * @return 如果这次操作改变了集合，返回true
     * @throws ClassCastException 如果该集合的元素类型和collection中的元素不一致，抛出该异常
     * @throws NullPointerException 如果collection中的元素为空,抛出该异常
     */
    @Override
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        //调用封装好的批量删除的方法，这里传入的参数为true的时候，保留的是交集
        return batchRemove(c, true);
    }

    /**
     * 批量删除的方法
     * @param c 需要和原集合进行对比的collection对象
     * @param complement    为false的时候，删除交集，为true的时候，取交集，删除其他
     * @return
     */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        //下面我写了一个小例子帮助大家理解
        //假设原集合数组为{1,2,3,4}，c为{2,3}
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //size = 4
            for (; r < size; r++) {
                //a.当complement为false，r = 0 和 3 的时候会进入循环
                //b.当complement为true，r = 1 和 2 的时候会进入循环
                if (c.contains(elementData[r]) == complement) {
                    //r = 0 w = 0 elementData[0] = elementData[0]  {1,2,3,4}
                    //r = 3 w = 1 elementData[1] = elementData[3] {1,4,3,4}
                    // r = 1 w = 0 elementData[0] = elementData[1] {2,2,3,4}
                    //r = 2 w = 1 elementData[1] = elementData[2] {2,3,3,4}
                    elementData[w++] = elementData[r];
                }
            }
        } finally {
            //如果contains方法使用过程报异常,将剩余的元素赋给该集合，如果不出现异常的话，是不会进入这个代码块的
            if (r != size) {
                System.arraycopy(elementData, r,
                        elementData, w,
                        size - r);
                w += size - r;
            }
            // w = 2
            if (w != size) {
                for (int i = w; i < size; i++) {
                    //a. elementData[2] = null, elementData[3] = null {1,4,null,null},null元素会被垃圾回收器回收么？
                    //b. elmentData[2] = null, elementData[3] = null {2,3,null,null}
                    elementData[i] = null;
                }
                //修改次数+2
                modCount += size - w;
                //当前的数组数量就是符合条件的元素数量
                size = w;
                //返回操作成功的标志
                modified = true;
            }
        }
        return modified;
    }

/**
 * 遍历集合，这里的参数是一个函数式接口，可以结合Lambda表达式去优雅的使用
 * @param action    进行的操作，函数式接口
 */
default void forEach(BiConsumer<? super K, ? super V> action) {
    Objects.requireNonNull(action);
    //其实本质上还是用entrySet()获取键值对后进行遍历的
    for (Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

   /**
         * 根据映射的键进行排序
         */
        public static <K extends Comparable<? super K>, V> Comparator<Entry<K,V>> comparingByKey() {
            return (Comparator<Entry<K, V>> & Serializable)
                    (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }

   /**
         * 通过指定的比较器根据映射的键进行排序
         */
        public static <K, V> Comparator<Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Entry<K, V>> & Serializable)
                    (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }

public class Test {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();
        map.put("A","test1");
        map.put("B","test2");
        map.put("E","test5");
        map.put("D","test4");
        map.put("C","test3");
        Stream<Map.Entry<String, String>> sorted = map.entrySet().stream().sorted(Map.Entry.comparingByKey());
        Stream<Map.Entry<String, String>> sorted2 = map.entrySet().stream().sorted(Map.Entry.comparingByKey(String::compareTo));
        sorted.forEach(entry -> System.out.println(entry.getValue()));
        System.out.println("===============");
        sorted2.forEach(entry -> System.out.println(entry.getValue()));
    }
}

test1
test2
test3
test4
test5
===============
test1
test2
test3
test4
test5

 /**
     * 对映射中的所有键值对执行计算，并将返回结果作为value覆盖
     * map.replaceAll((k,v)->((String)k).length());
     * @param function  执行的操作，函数式接口
     */
    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        ...
    }

 /**
     * 当且仅当 key 存在，并且对应值与 oldValue 不相等，才用 newValue 作为 key 的新相关联值，返回值为是否进行了替换。
     * @param key   与指定值相关联的键
     * @param oldValue  预期与指定键相关联的值
     * @param newValue  与指定键相关联的值
     * @return  如果该值被替换，返回true
     */
    default boolean replace(K key, V oldValue, V newValue) {
        ...
    }


    /**
     * 只有当目标映射到某个值时，才能替换指定键的条目。
     * @param key    与指定值相关联的键
     * @param value 与指定键相关联的值
     * @return  与指定键相关联的上一个值，如果没有键的映射，返回null
     */
    default V replace(K key, V value) {
       ...
    }

 public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();
        map.put("A","test1");
        map.put("B","test2");
        map.replaceAll((s, s2) -> {
            return s + s2;
        });
        printMap(map);
        map.replace("A","test1");
        printMap(map);
        map.replace("A","test2","test1");
        printMap(map);
        map.replace("A","test1","test2");
        printMap(map);
    }

    public static void printMap(Map<String,String> map){
       map.forEach((key, value) -> System.out.print(key + ":" + value + "    "));
        System.out.println();
    }

A:Atest1    B:Btest2    
A:test1    B:Btest2    
A:test1    B:Btest2    
A:test2    B:Btest2    

 /**
     * 如果指定的键尚未与值相关联（或映射到null），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非null 。
     * @param key   指定值与之关联的键
     * @param mappingFunction   计算值的函数
     * @return  与指定键相关联的当前（现有或计算）值，如果计算值为空，则为null
     */
    default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
       ...
    }

    /**
     * 如果指定的key的值存在且非空，则尝试计算给定键及其当前映射值的新映射。
     * @param key   指定值与之关联的键
     * @param remappingFunction 计算值的函数
     * @return  与指定键相关的新值，如果没有则为null
     */
    default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    ...
    }


    /**
     * 尝试计算指定key及其当前映射值的映射（如果没有当前映射，则null ）。
     * @param key   指定值与之关联的键
     * @param remappingFunction 计算值的函数
     * @return 与指定键相关的新值，如果没有则为null
     */
    default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
       ...
    }

 public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();
        map.put("A","test1");
        map.put("B","test2");
        map.compute("A", (key, value) -> { return key + value;});
        printMap(map);
        //因为，集合中存在“A”，所以这里没有进行相应的操作
        map.computeIfAbsent("A", (key) -> { return key + 2;});
        printMap(map);
      //这里因为集合中不存在“C”，所以进行了赋值的操作
        map.computeIfAbsent("C", (key) -> { return key + 2;});
        printMap(map);
      //这里由于集合存在“A”，根据方法定义，会计算后返回给原值
        map.computeIfPresent("A", (key, value) -> { return key + value;});
        printMap(map);
      //这里由于不存在“D”，根据方法定义，不做任何操作
       map.computeIfPresent("D", (key, value) -> { return key + value;});
        printMap(map);
    }

    public static void printMap(Map<String,String> map){
       map.forEach((key, value) -> System.out.print(key + ":" + value + "    "));
        System.out.println();
    }

A:Atest1    B:test2    
A:Atest1    B:test2    
A:Atest1    B:test2    C:C2    
A:AAtest1    B:test2    C:C2    
A:AAtest1    B:test2    C:C2  

 /**
     * 如果key在集合中的value为空或则键值对不存在，则用参数value覆盖
     * @param key   如果key存在且不为null，返回key对应的value，如果不存在，调用put(key,value)
     * @param value 如果key对应的值不存在或者为null，将该value与key进行对应
     * @return  返回的是被替代的值
     */
    default V putIfAbsent(K key, V value) {
       ...
    }
    
     /**
     * key 与 value 都匹配时才删除。
     * @param key   被删除的映射关系的key
     * @param value 被删除的映射关系的value
     * @return  返回的是否删除成功
     */
    default boolean remove(Object key, Object value) {
       ...
    }
    
     /**
     * 如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
     * @param key   结合值与之关联的键
     * @param value 要与与key相关联的现有值合并的非空值，或者如果没有现有值或空值与key相关联，则与该key相关联
     * @param remappingFunction 重新计算值（如果存在）的功能
     * @return 与指定键相关联的新值，如果没有值与该键相关联，则返回null
     */
    default V merge(K key, V value,
                    BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
      
    }

 public static void main(String[] args) {
        Map<String, String> map = new HashMap<String,String>();
        map.put("A","test1");
        map.put("B","test2");
        map.putIfAbsent("A","test2");
        map.putIfAbsent("C","test3");
        printMap(map);
        map.remove("A","test1");
        printMap(map);
        map.merge("A","test1",(oldValue, newValue) ->{
            return oldValue + newValue;
        } );
        printMap(map);
        map.merge("A","test4",(oldValue, newValue) ->{
            return  newValue;
        } );
        printMap(map);
    }

A:test1    B:test2    C:test3    
B:test2    C:test3    
A:test1    B:test2    C:test3    
A:test4    B:test2    C:test3 

/**
 * 返回 set 中的元素个数
 * @return  set中元素个数
 */
int size();

/**
 * 如果set中不包含任何元素，返回true
 * @return  如果set中不包含任何元素，返回true
 */
boolean isEmpty();

/**
 * 如果set包含指定的元素，则返回 true
 * @param o 指定的元素
 * @return  如果 set 包含指定的元素，则返回 true。
 */
boolean contains(Object o);

/**
 * 如果此 set 包含指定 collection 的所有元素，则返回 true。
 * 如果指定的 collection 也是一个 set，那么当该 collection 是此 set 的 子集 时返回 true。
 * @param c 检查是否包含在此 set 中的 collection
 * @return 如果此 set 包含指定 collection 中的所有元素，则返回 true
 */
boolean containsAll(Collection<?> c);

/**
 * 如果 set 中尚未存在指定的元素，则添加此元素
 * @param e 被添加的元素
 * @return  如果set中存在该元素，添加失败并返回false
 */
boolean add(E e);

/**
 * 如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中
 * 如果指定的 collection 也是一个 set，则 addAll 操作会实际修改此 set，
 * 这样其值是两个 set 的一个 并集。如果操作正在进行的同时修改了指定的 collection，则此操作的行为是不确定的。
 * @param c
 * @return
 */
boolean addAll(Collection<? extends E> c);

/**
 * 如果 set 中存在指定的元素，则将其移除（可选操作）。
 * @param o 被删除的元素
 * @return  如果此 set 包含指定的对象，则返回true
 */
boolean remove(Object o);

/**
 * 仅保留 set 中那些包含在指定 collection 中的元素，换句话说，只取两者交集，其余的不管
 * @param c 与set进行判断的集合
 * @return  如果此 set 由于调用而发生更改，则返回 true
 */
boolean retainAll(Collection<?> c);


/**
 * 移除 set 中那些包含在指定 collection 中的元素，也就是说，取交集之外的所有元素
 * @param c 与set进行判断的集合
 * @return  如果此 set 由于调用而发生更改，则返回 true
 */
boolean removeAll(Collection<?> c);


/**
 * 移除此 set 中的所有元素，此调用返回后该 set 将是空的。
 */
void clear();

/**
 * 可切割的迭代器，返回的是该set集合的可切割迭代器的一个实例
 * @return
 */
@Override
default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, Spliterator.DISTINCT);
}

/**
 * 从此 set 中移除包含在指定 collection 中的所有元素
 * 如果指定 collection 也是一个 set，则此操作有效地修改此 set，从而其值成为两个 set 的 不对称差集。
 *
 * @param c 包含将从此 set 中移除的元素的 collection
 * @return 如果此 set 由于调用而发生更改，则返回 true
 */
@Override
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    //通过在此 set 和指定 collection 上调用 size 方法，此实现可以确定哪一个更小。
    if (size() > c.size()) {
        // 如果此 set 中的元素更少，则该实现将在此 set 上进行迭代，依次检查迭代器返回的每个元素，查看它是否包含在指定的 collection 中。
        for (Iterator<?> i = c.iterator(); i.hasNext(); ) {
            //如果包含它，则使用迭代器的 remove 方法从此 set 中将其移除。
            modified |= remove(i.next());
        }
    } else {
        //如果指定 collection 中的元素更少，则该实现将在指定的 collection 上进行迭代，并使用此 set 的 remove 方法，从此 set 中移除迭代器返回的每个元素。
        for (Iterator<?> i = iterator(); i.hasNext(); ) {
            if (c.contains(i.next())) {
                i.remove();
                modified = true;
            }
        }
    }
    return modified;
}

static final int TREEIFY_THRESHOLD = 8;

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

static final int MAXIMUM_CAPACITY = 1 << 30;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

public V get(Object key) {
  Node<K,V> e;
  return (e = getNode(hash(key), key)) == null ? null : e.value;
}

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}