ConcurrentHashMap 源码分析02之内部类Traverser、View篇

1.3.8 TableStack<K,V>

• 保存当前正在遍历的数组以及索引信息

static final class TableStack<K,V> {
    int length; // 数组的长度
    int index;  // 存储遍历时的索引
    Node<K,V>[] tab; // 数组
    TableStack<K,V> next; // next 指针
}

1.3.9 Traverser<K,V>

• 主要用于遍历操作，有BaseIterator、KeySpliterator、ValueSpliterator、EntrySpliterator四个子类
• BaseIterator 用于遍历操作。KeySplitertor、ValueSpliterator、EntrySpliterator则用于键、值、键值对的划分。

static class Traverser<K,V> {
    Node<K,V>[] tab;        // 当前数组
    Node<K,V> next;         // 下一元素的指针
    /* stack 栈顶结点， spare 备用节点，可以理解为中继节点 */
    TableStack<K,V> stack, spare;
    int index;              // 下一个要读取的hash桶的下标
    int baseIndex;          // 起始的下标，下界
    int baseLimit;          // 终止的下标，上界
    final int baseSize;     // 数组的长度

	/* 构造函数：指定当前数组，新数组的长度，下界，上界 */
    Traverser(Node<K,V>[] tab, int size, int index, int limit) {
        this.tab = tab;
        this.baseSize = size;
        this.baseIndex = this.index = index;
        this.baseLimit = limit;
        this.next = null;
    }

    /* 获取下一元素，不存在则返回null */
    /* 这里如果遇到扩容，存储当前状态pushState(t, i, n)，等到扩容完成后，取出状态recoverState(n) */
    final Node<K,V> advance() {
        Node<K,V> e;
        /* 如果已经进入了一个非空的hash桶，直接尝试获取它的下一个节点 */
        if ((e = next) != null)
            e = e.next;
        for (;;) {
            Node<K,V>[] t; int i, n;  // must use locals in checks
            /* 下一节点不为 null，直接返回 */
            if (e != null)
                return next = e;
            /* 下界 >= 上界 || tab数组为空 || tab数组长度 <= 下界 || index < 0，没有新桶，返回 null  */    
            if (baseIndex >= baseLimit || (t = tab) == null ||
                (n = t.length) <= (i = index) || i < 0)
                return next = null;
            /* 桶位元素存在 && hash值 < 0，若此时为链表节点，e 已经赋值完毕 */    
            if ((e = tabAt(t, i)) != null && e.hash < 0) {
            	/* 是否为移动节点(正在扩容) */
                if (e instanceof ForwardingNode) {
                    tab = ((ForwardingNode<K,V>)e).nextTable;
                    e = null;
                    pushState(t, i, n); // 保存当前遍历状态
                    continue;
                }
                else if (e instanceof TreeBin)
                    e = ((TreeBin<K,V>)e).first; // 返回树的首节点
                else
                    e = null;
            }
            /* 弹出存储状态 */
            if (stack != null)
                recoverState(n);
            else if ((index = i + baseSize) >= n)
                index = ++baseIndex; // 这里的主要作用是 index++ 即指针往前移一位
        }
    }

    /* 保存当前遍历状态 */
    private void pushState(Node<K,V>[] t, int i, int n) {
        TableStack<K,V> s = spare;  // spare备用，减少 new 对象
        if (s != null)
            spare = s.next;
        else
            s = new TableStack<K,V>();
        s.tab = t;
        s.length = n;
        s.index = i;
        s.next = stack;
        stack = s;
    }

