HashMap学习小结

一、HashMap和TreeMap

        在数组中，通过数组下标来对其内容索引；在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。HashMap实现Map接口，提供所有映射操作的实现，并且允许null的键和值。HashMap中插入和查询key/value的开销是一个固定常量。HashMap不保证映射后的其内容的顺序在一定的时间内不会变化，也就是说，HashMap中元素的排列顺序是无序的（TreeMap是有序的）如例1：

例1：

import java.util.*;
class HashMaps
{
  public static void main(String[] args)
  {
    HashMap map = new HashMap();
    map.put("1", "111");
    map.put("4", "444");
    map.put("2", "222");
    map.put("5", "555");
   
    Iterator it = map.keySet().iterator();
    while (it.hasNext())
    {
      Object mapKey = it.next();
      System.out.println("map.get(key) is : " + map.get(mapKey));
    }
   
    TreeMap tree = new TreeMap();
    tree.put("1", "111");
    tree.put("4", "444");
    tree.put("2", "222");
    tree.put("5", "555");
    Iterator it_2 = tree.keySet().iterator();
    while(it_2.hasNext())
    {
      Object treeKey = it_2.next();
      System.out.println("tree.get(key) is : " + tree.get(treeKey));
    }
  }
}

        运行结果：

map.get(key) is : 222

map.get(key) is : 111

map.get(key) is : 555

map.get(key) is : 444

tree.get(key) is : 111

tree.get(key) is : 222

tree.get(key) is : 444

tree.get(key) is : 555       

        因为HashMap通过hashCode对进行查找，所以HashMap中元素的排列顺序是不固定的，而TreeMap在查看key/value的时候，元素会被排序，其次序由Comparable或Comparator决定，因此查询得到的结果是有序地。如果你需要得到一个有序的结果你就应该使用TreeMap。

二、HashMap的使用

        HashMap通过get()/put()方法来查询和插入，还有一个很有用的方法ContainsKey()来check对象是否存在于HashMap中。如例2：

例2：

import java.util.*;
public class HashMaps
{
  public static void main(String[] args)
  {
    HashMap aMap = new HashMap();
    Random ran = new Random();
   
    for (int i = 0; i<100; i++)
    {
      Integer iVal = new Integer(ran.nextInt(10));
      if (aMap.containsKey(iVal))
      {
        ((CCount)aMap.get(iVal)).count++;
      }
      else
      {
        aMap.put(iVal, new CCount());
      }
    }
    System.out.println(aMap);
  }
}
 
class CCount
{
  int count = 1;
  public String toString()
  {
    return Integer.toString(count);
  }
}

        例2中生成100个0-9的任意整数，并统计了每个数出现的次数，然后以0-9的数为key，将他们出现的次数（count）作为value保存到HashMap中。

        HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法。当使用标准库中的类Integer作为HashMap的key时，程序能够正常运行，但是如果使用自定义的类作为HashMap的key时，可能会出现错误。这是因为HashMap通过key查找value时，实际上是计算key对象地址的散列码来确定value的。默认情况下，我们使用超类Object的方法HashCode()来生成散列码。这样，假如我们用同样的初始化参数构造同样内容的对象，由于他们的地址不同，生成的散列码也不同。如下例所示：

例3：

import java.util.*;
public class HashMaps
{
  public static void main(String[] args)
  {
    HashMap aMap = new HashMap();
    for (int i = 0; i<10; i++)
      aMap.put(new Element(i), new Figureout());
    System.out.println("aMap: get result:");
    Element test = new Element(5);
    if (aMap.containsKey(test))
      System.out.println((Figureout)aMap.get(test));
    else
      System.out.println("Not found");
  }
}
 
class Element
{
  int num;
  public Element(int n)
  {
    num = n;
  }
}
 
class Figureout
{
  Random r = new Random();
  boolean possible = r.nextDouble() > 0.5;
  public String toString()
  {
    if (possible)
      return "OK";
    else
      return "Impossible";
  }
}

        例3中，先是在for循环中通过new Element(i)生成了一个HashMap，之后，我们希望查找一个test元素，这个test元素是通过new Element(5)生成的。test元素和HashMap中的元素是不同的对象，因此，它们的地址也不同，使用默认的Object超类提供的HashCode方法无法查找。所以，例3中程序执行结果始终是“Not found”。

        因此，对于用户自定义的类作key的情况，我们需要覆盖HashCode方法。同时，还需要覆盖equals方法来判断当前的key是否与HashMap中的元素的key相同。修改后的Element类如下：

class Element
{
  int num;
  public Element(int n)
  {
    num = n;
  }
  public int hashCode()
  {
      return num;
  }
  public boolean equals(Object o)
  {
      return (o instanceof Element) && (num==((Element)o).num);
  }
}

        这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashCode返回，这样对于相同内容的对象来说它们的hashCode也就相同了。

三、小结

1，如果要用自己的类作为HashMap的key，必须同时覆盖hashCode和equals方法。

2，重写hashCode方法的关键：

(1)对同一个对象调用hashCode()都应该生成同样的值。

(2)hashCode()方法不要依赖于对象中易变的数据，当数据发生变化时，hashCode()就会生成一个不同的散列码，即产生了一个不同的label。

(3)hashCode()不应依赖于具有唯一性的对象信息，例如对象地址。

(4)散列码应该更关心速度，而不是唯一性，因为散列码不必是唯一的。

(5)好的hashCode()应该产生分步均匀的散列码。

3，正确的equals()方法满足五个条件：

(1)自反性。对于任意的x，x.equals(x)一定返回true。

(2)对称性。对于任意的x和y，如果y.equals(x)返回true，则x.equals(y)也返回true。

(3)传递性。对于任意的x、y、z，如果有x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)一定返回true。

(4)一致性。对于任意的x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应该保持一致，要么一直是true，要么一直是false。

(5)对任何不是null的x，x.equals(null)一定返回false。