java Hashmap

HashMap也是我们使用非常多的Collection，它是基于哈希表的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据hash算法来来计算key-value的存储位置，我们总是可以通过key快速地存、取value。下面就来分析HashMap的存取。

一、定义

      HashMap实现了Map接口，继承AbstractMap。其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作，其实AbstractMap类已经实现了Map，这里标注Map LZ觉得应该是更加清晰吧！

public class HashMap<K,V>    extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable

二、构造函数

      HashMap提供了三个构造函数：

      HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

      HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。

      HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。

      在这里提到了两个参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。

      HashMap是一种支持快速存取的数据结构，要了解它的性能必须要了解它的数据结构。

三、数据结构

      我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它数据结构：

      从上图我们可以看出HashMap底层实现还是数组，只是数组的每一项都是一条链。其中参数initialCapacity就代表了该数组的长度。下面为HashMap构造函数的源码：

public HashMap(int initialCapacity, float loadFactor) {        //初始容量不能<0        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: "                    + initialCapacity);        //初始容量不能 > 最大容量值，HashMap的最大容量值为2^30        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        //负载因子不能 < 0        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: "                    + loadFactor);        // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;                this.loadFactor = loadFactor;        //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作        threshold = (int) (capacity * loadFactor);        //初始化table数组        table = new Entry[capacity];        init();    }

      从源码中可以看出，每次新建一个HashMap时，都会初始化一个table数组。table数组的元素为Entry节点。

static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        Entry<K,V> next;        final int hash;        /**         * Creates new entry.         */        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }        .......    }

      其中Entry为HashMap的内部类，它包含了键key、值value、下一个节点next，以及hash值，这是非常重要的，正是由于Entry才构成了table数组的项为链表。

      上面简单分析了HashMap的数据结构，下面将探讨HashMap是如何实现快速存取的。

四、存储实现：put(key,vlaue)

      首先我们先看源码

