深入了解HashMap。
eclipse中查看源码的方法：按住Ctrl键，鼠标左键单击代码（更详细请百度）。
容器：在Java中，“集合”有另外的用途，所以ArrayList、HashMap等皆称为容器类，其创建的一个对象就是一个容器。
HashMap是一个基于数组、单向链表以及树结构的Map，存储的元素中key值是唯一的，value没有要求。
1、class声明
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {...}源码分析：HashMap继承自AbstractMap类，实现了Map接口，Cloneable接口以及Serializable接口
如果查看AbstractMap源码，就会发现它也实现了Map接口。那为什么在HashMap中继承了AbstractMap后还要实现Map接口呢?网上有很多种答案，觉得最站得住脚的有两点：1）、添加Map接口是为了Class类的getInterfaces这个方法可以直接返回Map接口。2）、这就是写法上的错误，并没有什么深意，这是得票最高的答案，回答者称曾问过此段代码的设计者Josh Bloch。
实现Cloneable接口（标识接口），该接口不包含任何方法，实现它仅仅是为了指示可以使用Object类中的clone()方法来进行克隆。
实现Serializable接口（标识接口），该接口不包含任何方法，实现它表示该类可以进行序列化。该接口表示所有的非transient和非static字段都可以被序列化。如果要实现transient字段与static字段的序列化保存，必须声明writeObject和readObject方法
2、静态常量字段
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 static final int MAXIMUM_CAPACITY = 1 << 30; static final float DEFAULT_LOAD_FACTOR = 0.75f; static final int TREEIFY_THRESHOLD = 8; static final int UNTREEIFY_THRESHOLD = 6; static final int MIN_TREEIFY_CAPACITY = 64;源码分析：
DEFAULT_INITIAL_CAPACITY：容器的默认初始化容量，值为16。
MAXIMUM_CAPACITY ：容器的最大容量，值为2的30次方。
DEFAULT_LOAD_FACTOR ：默认的容量因子，值为0.75f。用于计算容器的实际可用容量（如：16*0.75f=12。原本初始化容器时指定了大小为16，但实际能用的只有12）。
TREEIFY_THRESHOLD ：阈值，值为8。当桶上的链表数大于该值时，转红黑数。
UNTREEIFY_THRESHOLD： 阈值，值为6。当桶上的链表数小于该值时，转链表。
MIN_TREEIFY_CAPACITY ：红黑树的最小容量，本为4 x TREEIFY_THRESHOLD =32，但为了避免resizing和treeifcation tresholds 则设为了64。
3、非静态字段
transient Node<K,V>[] table; transient Set<Map.Entry<K,V>> entrySet; transient int size; transient int modCount; int threshold; final float loadFactor;源码分析：
table：装Node对象的列表，也叫桶。经hash算法计算后的值如果没有重复，则对象都是放于此。
entrySet：Set容器变量，存储一系列Map.Entry对象，主要用于实现元素遍历。
size：实际已经使用的容器大小，即容器中已经存在的元素个数。
modCount：记录HashMap结构性变化的次数。
threshold：容器大小，默认为16*0.75f=12。
loadFactor：容量因子，用于计算容器的真实大小（threshold）。
4、构造器
public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }源码分析：HashMap有四个构造方法可供选择
HashMap(int initialCapacity, float loadFactor)：该方法要求传入两个参数。容器的初始大小和容量因子。
HashMap(int initialCapacity)：该方法只要求传入初始容量。而容量因子采用了默认的0.75。
HashMap()：该方法为无参构造器。容量大小默认16，容量因子默认0.75。
HashMap(Map<? extends K, ? extends V> m)：该方法根据已有的Map容器对象创建新的对象。
构造方法中涉及到容器大小参数的问题，自定义容量大小的构造器方法中会调用方法tableSizeFor（源码如下）来处理数据，最终保证容量大小是2的n次方（如自定义容量大小为7，则数据处理会将其修改为2的3次方，即8）。所以HashMap容器的最小容量可以定义为2的0次方，即1。
static final int tableSizeFor(int cap) { int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1); return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }5、数据存储结构
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }源码分析：此为HashMap中存储的数据的结构
每一个数据就是一个Node对象，实现了Map.Entry<K,V>接口，Entry是Map接口中定义的一个接口，该接口中定义的一些方法，都在Node中被实现。每一个数据主要包含四个字段
hash(经Hash算法获得的值)
key(具有唯一性，与字段value构成一组关系)
value
next(也是Node对象，主要用于hash值相同时将数据保存为链表)
6、hash算法
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }源码分析：哈希算法（确保长度为n的数组经过(n-1)&hash后的值正好为0—(n-1)）
hash()方法用于计算key的hash值。如果key为null，返回0。否则将key的hashCode值异或上其右移了16位的值（如"a"的hashCode()为97，则97^(97>>>16)=97^(97/(int)Math.pow(2,16))=97）
当然只看此方法是看不出有什么用的，需要结合HashMap在保存、获取元素时计算元素索引的源码（下面是getNode方法中的部分源码）。在计算数据位置时，用到了hash值，即tab[(n-1)&hash] （n是数组table的真实大小），这里的hash值就是上面根据key计算出来的hash值，利用该算法可以有效减小不同数据在table中保存位置相同的情况。
并且，通过哈希算法可以保证只要元素的hash值不变，当数组table在扩容（每次扩容都是原来的两倍）的时候。(n-1)&hash都能得到唯一值（如：(8-1)&97是等于(16-1)&97的）。避免了重新分配数组大小时已有数据的索引被重新定义。
final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { ... }7、添加/修改元素
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }源码分析：put()方法实现添加/修改数据。如果已经存在key值，则使用新的value替换旧的value并返回旧的value。如果不存在key值，添加完数据后返回null。
第一步检查数组table是否为空，如果是将调用resize方法为其分配存储空间进行初始化。
if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;第二步使用hash算法的结果来获得数据在数组table中的位置索引。再判断该位置是否已经存在数据，如果没有数据，直接添加数据。
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);如果该位置已经存在数据，则
首先判断若确定旧数据与新数据的hash以及key均相同，直接用新value替换旧value，返回oldValue，程序结束。若确定旧数据类型是TreeNode，将数据添加到树结构中。之后进入第三步以上两步都没有执行，则表明旧数据与新数据的hash相同但key值不相同，即将新数据挂载于旧数据之下形成链表。此时有判断，判断其链上的数据量是否超过8，超过就将其链表结构转变成红黑树结构。之后进入第三步 else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; }第三步由于添加了新数据，用于记录结构改变次数的modCount自增1（增加元素会自增，修改元素不会），用于记录已有数据个数的size自增1并判断其是否超过了能存储的实际元素个数threshold
++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null;8、获取元素
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }源码分析：get(Object key)方法实现获取元素。若不存在要获取的元素 返回null，存在即返回元素中的value值
代码中根据key以及key对应的hash值进行数据查找。
首先通过判断确定数据表table不为null，且通过hash值查找数据位置索引。
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null)如果获得的数据刚好key以及hash都符合要求，返回该数据的value，程序结束。
if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first;如果获得的数据不符合要求，但由于hash是相同的，所以继续判断数据的next是否存在数据。
if ((e = first.next) != null)确认存在则判断数据类型是否是TreeNode，若是则表明是红黑树结构，进入红黑树结构中查询数据并返回，程序结束。
if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key);若不是红黑树结构，则表明该结构仅仅是一个链表结构，循环查找数据，找到后返回，程序结束。
do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null);9、移除元素
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }源码分析：remove(Object key)方法实现删除元素。若要被删除的元素不存在就返回null，否则删除成功后返回被删除的元素的value
第一步找到要移除的数据的确切位置
首先依然是判断确定数据表table不为null，且通过hash值查找数据位置索引。
if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null)接着若获得的数据刚好hash以及key均符合要求，找到数据，进入第二步。
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k)))) node = p;若获得的数据类型是TreeNode，进入红黑树结构中查找数据，找到后进入第二步。
if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key);若以上两个判断均不成立，则表明数据存储方式是链式结构，循环查找数据，找到后进入第二步。
do { if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null);第二步移除目标元素
若数据类型为TreeNode，则调用对应的树形结构移除数据的方法（其中包括当树中的数据量低于6时，结构转变为链表等操作）。若数据就在数组table中，则用该位置的数据的next替换掉要移除的数据（可能node.next为null，但是没有任何问题）。若数据在链表结构中，进行对应的操作。
if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount;//删除数据，结构改变 --size;//数据量减一 afterNodeRemoval(node); return node; }10、获得容器中已有元素个数
public int size() { return size; }源码分析：size()方法返回元素个数
为什么说是元素个数而不是数组table大小呢？因为元素个数是永远小于table的真实大小的（容量因子*数组大小=size的最大值，在resize()方法中可以很明确的看到这三者的关系）
11、重新分配容量大小
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }源码分析：resize()用于设置容器大小，包括初始化数组table大小和扩容，扩容一次扩大为原来的两倍。返回已经经过扩容或者初始化的新数组newTab（Node<K,V>）。
oldCap/newCap：数组table容量oldThr/newThr：元素容量，能添加数据元素的最大个数第一步判断应该初始化数组还是进行扩容
若oldCap大于0（即数组不为null），这时若容量在允许的范围内（最大容量2的30次方），就对数组大小进行扩容（采用移位运算oldCap<<1）为原来的两倍，若扩容后的大小也低于最大容量，则将实际容量也进行扩容（oldThr<<1）为原来的两倍。进入第二步
if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold }若oldCap等于0（即数组为空），但是oldThr>0（即初始化容器时设定了初始容量），将该值赋给newCap（用于设置数组的大小）。进入第二步。
else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr;若oldCap等于0且oldThr也等于0（即数组为空，且创建HashMap对象时调用了无参构造器），则设定newCap与newThr为默认值。进入第二步。
else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY;//16 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//0.75*16=12 }第二步若newThr等于0，为其赋值
if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); }第三步重新创建一个大小为newCap的数组newTab,，并赋给table。将原数组中的数据转移到新数组中（这部分是本方法中最耗时的，故如果有可能，一定要在创建HashMap对象时设置好初始容量）
@SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } }12、自定义序列化
private void writeObject(java.io.ObjectOutputStream s) throws IOException { int buckets = capacity(); // Write out the threshold, loadfactor, and any hidden stuff s.defaultWriteObject(); s.writeInt(buckets); s.writeInt(size); internalWriteEntries(s); } private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the threshold (ignored), loadfactor, and any hidden stuff s.defaultReadObject(); reinitialize(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new InvalidObjectException("Illegal load factor: " + loadFactor); s.readInt(); // Read and ignore number of buckets int mappings = s.readInt(); // Read number of mappings (size) if (mappings < 0) throw new InvalidObjectException("Illegal mappings count: " + mappings); else if (mappings > 0) { // (if zero, use defaults) // Size the table using given load factor only if within // range of 0.25...4.0 float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f); float fc = (float)mappings / lf + 1.0f; int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ? DEFAULT_INITIAL_CAPACITY : (fc >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int)fc)); float ft = (float)cap * lf; threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ? (int)ft : Integer.MAX_VALUE); // Check Map.Entry[].class since it's the nearest public type to // what we're actually creating. SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap); @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] tab = (Node<K,V>[])new Node[cap]; table = tab; // Read the keys and values, and put the mappings in the HashMap for (int i = 0; i < mappings; i++) { @SuppressWarnings("unchecked") K key = (K) s.readObject(); @SuppressWarnings("unchecked") V value = (V) s.readObject(); putVal(hash(key), key, value, false, false); } } } void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException { Node<K,V>[] tab; if (size > 0 && (tab = table) != null) { for (Node<K,V> e : tab) { for (; e != null; e = e.next) { s.writeObject(e.key); s.writeObject(e.value); } } } }源码分析：writeObject(java.io.ObjectOutputStream s)方法和readObject(java.io.ObjectInputStream s)方法是实现序列化的两个重要方法，声明这两个方法的目的是为了实现自己可控制的序列化
序列化时，ObjectOutputStream会采用反射查找Serializable实现类内部是否声明了这两个方法，若有，则调用该方法。否则将采用默认的序列化进程。
13、遍历元素
在HashMap中遍历元素有两种方法，第一种是先调用map.keySet().iterator()得到元素的所有key值集合，再通过map.get(key)循环获得元素中所有的value值。第二种方法是通过调用map.entrySet().iterator()获得所有元素的Entry集合，通过Entry中的getKey()和getValue()获得所有的键—值；下面是实例：
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; public class Run { public static void main(String[] args) { Map<Integer, String> map=new HashMap(); map.put(1,"n"); map.put(2,"y"); map.put(3,"s"); map.put(4,"a"); map.put(5,"b"); //第一种，先获得所有键值集合，再一一获得对应的值 Iterator<Integer> keys=map.keySet().iterator(); while(keys.hasNext()) { Integer key=keys.next(); System.out.println(key+":"+map.get(key)); } //第二种，直接获得所有的键—值关系集合 Iterator<Entry<Integer, String>> entrys=map.entrySet().iterator(); while(entrys.hasNext()) { Entry<Integer, String> entry=entrys.next(); System.out.println(entry.getKey()+":"+entry.getValue()); } } }第一种方法（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 (Node<K,V> e : tab) { for (; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } } }源码分析：方法中第一句Set<K> ks=keySet;这里的keySet是Set接口中定义的字段。
keySet()方法返回一个KeySet对象。KeySet是HashMap中的内部类，继承了AbstractSet抽象类
KeySet类中的iterator()方法返回一个可以获取所有key值的迭代器对象。
第二种方法（entrySet()）源码
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es; return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; } 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 (Node<K,V> e : tab) { for (; e != null; e = e.next) action.accept(e); } if (modCount != mc) throw new ConcurrentModificationException(); } } }源码分析：entrySet()方法返回一个Set对象
变量entrySet是HashMap中的实例字段（前面有说过的，即transient Set<Map.Entry<K,V>> entrySet;）。
类EntrySet继承于抽象类AbstractSet。
类EntrySet中的iterator()方法返回一个可以获得所有Map.Entry实例的迭代器对象（在HashMap中，数据的存储结构Node继承于Map.Entry接口，可以查看上面第5点“数据存储结构”）。
HashMap的存储结构有三种：数组、链表、树。向HashMap容器中添加元素时
首先默认使用数组结构。当存在hash值与已有元素hash相同，且key值不同时，在数组上添加链表结构。当链表上的元素数量大于等于8时，链表转红黑树。将HashMap容器中的元素移除时
若是红黑树结构，移除元素后若树上的元素数量小于6，红黑树转链表。所以一个HashMap容器中可能同时存在数组、链表、树三种数据结构。