    /* 恢复存储时的状态 */
    private void recoverState(int n) {
        TableStack<K,V> s; int len;
        /* (index += (len = s.length)) >= n 这里的作用是 获取 tab[i+n] 位置的值 */
        while ((s = stack) != null && (index += (len = s.length)) >= n) {
        	/* 恢复成保存时的状态，以此循环尚未遍历的后序的值 */
        	/* 从这里可以看到，若添加在扩容前[index ~ len-1]后的值，可以遍历的到，但桶位之前的值不会遍历 */
            n = len;
            index = s.index;
            tab = s.tab;
            s.tab = null;
            /* stack 后移，存储spare备用 */
            TableStack<K,V> next = s.next;
            s.next = spare;
            stack = next;
            spare = s;
        }
        /* 获取完 stack 后，index指针后移 */
        if (s == null && (index += baseSize) >= n)
            index = ++baseIndex;
    }
}

1.3.10 BaseIterator

• 继承 Traverser，其子类有 KeyIterator、ValueIterator、EntryIterator。

static class BaseIterator<K,V> extends Traverser<K,V> {
    finalConcurrentHashMap<K,V> map;
    Node<K,V> lastReturned;
    BaseIterator(Node<K,V>[] tab, int size, int index, int limit,
                ConcurrentHashMap<K,V> map) {
        super(tab, size, index, limit);
        this.map = map;
        advance(); // 初始化父类的 next 指针
    }
	/* 是否有下一个元素 */
    public final boolean hasNext() { return next != null; }
    /* 这里是因为子类实现 接口Enumeration，在父类予以共同实现 */
    /* 是否有更多的元素，底层与hasNext()都是使用 next 指针判断 */
    public final boolean hasMoreElements() { return next != null; }
	/* 移除节点 */
    public final void remove() {
        Node<K,V> p;
        if ((p = lastReturned) == null)
            throw new IllegalStateException();
        lastReturned = null;
        /* param2 为要替换的value值，null即删除 */
        map.replaceNode(p.key, null, null);
    }
}

1.3.11 KeyIterator

• ket 值迭代器，继承 BaseIterator，实现 Enumeration

static final class KeyIterator<K,V> extends BaseIterator<K,V>
    implements Iterator<K>, Enumeration<K> {
    /* 构造函数：初始化属性值，这里的 index 与 size 应该是名字相反了，查看父类与调用构造器的参数可知，但不影响结果 */
    KeyIterator(Node<K,V>[] tab, int index, int size, int limit,
                ConcurrentHashMap<K,V> map) {
        super(tab, index, size, limit, map);
    }
	/* 获取下一个元素 */
    public final K next() {
        Node<K,V> p;
        if ((p = next) == null)
            throw new NoSuchElementException();
        K k = p.key;
        lastReturned = p;
        /* 将 next 指针指向下一元素 */
        advance();
        return k;
    }
	/* 获取下一个元素，底层调用next() */
    public final K nextElement() { return next(); }
}

1.3.12 ValueIterator<K,V>

• value 值迭代器，继承 BaseIterator，实现 Enumeration

static final class ValueIterator<K,V> extends BaseIterator<K,V>
    implements Iterator<V>, Enumeration<V> {
    /* 构造函数：初始化属性值，这里的 index 与 size 应该是名字相反了，查看父类与调用构造器的参数可知，但不影响结果 */
    ValueIterator(Node<K,V>[] tab, int index, int size, int limit,
                  ConcurrentHashMap<K,V> map) {
        super(tab, index, size, limit, map);
    }
	/* 获取下一个元素 */
    public final V next() {
        Node<K,V> p;
        if ((p = next) == null)
            throw new NoSuchElementException();
        V v = p.val;
        lastReturned = p;
        /* 将 next 指针指向下一元素 */
        advance();
        return v;
    }
	/* 获取下一个元素，底层调用next() */
    public final V nextElement() { return next(); }
}

1.3.13 EntryIterator<K,V>

• 键值对迭代器，继承 BaseIterator