public V put(K key, V value) {        //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因        if (key == null)            return putForNullKey(value);        //计算key的hash值        int hash = hash(key.hashCode());                  ------(1)        //计算key hash 值在 table 数组中的位置        int i = indexFor(hash, table.length);             ------(2)        //从i出开始迭代 e,找到 key 保存的位置        for (Entry<K, V> e = table[i]; e != null; e = e.next) {            Object k;            //判断该条链上是否有hash值相同的(key相同)            //若存在相同，则直接覆盖value，返回旧value            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;    //旧值 = 新值                e.value = value;                e.recordAccess(this);                return oldValue;     //返回旧值            }        }        //修改次数增加1        modCount++;        //将key、value添加至i位置处        addEntry(hash, key, value, i);        return null;    }

      通过源码我们可以清晰看到HashMap保存数据的过程为：首先判断key是否为null，若为null，则直接调用putForNullKey方法。若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，否则将该元素保存在链头（最先保存的元素放在链尾）。若table在该处没有元素，则直接保存。这个过程看似比较简单，其实深有内幕。有如下几点：

      1、 先看迭代处。此处迭代原因就是为了防止存在相同的key值，若发现两个hash值（key）相同时，HashMap的处理方式是用新value替换旧value，这里并没有处理key，这就解释了HashMap中没有两个相同的key。

      2、 在看（1）、（2）处。这里是HashMap的精华所在。首先是hash方法，该方法为一个纯粹的数学计算，就是计算h的hash值。

static int hash(int h) {        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

      我们知道对于HashMap的table而言，数据分布需要均匀（最好每项都只有一个元素，这样就可以直接找到），不能太紧也不能太松，太紧会导致查询速度慢，太松则浪费空间。计算hash值后，怎么才能保证table元素分布均与呢？我们会想到取模，但是由于取模的消耗较大，HashMap是这样处理的：调用indexFor方法。

static int indexFor(int h, int length) {        return h & (length-1);    }

      HashMap的底层数组长度总是2的n次方，在构造函数中存在：capacity <<= 1;这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时，h&(length – 1)就相当于对length取模，而且速度比直接取模快得多，这是HashMap在速度上的一个优化。至于为什么是2的n次方下面解释。

      我们回到indexFor方法，该方法仅有一条语句：h&(length – 1)，这句话除了上面的取模运算外还有一个非常重要的责任：均匀分布table数据和充分利用空间。

      这里我们假设length为16(2^n)和15，h为5、6、7。

      当n=15时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低。诚然这里只分析三个数字不是很多，那么我们就看0-15。

      从上面的图表中我们看到总共发生了8此碰撞，同时发现浪费的空间非常大，有1、3、5、7、9、11、13、15处没有记录，也就是没有存放数据。这是因为他们在与14进行&运算时，得到的结果最后一位永远都是0，即0001、0011、0101、0111、1001、1011、1101、1111位置处是不可能存储数据的，空间减少，进一步增加碰撞几率，这样就会导致查询速度慢。而当length = 16时，length – 1 = 15 即1111，那么进行低位&运算时，值总是与原来hash值相同，而进行高位运算时，其值等于其低位值。所以说当length = 2^n时，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。

      这里我们再来复习put的流程：当我们想一个HashMap中添加一对key-value时，系统首先会计算key的hash值，然后根据hash值确认在table中存储的位置。若该位置没有元素，则直接插入。否则迭代该处元素链表并依此比较其key的hash值。如果两个hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),则用新的Entry的value覆盖原来节点的value。如果两个hash值相等但key值不等 ，则将该节点插入该链表的链头。具体的实现过程见addEntry方法，如下：

void addEntry(int hash, K key, V value, int bucketIndex) {        //获取bucketIndex处的Entry        Entry<K, V> e = table[bucketIndex];        //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry         table[bucketIndex] = new Entry<K, V>(hash, key, value, e);        //若HashMap中元素的个数超过极限了，则容量扩大两倍        if (size++ >= threshold)            resize(2 * table.length);    }

      这个方法中有两点需要注意：

      一是链的产生。这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象，那么新添加的Entry对象将指向原有的Entry对象，形成一条Entry链，但是若bucketIndex处没有Entry对象，也就是e==null,那么新添加的Entry对象指向null，也就不会产生Entry链了。

      二、扩容问题。

      随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

五、读取实现：get(key)

            相对于HashMap的存而言，取就显得比较简单了。通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。

public V get(Object key) {        // 若为null，调用getForNullKey方法返回相对应的value        if (key == null)            return getForNullKey();        // 根据该 key 的 hashCode 值计算它的 hash 码          int hash = hash(key.hashCode());        // 取出 table 数组中指定索引处的值        for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {            Object k;            //若搜索的key与查找的key相同，则返回相对应的value            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))                return e.value;        }        return null;    }

     在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。

HashMap 的存储实现

当程序试图将多个 key-value 放入 HashMap 中时，以如下代码片段为例：

[java] view plain copy

1. HashMap<String , Double> map = new HashMap<String , Double>();   
2. map.put("语文" , 80.0);   
3. map.put("数学" , 89.0);   
4. map.put("英语" , 78.2);   

HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。 

当程序执行 map.put("语文" , 80.0); 时，系统将调用"语文"的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode 值来决定该元素的存储位置。 

我们可以看 HashMap 类的 put(K key , V value) 方法的源代码：

[java] view plain copy

1. public V put(K key, V value)   
2. {   
3.  // 如果 key 为 null，调用 putForNullKey 方法进行处理  
4.  if (key == null)   
5.      return putForNullKey(value);   
6.  // 根据 key 的 keyCode 计算 Hash 值  
7.  int hash = hash(key.hashCode());   
8.  // 搜索指定 hash 值在对应 table 中的索引  
9.      int i = indexFor(hash, table.length);  
10.  // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素  
11.  for (Entry<K,V> e = table[i]; e != null; e = e.next)   
12.  {   
13.      Object k;   
14.      // 找到指定 key 与需要放入的 key 相等（hash 值相同  
15.      // 通过 equals 比较放回 true）  
16.      if (e.hash == hash && ((k = e.key) == key   
17.          || key.equals(k)))   
18.      {   
19.          V oldValue = e.value;   
20.          e.value = value;   
21.          e.recordAccess(this);   
22.          return oldValue;   
23.      }   
24.  }   
25.  // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry   
26.  modCount++;   
27.  // 将 key、value 添加到 i 索引处  
28.  addEntry(hash, key, value, i);   
29.  return null;   
30. }   

上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。 

上面方法提供了一个根据 hashCode() 返回值来计算 Hash 码的方法：hash()，这个方法是一个纯粹的数学计算，其方法如下： 

[java] view plain copy

1. static int hash(int h)   
2. {   
3.     h ^= (h >>> 20) ^ (h >>> 12);   
4.     return h ^ (h >>> 7) ^ (h >>> 4);   
5. }   

对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下：

[java] view plain copy

1. static int indexFor(int h, int length)   
2. {   
3.     return h & (length-1);   
4. }  

这个方法非常巧妙，它总是通过 h &(table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方，这一点可参看后面关于 HashMap 构造器的介绍。 

当 length 总是 2 的倍数时，h & (length-1) 将是一个非常巧妙的设计：假设 h=5,length=16, 那么 h & length - 1 将得到 5；如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15；但是当 h=16 时 , length=16 时，那么 h & length - 1 将得到 0 了；当 h=17 时 , length=16 时，那么 h & length - 1 将得到 1 了……这样保证计算得到的索引值总是位于 table 数组的索引之内。 

根据上面 put 方法的源代码可以看出，当程序试图将一个 key-value 对放入 HashMap 中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但 key 不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——具体说明继续看 addEntry() 方法的说明。 

当向 HashMap 中添加 key-value 对，由其 key 的 hashCode() 返回值决定该 key-value 对（就是 Entry 对象）的存储位置。当两个 Entry 对象的 key 的 hashCode() 返回值相同时，将由 key 通过 eqauls() 比较值决定是采用覆盖行为（返回 true），还是产生 Entry 链（返回 false）。 

上面程序中还调用了 addEntry(hash, key, value, i); 代码，其中 addEntry 是 HashMap 提供的一个包访问权限的方法，该方法仅用于添加一个 key-value 对。下面是该方法的代码： 

[java] view plain copy

1. void addEntry(int hash, K key, V value, int bucketIndex)   
2. {   
3.     // 获取指定 bucketIndex 索引处的 Entry   
4.     Entry<K,V> e = table[bucketIndex];     // ①  
5.     // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry   
6.     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);   
7.     // 如果 Map 中的 key-value 对的数量超过了极限  
8.     if (size++ >= threshold)   
9.         // 把 table 对象的长度扩充到 2 倍。  
10.         resize(2 * table.length);    // ②  
11. }   

上面方法的代码很简单，但其中包含了一个非常优雅的设计：系统总是将新添加的 Entry 对象放入 table 数组的 bucketIndex 索引处——如果 bucketIndex 索引处已经有了一个 Entry 对象，那新添加的 Entry 对象指向原有的 Entry 对象（产生一个 Entry 链），如果 bucketIndex 索引处没有 Entry 对象，也就是上面程序①号代码的 e 变量是 null，也就是新放入的 Entry 对象指向 null，也就是没有产生 Entry 链。 

JDK 源码 

在 JDK 安装目录下可以找到一个 src.zip 压缩文件，该文件里包含了 Java 基础类库的所有源文件。只要读者有学习兴趣，随时可以打开这份压缩文件来阅读 Java 类库的源代码，这对提高读者的编程能力是非常有帮助的。需要指出的是：src.zip 中包含的源代码并没有包含像上文中的中文注释，这些注释是笔者自己添加进去的。 

Hash 算法的性能选项 

根据上面代码可以看出，在同一个 bucket 存储 Entry 链的情况下，新放入的 Entry 总是位于 bucket 中，而最早放入该 bucket 中的 Entry 则位于这个 Entry 链的最末端。 

上面程序中还有这样两个变量： 

    * size：该变量保存了该 HashMap 中所包含的 key-value 对的数量。 
    * threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）。 

从上面程序中②号代码可以看出，当 size++ >= threshold 时，HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次，HashMap 的容量就增大一倍。 

上面程序中使用的 table 其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是 HashMap 的容量。HashMap 包含如下几个构造器： 

    * HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。 
    * HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。 
    * HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。 

当创建一个 HashMap 时，系统会自动创建一个 table 数组来保存 HashMap 中的 Entry，下面是 HashMap 中一个构造器的代码：

[java] view plain copy

1. // 以指定初始化容量、负载因子创建 HashMap   
2.  public HashMap(int initialCapacity, float loadFactor)   
3.  {   
4.      // 初始容量不能为负数  
5.      if (initialCapacity < 0)   
6.          throw new IllegalArgumentException(   
7.         "Illegal initial capacity: " +   
8.              initialCapacity);   
9.      // 如果初始容量大于最大容量，让出示容量  
10.      if (initialCapacity > MAXIMUM_CAPACITY)   
11.          initialCapacity = MAXIMUM_CAPACITY;   
12.      // 负载因子必须大于 0 的数值  
13.      if (loadFactor <= 0 || Float.isNaN(loadFactor))   
14.          throw new IllegalArgumentException(   
15.          loadFactor);   
16.      // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。  
17.      int capacity = 1;   
18.      while (capacity < initialCapacity)   
19.          capacity <<= 1;   
20.      this.loadFactor = loadFactor;   
21.      // 设置容量极限等于容量 * 负载因子  
22.      threshold = (int)(capacity * loadFactor);   
23.      // 初始化 table 数组  
24.      table = new Entry[capacity];            // ①  
25.      init();   
26.  }   

上面代码中粗体字代码包含了一个简洁的代码实现：找出大于 initialCapacity 的、最小的 2 的 n 次方值，并将其作为 HashMap 的实际容量（由 capacity 变量保存）。例如给定 initialCapacity 为 10，那么该 HashMap 的实际容量就是 16。 
程序①号代码处可以看到：table 的实质就是一个数组，一个长度为 capacity 的数组。 

对于 HashMap 及其子类而言，它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时，系统会创建一个长度为 capacity 的 Entry 数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket 都有其指定索引，系统可以根据其索引快速访问该 bucket 里存储的元素。 

无论何时，HashMap 的每个“桶”只存储一个元素（也就是一个 Entry），由于 Entry 对象可以包含一个引用变量（就是 Entry 构造器的的最后一个参数）用于指向下一个 Entry，因此可能出现的情况是：HashMap 的 bucket 中只有一个 Entry，但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示：

图 1. HashMap 的存储示意 

HashMap 的读取实现 

当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时，此时的 HashMap 具有最好的性能：当程序通过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，然后取出该索引处的 Entry，最后返回该 key 对应的 value 即可。看 HashMap 类的 get(K key) 方法代码： 

[java] view plain copy

1. public V get(Object key)   
2. {   
3.  // 如果 key 是 null，调用 getForNullKey 取出对应的 value   
4.  if (key == null)   
5.      return getForNullKey();   
6.  // 根据该 key 的 hashCode 值计算它的 hash 码  
7.  int hash = hash(key.hashCode());   
8.  // 直接取出 table 数组中指定索引处的值，  
9.  for (Entry<K,V> e = table[indexFor(hash, table.length)];   
10.      e != null;   
11.      // 搜索该 Entry 链的下一个 Entr   
12.      e = e.next)         // ①  
13.  {   
14.      Object k;   
15.      // 如果该 Entry 的 key 与被搜索 key 相同  
16.      if (e.hash == hash && ((k = e.key) == key   
17.          || key.equals(k)))   
18.          return e.value;   
19.  }   
20.  return null;   
21. }   

从上面代码中可以看出，如果 HashMap 的每个 bucket 里只有一个 Entry 时，HashMap 可以根据索引、快速地取出该 bucket 里的 Entry；在发生“Hash 冲突”的情况下，单个 bucket 里存储的不是一个 Entry，而是一个 Entry 链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），那系统必须循环到最后才能找到该元素。 

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。由此可见：HashMap 之所以能快速存、取它所包含的 Entry，完全类似于现实生活中母亲从小教我们的：不同的东西要放在不同的位置，需要时才能快速找到它。 

当创建 HashMap 时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。 

掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。 

如果开始就知道 HashMap 会保存多个 key-value 对，可以在创建时就使用较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity * load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity 的 Entry 数组），因此创建 HashMap 时初始化容量设置也需要小心对待。

1：使用HashMap的一个简单例子

[java] view plain copy

1. package com.pb.collection;  
2.   
3. import java.util.HashMap;  
4. import java.util.Iterator;  
5. import java.util.Set;  
6. import java.util.Map.Entry;  
7.   
8. public class HashMapDemo {  
9.   
10.     public static void main(String[] args) {  
11.           
12.         HashMap<String, String> hashMap = new HashMap<String, String>();  
13.         hashMap.put("cn", "中国");  
14.         hashMap.put("jp", "日本");  
15.         hashMap.put("fr", "法国");  
16.           
17.         System.out.println(hashMap);  
18.         System.out.println("cn:" + hashMap.get("cn"));  
19.         System.out.println(hashMap.containsKey("cn"));  
20.         System.out.println(hashMap.keySet());  
21.         System.out.println(hashMap.isEmpty());  
22.           
23.         hashMap.remove("cn");  
24.         System.out.println(hashMap.containsKey("cn"));  
25.           
26.         //采用Iterator遍历HashMap  
27.         Iterator it = hashMap.keySet().iterator();  
28.         while(it.hasNext()) {  
29.             String key = (String)it.next();  
30.             System.out.println("key:" + key);  
31.             System.out.println("value:" + hashMap.get(key));  
32.         }  
33.           
34.         //遍历HashMap的另一个方法  
35.         Set<Entry<String, String>> sets = hashMap.entrySet();  
36.         for(Entry<String, String> entry : sets) {  
37.             System.out.print(entry.getKey() + ", ");  
38.             System.out.println(entry.getValue());  
39.         }  
40.     }  
41. }  

2：一个结合List和HashMap实现的例子

import java.util.Iterator;  

import java.util.List;  
import java.util.HashMap;  
import java.util.ArrayList;  
import java.util.Map;  
import java.util.Scanner;  
import java.util.Set;  
import java.util.Map.Entry;  
/** 
 * 在不创建学生类的情况下，从键盘输入n个学生信息(学号，姓名，年龄）， 
 * 输入完成后，打印出各个学生信息 
 * @author ccna_zhang 
 * 
 */  
public class Test1 {  
      
    public static void main(String[] args) {  
          
        //定义保存学生信息的List，元素类型为HashMap  
        List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();  
        Scanner input = new Scanner(System.in);  
          
        System.out.println("请输入学生的信息,y表示继续，n表示退出");  
        while("y".equals(input.next())) {  
            HashMap<String, Object> map = new HashMap<String, Object>();  
            System.out.println("请输入学号");  
            map.put("studentno", input.next());  
            System.out.println("请输入姓名");  
            map.put("name", input.next());  
            System.out.println("请输入年龄");  
            map.put("age", input.nextInt());  
            list.add(map);  
            System.out.println("请继续输入学生的信息,y表示继续，n表示退出");  
        }  
        System.out.println("输入的学生信息为:");  
        System.out.println("学生数量为:" + list.size());   
        Iterator<HashMap<String, Object>> it = list.iterator();  
        while(it.hasNext()) {  
            HashMap<String, Object> stuMap = it.next();  
            System.out.println("学号:" + stuMap.get("studentno") + " ,姓名:" + stuMap.get("name") + " ,年龄:" + stuMap.get("age"));
        }  
    }  
}