[Java] Java源码解析HashMap的keySet()方法

public set<k> keyset() {
  set<k> ks = keyset;
  if (ks == null) {
  ks = new keyset();
  keyset = ks;
  }
  return ks;
}

final class keyset extends abstractset<k> {
  public final int size()     { return size; }
  public final void clear()    { hashmap.this.clear(); }
  public final iterator<k> iterator()   { return new keyiterator(); }
  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 new keyspliterator<>(hashmap.this, 0, -1, 0, 0);
  }
  public final void foreach(consumer<? super k> 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.key);
    }
    if (modcount != mc)
    throw new concurrentmodificationexception();
  }
  }
}
final class keyiterator extends hashiterator
  implements iterator<k> {
  public final k next() { return nextnode().key; }
}
abstract class hashiterator {
  node<k,v> next;  // next entry to return
  node<k,v> current;   // current entry
  int expectedmodcount; // for fast-fail
  int index;     // current slot
  hashiterator() {
  expectedmodcount = modcount;
  node<k,v>[] t = table;
  current = next = null;
  index = 0;
  if (t != null && size > 0) { // advance to first entry
    do {} while (index < t.length && (next = t[index++]) == null);
  }
  }
  public final boolean hasnext() {
  return next != null;
  }
  final node<k,v> nextnode() {
  node<k,v>[] t;
  node<k,v> e = next;
  if (modcount != expectedmodcount)
    throw new concurrentmodificationexception();
  if (e == null)
    throw new nosuchelementexception();
  if ((next = (current = e).next) == null && (t = table) != null) {
    do {} while (index < t.length && (next = t[index++]) == null);
  }
  return e;
  }
  public final void remove() {
  node<k,v> p = current;
  if (p == null)
    throw new illegalstateexception();
  if (modcount != expectedmodcount)
    throw new concurrentmodificationexception();
  current = null;
  k key = p.key;
  removenode(hash(key), key, null, false, false);
  expectedmodcount = modcount;
  }
}