static final class EntryIterator<K,V> extends BaseIterator<K,V>
    implements Iterator<Map.Entry<K,V>> {
    /* 构造函数：初始化属性值，这里的 index 与 size 应该是名字相反了，查看父类与调用构造器的参数可知，但不影响结果 */
    EntryIterator(Node<K,V>[] tab, int index, int size, int limit,
                  ConcurrentHashMap<K,V> map) {
        super(tab, index, size, limit, map);
    }
	/* 获取下一个元素 */
    public final Map.Entry<K,V> next() {
        Node<K,V> p;
        if ((p = next) == null)
            throw new NoSuchElementException();
        K k = p.key;
        V v = p.val;
        lastReturned = p;
        /* 将 next 指针指向下一元素 */
        advance();
        return new MapEntry<K,V>(k, v, map);
    }
}

1.3.14 MapEntry

• 该类为 EntryIterator 服务，导出 entry 节点，但不能被外部修改

static final class MapEntry<K,V> implements Map.Entry<K,V> {
    /* key,value 都不能为null */
    final K key;
    V val;
    final ConcurrentHashMap<K,V> map;
    /* 构造函数：初始化属性 */
    MapEntry(K key, V val, ConcurrentHashMap<K,V> map) {
        this.key = key;
        this.val = val;
        this.map = map;
    }
    public K getKey()        { return key; } // 获取 key
    public V getValue()      { return val; } // 获取 value
    /* 重写 hashcode，toString，equals 方法 */
    public int hashCode()    { return key.hashCode() ^ val.hashCode(); }
    public String toString() { return key + "=" + val; }
    public boolean equals(Object o) {
        Object k, v; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == val || v.equals(val)));
    }

    /* 设置新值，返回旧值 */
    public V setValue(V value) {
        if (value == null) throw new NullPointerException();
        V v = val;
        val = value;
        map.put(key, value); // 这里使用的是MapEntry, 需要使用put去更新Node的值
        return v;
    }
}

1.3.15 KeySpliterator

• key 值的分解迭代器，继承 Traverser

static final class KeySpliterator<K,V> extends Traverser<K,V>
    implements Spliterator<K> {
    long est; // 大致个数
    /* 构造函数：初始化属性 */
    KeySpliterator(Node<K,V>[] tab, int size, int index, int limit,
                   long est) {
        super(tab, size, index, limit);
        this.est = est;
    }
	/* 分解方法 */
    public Spliterator<K> trySplit() {
        int i, f, h;
        /* 分离出 h，f 的迭代器  */
        return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null :
            new KeySpliterator<K,V>(tab, baseSize, baseLimit = h,
                                    f, est >>>= 1);
    }
	/* 遍历未遍历的元素，执行 action 动作 */
    public void forEachRemaining(Consumer<? super K> action) {
        if (action == null) throw new NullPointerException();
        for (Node<K,V> p; (p = advance()) != null;)
            action.accept(p.key);
    }
	/* 未遍历的第一个元素执行 action 动作 */
    public boolean tryAdvance(Consumer<? super K> action) {
        if (action == null) throw new NullPointerException();
        /* 没有下一元素，返回false，若存在，执行 action 动作后，返回true */
        Node<K,V> p;
        if ((p = advance()) == null)
            return false;
        action.accept(p.key);
        return true;
    }
	/* 返回大致个数 */
    public long estimateSize() { return est; }
	/* 返回特征值 */
    public int characteristics() {
        return Spliterator.DISTINCT | Spliterator.CONCURRENT |
            Spliterator.NONNULL;
    }
}

1.3.16 ValueSpliterator

• value 值的分解迭代器，继承 Traverser

