HashMap(2): EntrySet、KeySet实现原理

一.概述

HashMap里面保存的数据最底层是一个Entry型的数组，这个Entry则保留了一个键值对，还有一个指向下一个Entry的指针。所以HashMap是一种结合了数组和链表的结构。因此，我们有3种对数据的观测方式：keySet，values，entrySet。

keySet是从key的值角度出发的结果。它里面包含了这个键值对表里面的所有键的值的集合，因为HashMap明确规定一个键只能对应一个值，所以不会有重复的key存在，这也就是为什么可以用集合来装key。

values则是从键值对的值的角度看这个映射表，因为可以有多个key对应一个值，所以可能有多个相同的values。

entrySet是从键值对的角度思考这个问题，它返回一个键值对的集合。（键值对相等当且仅当键和值都相等）。

二.原理

1.keySet.iterator()

HashMap中的keySet源码：

public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}

private final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Obje
4000
ct o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}

由以上源码可知，当调用hashmap.keySet()方法时，若keySet为空，则返回一个新建的内部类KeySet(); 但是我们发现它有个iterator()方法，我们在敲代码中经常使用这个迭代器迭代取出HashMap对象中的key和value，再深入看：

Iterator newKeyIterator() {
return new KeyIterator();
}

HashMap内部类KeyIterator :

private final class KeyIterator extends HashIterator {
public Object next() {
return nextEntry().getKey();
}
final HashMap this$0;
private KeyIterator() {
this$0 = HashMap.this;
super();
}
}

HashIterator :

private abstract class HashIterator implements Iterator {

public final boolean hasNext() {
return next != null;
}

final HashMap.Entry nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
HashMap.Entry entry = next;
if (entry == null)
throw new NoSuchElementException();
if ((next = entry.next) == null) {
for (HashMap.Entry aentry[] = table; index < aentry.length
&& (next = aentry[index++]) == null;)
;
}
current = entry;
return entry;
}

public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
} else {
Object obj = current.key;
current = null;
removeEntryForKey(obj);
expectedModCount = modCount;
return;
}
}

HashMap.Entry next;
int expectedModCount;
int index;
HashMap.Entry current;
final HashMap this$0;

HashIterator() {
this$0 = HashMap.this;
super();
expectedModCount = modCount;
if (size > 0) {
for (HashMap.Entry aentry[] = table; index < aentry.length
&& (next = aentry[index++]) == null;)
;
}
}
}

由此可以Iterator是继承了这个HashIterator 这个内部类，而HashIterator 又访问了外部HashmMap的一些属性得以访问到整个对象的table数组的所有Entry的。

2.输出hashmap.keySet();

写个测试的案例：

@Test
public void testPrint(){
Map<String, Object> map = new HashMap<String, Object>();
map.put("now", "u");
map.put("see", "me");
System.out.println(map.keySet());
}

输出结果为：

[see, now]

当我们调用map.keySet时候，为什么会打印出keySet的这个结果呢？原理是什么？仿照HashMap写一个自定义的Iterator

package MyMap.Demo1;

import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;

public class MyTestIterator {
public static void main(String[] args) {
TestIterator t = new TestIterator();
Set<Integer> set = t.keySet();
System.out.println(set);
}

}

class TestIterator {
public Set<Integer> keySet() {

final ArrayList<Integer> result = new ArrayList<Integer>();
result.add(1);
result.add(2);
result.add(3);

Set<Integer> keySet = new AbstractSet<Integer>() {

public Iterator<Integer> iterator() {
return new Iterator<Integer>() {
private Iterator<Integer> i = result.iterator();

@Override
public boolean hasNext() {
System.out.println("===========hasNext");
return i.hasNext();
}

@Override
public Integer next() {
System.out.println("===========next");
return i.next();
}

@Override
public void remove() {
System.out.println("===========remove");
i.remove();
}
};
}

@Override
public int size() {
return 0;
}
};
return keySet;
}
}

打印结果为：

===========hasNext
===========hasNext
===========next
===========hasNext
===========next
===========hasNext
===========next
===========hasNext
[1, 2, 3]

是在哪里调用了keySet的iterator方法呢？在所有的输出语句打个断点，原来当我们使用

System.out.println( t.keySet());

输出

Set<Integer>

对象时，由于AbstractSet类继承了AbstractCollection类，而AbstractCollection又重写了Object类的toString()方法，因此在输出时调用了AbstractCollection.java类中的toString方法，重写的toString()方法又调用了iterator，从而迭代取出结果拼接成字符串。

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