HashMap之keyset()方法底层原理解读

    public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new LinkedKeySet();
            keySet = ks;
        }
        return ks;
    }
 
    final class LinkedKeySet extends AbstractSet<K> {
        public final int size()                 { return size; }
        public final void clear()               { LinkedHashMap.this.clear(); }
        public final Iterator<K> iterator() {
            return new LinkedKeyIterator();
        }
        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 Spliterators.spliterator(this, Spliterator.SIZED |
                                            Spliterator.ORDERED |
                                            Spliterator.DISTINCT);
        }
        public final void forEach(Consumer<? super K> action) {
            if (action == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                action.accept(e.key);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

    final class LinkedKeyIterator extends LinkedHashIterator
        implements Iterator<K> {
        public final K next() { return nextNode().getKey(); }
    }

    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";
 
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

 /*
    * hashMap通过keyset遍历时，先调用keySet()方法，该方法返回hashMap中存储的key的集合ks,
    然后再执行内部类 final class KeySet extends AbstractSet<K>中的iterator()，iterator()
    返回一个HashMap.KeyIterator()对象，KeyIterator对象继承HashIterator且实现 Iterator<K>
      HashIterator的构造方法初始化时会把table中存储的元素赋值给临时node类型变量t,并通过循环
        do {} while (index < t.length && (next = t[index++]) == null);找到table中的第一个
        不为空的元素的前一个元素，赋值给next，
    KeyIterator对象实现 Iterator<K>接口的next方法，这样就能实现table中元素的遍历
    * HashIterator 中的nextNode()方法可以找到table中的第一个不为空的元素的前一个元素，赋值给next，
    * */
      public Set<K> keySet() {
        Set<K> ks = keySet; //keySet是hashMap的父类AbstractMap的成员变量，创建Set类型的ks对象，把keySet赋值给ks;
        if (ks == null) { //如果ks为空，创建一个KeySet对象，赋值给ks
            ks = new KeySet();
            keySet = ks;  //把ks再赋值赋值给成员变量keySet
        }
        return ks;       //返回ks
    }

/*
    * 定义一个不可变类KeySet，继承AbstractSet，重写它父类的父类AbstractCollection中的size()、
    * clear()\ iterator()\contains(Object o)\remove(Object key)\
    * spliterator()\forEach(Consumer<? super K> action) 方法
     * */
    final class KeySet extends AbstractSet<K> {
        public final int size()                 { return size; } //返回hashMap的成员变量size的长度
        public final void clear()               { HashMap.this.clear(); }//调用hashMap的clear方法，this表示调用clear()方法的hashMap对象
        public final Iterator<K> iterator()     { return new HashMap.KeyIterator(); }//创建一个KeyIterator对象，该对象继承HashIterator，implements Iterator<K>中的next方法，其它方法为啥不用实现？
        public final boolean contains(Object o) { return containsKey(o); }//调用hashMap的 containsKey(o)方法
        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null; //调用hashMap的 removeNode()方法
        }
        public final Spliterator<K> spliterator() {
            return new HashMap.KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }//返回一个KeySpliterator对象，KeySpliterator 继承 HashMapSpliterator<K,V>implements Spliterator<K>，调用父类的构造方法初始化对象
        //KeySpliterator的方法中调用它的父类HashMapSpliterator中的构造方法初始化对象
       public final void forEach(Consumer<? super K> action) {
            Node<K,V>[] tab; //定义Node类型的数组tab
            if (action == null)//如果action为空，抛出空指针异常
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) { //如果size大于0，把table赋值给tab,tab不为空
                int mc = modCount;//定义mc变量，把modCount赋值给mc,modCount记录hashMap修改次数
                for (Node<K, V> e : tab) { //遍历tab
                    for (; e != null; e = e.next) //循环条件e不为空，有next节点
                        action.accept(e.key);//调用Consumer中的accept(),传入key
                }
                if (modCount != mc) //如果modCount不等于mc，说明有其它线程修改这个hashMap,抛出异常
                    throw new ConcurrentModificationException();
            }
        }
    }

  final class KeyIterator extends HashMap.HashIterator
        implements Iterator<K>{
 
    @Override
    public K next() {
        return null;
    }
}