static final class ValueSpliterator<K,V> extends Traverser<K,V>
   implements Spliterator<V> {
	long est; // 大致个数
	/* 构造函数：初始化属性值 */
	ValueSpliterator(Node<K,V>[] tab, int size, int index, int limit,
	                long est) {
	   super(tab, size, index, limit);
	   this.est = est;
	}
	/* 分解方法：分割出 h~f 的迭代器 */
	public Spliterator<V> trySplit() {
	   int i, f, h;
	   return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null :
	       new ValueSpliterator<K,V>(tab, baseSize, baseLimit = h,
	                                 f, est >>>= 1);
	}
	/* 遍历未遍历的元素，执行 action 动作 */
	public void forEachRemaining(Consumer<? super V> action) {
	   if (action == null) throw new NullPointerException();
	   for (Node<K,V> p; (p = advance()) != null;)
	       action.accept(p.val);
	}
	/* 未遍历的第一个元素执行 action 动作 */
	public boolean tryAdvance(Consumer<? super V> action) {
	   if (action == null) throw new NullPointerException();
	   Node<K,V> p;
	   /* 没有下一元素，返回false，若存在，执行 action 动作后，返回true */
	   if ((p = advance()) == null)
	       return false;
	   action.accept(p.val);
	   return true;
	}
	/* 返回大致个数 */
	public long estimateSize() { return est; }
	/* 返回特征值 */	
	public int characteristics() {
	   return Spliterator.CONCURRENT | Spliterator.NONNULL;
	}
}

1.3.17 EntrySpliterator

• entry 的分解迭代器，继承 Traverser

static final class EntrySpliterator<K,V> extends Traverser<K,V>
    implements Spliterator<Map.Entry<K,V>> {
    final ConcurrentHashMap<K,V> map; // To export MapEntry
    long est;               // 大致个数
    /* 构造函数：初始化属性值 */
    EntrySpliterator(Node<K,V>[] tab, int size, int index, int limit,
                     long est, ConcurrentHashMap<K,V> map) {
        super(tab, size, index, limit);
        this.map = map;
        this.est = est;
    }
	/* 分解方法：分割出 h~f 的迭代器 */
    public Spliterator<Map.Entry<K,V>> trySplit() {
        int i, f, h;
        return (h = ((i = baseIndex) + (f = baseLimit)) >>> 1) <= i ? null :
            new EntrySpliterator<K,V>(tab, baseSize, baseLimit = h,
                                      f, est >>>= 1, map);
    }
	/* 遍历未遍历的元素，执行 action 动作 */
    public void forEachRemaining(Consumer<? super Map.Entry<K,V>> action) {
        if (action == null) throw new NullPointerException();
        for (Node<K,V> p; (p = advance()) != null; )
            action.accept(new MapEntry<K,V>(p.key, p.val, map));
    }
	/* 未遍历的第一个元素执行 action 动作 */
    public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {
        if (action == null) throw new NullPointerException();
        Node<K,V> p;
        /* 没有下一元素，返回false，若存在，执行 action 动作后，返回true */
        if ((p = advance()) == null)
            return false;
        action.accept(new MapEntry<K,V>(p.key, p.val, map));
        return true;
    }
	/* 返回大致个数 */
    public long estimateSize() { return est; }
	/* 返回特征值 */
    public int characteristics() {
        return Spliterator.DISTINCT | Spliterator.CONCURRENT |
            Spliterator.NONNULL;
    }
}

1.3.18 CollectionView

• 主要定义了视图操作，其子类KeySetView、ValueSetView、EntrySetView分别表示键视图、值视图、键值对视图

