走进科学之——为何刚初始化的HashMap的entrySet不为null

疑团重重

当你调试以下代码时，你会发现oldMap的entrySet不为null：

HashMap<Object,Integer> oldMap = new HashMap<Object,Integer>();
System.out.println();//此处打断点

从图中可以看出，oldMap的各个成员都是刚初始化时的状态，除了entrySet这个成员不为null以外（后面有个@500，代表这个引用已经指向了某个对象了），但HashMap的默认构造器只是：

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

很明显，默认构造器只是初始化了loadFactor而已，肯定没有去初始化entrySet成员啊。

谜题揭秘

其实是因为debug调试时，隐式地调用了AbstractMap的toString方法。

如果你通过反射的方法来看：

HashMap<Object,Integer> map = new HashMap<>();

Field entrySetField = HashMap.class.getDeclaredField("entrySet");
entrySetField.setAccessible(true);
Object entrySet = entrySetField.get(map);
System.out.println("entrySet = " + entrySet);
System.out.println("map.toString() = " + map.toString());
entrySet = entrySetField.get(map);
System.out.println("entrySet = " + entrySet);

你会发现打印结果为：

entrySet = null  //调用toString之前，entrySet还是为null的
map.toString() = {}
entrySet = []    //调用toString之后，entrySet就不为null了

从打印结果可以看出，调用toString之后，entrySet会被赋值，不再为null。

调用过程

首先，我们先来看看map.toString() = {}这句后面的大括号是怎么打印出来。首先AbstractMap.toString()会被调用：

//AbstractMap.java
    public String toString() {
        Iterator<Entry<K,V>> i = entrySet().iterator();//调用entrySet方法返回值的iterator方法
        if (! i.hasNext())
            return "{}";

        StringBuilder sb = new StringBuilder();
        sb.append('{');//这不就是大括号吗
        for (;;) {
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key);
            sb.append('=');
            sb.append(value == this ? "(this Map)" : value);
            if (! i.hasNext())
                return sb.append('}').toString();//这不就是大括号吗
            sb.append(',').append(' ');
        }
    }

再来看entrySet方法，它会创建成员内部类EntrySet的实例，然后赋值给HashMap的entrySet成员，这就是刚创建的HashMap的entrySet不为null的原因。内部类EntrySet的Iterator方法返回的EntryIterator迭代器，才让AbstractMap.toString()打印出了东西。

    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;//如果为null，创建这个内部类的实例
    }

    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();
            }
        }
    }

然后，我们先来看看entrySet = []这句后面的大括号是怎么打印出来。首先AbstractCollection.toString()会被调用：

//AbstractCollection.java
    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(' ');
        }
    }

上面的Iterator<E> it = iterator()会调用到EntrySet内部类重写的iterator方法，所以这里返回的迭代器也是EntryIterator迭代器，但由于HashMap刚创建，迭代器根本没有元素可以迭代。

以上，就解释了为什么调试截图中oldMap的打印结果为"{}"，entrySet成员的打印结果是"[]"。

友情链接

how and when HashMap initialize entrySet and add value into it