abstract static class CollectionView<K,V,E>
    implements Collection<E>, java.io.Serializable {
    private static final long serialVersionUID = 7249069246763182397L;
    final ConcurrentHashMap<K,V> map;
    /* 构造函数：初始化map集合 */
    CollectionView(ConcurrentHashMap<K,V> map)  { this.map = map; }

    /* 获取当前 map 集合 */
    public ConcurrentHashMap<K,V> getMap() { return map; }

    /* 清空map，获取size，是否为空， 当前视图与map使用的同一地址，修改会同步进行 */
    public final void clear()      { map.clear(); }
    public final int size()        { return map.size(); }
    public final boolean isEmpty() { return map.isEmpty(); }
    
    /* 定义抽象函数：获取迭代器，是否包含元素，移除元素，由子类实现 */
    public abstract Iterator<E> iterator();
    public abstract boolean contains(Object o);
    public abstract boolean remove(Object o);

	/* OOM 报错信息 */
    private static final String oomeMsg = "Required array size too large";
	/* 集合转换成 Object 数组 */
    public final Object[] toArray() {
        long sz = map.mappingCount(); // 计算map 的 size 
        if (sz > MAX_ARRAY_SIZE) // 个数过多
            throw new OutOfMemoryError(oomeMsg);
        int n = (int)sz;
        /* 新建长度n 的新Object数组 */
        Object[] r = new Object[n];
        int i = 0;
        /* 循环赋值 */
        for (E e : this) {
        	/* 若出现 i == n */
            if (i == n) {
            	/* 再次进行个数判断 */
                if (n >= MAX_ARRAY_SIZE)
                    throw new OutOfMemoryError(oomeMsg);
                /* n > 最大数组大小的一半 - 1 则使用最大数组大小 */    
                if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
                    n = MAX_ARRAY_SIZE;
                else
                    n += (n >>> 1) + 1; // 扩容1.5倍 + 1
                r = Arrays.copyOf(r, n); // 扩容数组长度
            }
            r[i++] = e;
        }
        /* 若 i != n，则表示在赋值过程中出现中断，则重新赋值 */
        return (i == n) ? r : Arrays.copyOf(r, i);
    }
    
	/* 指定泛型数组的map转化数组 */
    @SuppressWarnings("unchecked")
    public final <T> T[] toArray(T[] a) {
        long sz = map.mappingCount();
        if (sz > MAX_ARRAY_SIZE)
            throw new OutOfMemoryError(oomeMsg);
        int m = (int)sz;
        /* 传入的数组a 长度比 m 大，使用 a 的长度，否则，反射创建长度为m的数组 */
        T[] r = (a.length >= m) ? a :
            (T[])java.lang.reflect.Array
            .newInstance(a.getClass().getComponentType(), m);
        int n = r.length;
        int i = 0;
        /* 循环赋值 */
        for (E e : this) {
            if (i == n) {
                if (n >= MAX_ARRAY_SIZE)
                    throw new OutOfMemoryError(oomeMsg);
                if (n >= MAX_ARRAY_SIZE - (MAX_ARRAY_SIZE >>> 1) - 1)
                    n = MAX_ARRAY_SIZE;
                else
                    n += (n >>> 1) + 1;
                r = Arrays.copyOf(r, n);
            }
            r[i++] = (T)e;
        }
        /* 使用a数组赋值 && map 长度 < a.length */
        if (a == r && i < n) {
            r[i] = null; // i下标元素置为 null，我也不知道为什么，可能是为了间隔赋值与原有的元素吧
            return r;
        }
        return (i == n) ? r : Arrays.copyOf(r, i);
    }

    /* 重写toString() */
    public final String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        Iterator<E> it = iterator();
        if (it.hasNext()) {
            for (;;) {
                Object e = it.next();
                sb.append(e == this ? "(this Collection)" : e);
                if (!it.hasNext())
                    break;
                sb.append(',').append(' ');
            }
        }
        return sb.append(']').toString();
    }
	/* 是否包含集合c内的所有元素 */
    public final boolean containsAll(Collection<?> c) {
    	/* 若集合c为当前map，直接返回true */
        if (c != this) {
        	/* 循环遍历集合c，不包含则返回false */
            for (Object e : c) {
                if (e == null || !contains(e))
                    return false;
            }
        }
        return true;
    }
	/* 移除 map中 与集合c 的相同的元素，没有发生移除则返回false */
    public final boolean removeAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();
        boolean modified = false;
        for (Iterator<E> it = iterator(); it.hasNext();) {
        	/* 集合c中包含该元素，则进行删除 */
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }
	/* 移除 map 中与集合c 不相同的元素，没有发生移除则返回false */
    public final boolean retainAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();
        boolean modified = false;
        for (Iterator<E> it = iterator(); it.hasNext();) {
        	/* 集合c中不包含该元素，则进行删除 */
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

}

1.3.19 KeySetView

• key 集合视图，继承 CollectionView

public static class KeySetView<K,V> extends CollectionView<K,V,K>
    implements Set<K>, java.io.Serializable {
    private static final long serialVersionUID = 7249069246763182397L;
    private final V value; // 用来当做创建节点时的value值
    KeySetView(ConcurrentHashMap<K,V> map, V value) {  // non-public
        super(map);
        this.value = value;
    }

    /* 获取 valuez 值 */
    public V getMappedValue() { return value; }

    /* map 是否包含对象 o */
    public boolean contains(Object o) { return map.containsKey(o); }

    /* 移除对象 o */
    public boolean remove(Object o) { return map.remove(o) != null; }

    /* 返回 key值的迭代器 */
    public Iterator<K> iterator() {
        Node<K,V>[] t;
        ConcurrentHashMap<K,V> m = map;
        int f = (t = m.table) == null ? 0 : t.length;
        return new KeyIterator<K,V>(t, f, 0, f, m);
    }

    /* 添加一个节点，传入key，当前value为添加的value值 */
    public boolean add(K e) {
        V v;
        if ((v = value) == null)
            throw new UnsupportedOperationException();
        /* param3: 为true不替换已有key的旧值 */    
        return map.putVal(e, v, true) == null;
    }

    /* 添加集合c内的元素，c作为key，当前value为添加的value值 */
    public boolean addAll(Collection<? extends K> c) {
        boolean added = false; // 没有发生添加返回 false
        V v;
        if ((v = value) == null)
            throw new UnsupportedOperationException();
        for (K e : c) {
        	/* param3: 为true不替换已有key的旧值 */
            if (map.putVal(e, v, true) == null)
                added = true;
        }
        return added;
    }
	/* 重写 hashCode 方法 */
    public int hashCode() {
        int h = 0;
        for (K e : this)
            h += e.hashCode();
        return h;
    }
	/* 重写 equals方法*/
    public boolean equals(Object o) {
        Set<?> c;
        return ((o instanceof Set) &&
                ((c = (Set<?>)o) == this ||
                 (containsAll(c) && c.containsAll(this))));
    }
	/* 获取key值的分解迭代器 */
    public Spliterator<K> spliterator() {
        Node<K,V>[] t;
        ConcurrentHashMap<K,V> m = map;
        long n = m.sumCount();  // 计算当前map元素个数
        int f = (t = m.table) == null ? 0 : t.length;
        return new KeySpliterator<K,V>(t, f, 0, f, n < 0L ? 0L : n);
    }
	/* 遍历未遍历的元素，执行 action 动作 */
    public void forEach(Consumer<? super K> action) {
        if (action == null) throw new NullPointerException();
        Node<K,V>[] t;
        if ((t = map.table) != null) {
            Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
            for (Node<K,V> p; (p = it.advance()) != null; )
                action.accept(p.key);
        }
    }
}

1.3.20 ValuesView

• value 值的视图，继承 CollectionView

static final class ValuesView<K,V> extends CollectionView<K,V,V>
    implements Collection<V>, java.io.Serializable {
    private static final long serialVersionUID = 2249069246763182397L;
    /* 构造函数：指定map */
    ValuesView(ConcurrentHashMap<K,V> map) { super(map); }
    /* 是否包含对象o */
    public final boolean contains(Object o) {
        return map.containsValue(o);
    }
	/* 移除对象o，没找到返回 false */
    public final boolean remove(Object o) {
        if (o != null) {
            for (Iterator<V> it = iterator(); it.hasNext();) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }
	/* 获取value值的迭代器 */
    public final Iterator<V> iterator() {
        ConcurrentHashMap<K,V> m = map;
        Node<K,V>[] t;
        int f = (t = m.table) == null ? 0 : t.length;
        return new ValueIterator<K,V>(t, f, 0, f, m);
    }
	/* 添加值抛错，因为这是value值视图，添加需要指定不同的key太麻烦，不指定又没意义 */
    public final boolean add(V e) {
        throw new UnsupportedOperationException();
    }
    public final boolean addAll(Collection<? extends V> c) {
        throw new UnsupportedOperationException();
    }
	/* 获取value值的分解迭代器 */
    public Spliterator<V> spliterator() {
        Node<K,V>[] t;
        ConcurrentHashMap<K,V> m = map;
        long n = m.sumCount(); // 计算当前map元素个数
        int f = (t = m.table) == null ? 0 : t.length;
        return new ValueSpliterator<K,V>(t, f, 0, f, n < 0L ? 0L : n);
    }
	/* 遍历未遍历的元素，执行 action 动作 */
    public void forEach(Consumer<? super V> action) {
        if (action == null) throw new NullPointerException();
        Node<K,V>[] t;
        if ((t = map.table) != null) {
            Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
            for (Node<K,V> p; (p = it.advance()) != null; )
                action.accept(p.val);
        }
    }
}

1.3.21 EntrySetView

• 键值对视图，继承 CollectionView

static final class EntrySetView<K,V> extends CollectionView<K,V,Map.Entry<K,V>>
    implements Set<Map.Entry<K,V>>, java.io.Serializable {
    private static final long serialVersionUID = 2249069246763182397L;
    /* 构造函数：指定map */
    EntrySetView(ConcurrentHashMap<K,V> map) { super(map); }
	
	/* 是否包含对象o */
    public boolean contains(Object o) {
        Object k, v, r; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (r = map.get(k)) != null &&
                (v = e.getValue()) != null &&
                (v == r || v.equals(r)));
    }
	/* 移除对象o */
    public boolean remove(Object o) {
        Object k, v; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                map.remove(k, v));
    }

    /* 获取迭代器 */
    public Iterator<Map.Entry<K,V>> iterator() {
        ConcurrentHashMap<K,V> m = map;
        Node<K,V>[] t;
        int f = (t = m.table) == null ? 0 : t.length;
        return new EntryIterator<K,V>(t, f, 0, f, m);
    }
	/* 添加指定的节点e */
    public boolean add(Entry<K,V> e) {
        return map.putVal(e.getKey(), e.getValue(), false) == null;
    }
	/* 添加集合c的所有元素，没发生添加返回 false */
    public boolean addAll(Collection<? extends Entry<K,V>> c) {
        boolean added = false;
        for (Entry<K,V> e : c) {
            if (add(e))
                added = true;
        }
        return added;
    }
	/* 重写 hashCode 方法 */
    public final int hashCode() {
        int h = 0;
        Node<K,V>[] t;
        if ((t = map.table) != null) {
            Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
            for (Node<K,V> p; (p = it.advance()) != null; ) {
                h += p.hashCode();
            }
        }
        return h;
    }
	/* 重写 equals 方法 */
    public final boolean equals(Object o) {
        Set<?> c;
        return ((o instanceof Set) &&
                ((c = (Set<?>)o) == this ||
                 (containsAll(c) && c.containsAll(this))));
    }
	/* 获取分解迭代器 */
    public Spliterator<Map.Entry<K,V>> spliterator() {
        Node<K,V>[] t;
        ConcurrentHashMap<K,V> m = map;
        long n = m.sumCount(); // 计算当前map元素个数
        int f = (t = m.table) == null ? 0 : t.length;
        return new EntrySpliterator<K,V>(t, f, 0, f, n < 0L ? 0L : n, m);
    }
	/* 遍历未遍历的元素，执行 action 动作 */
    public void forEach(Consumer<? super Map.Entry<K,V>> action) {
        if (action == null) throw new NullPointerException();
        Node<K,V>[] t;
        if ((t = map.table) != null) {
            Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
            for (Node<K,V> p; (p = it.advance()) != null; )
                action.accept(new MapEntry<K,V>(p.key, p.val, map));
        }
    }

}