散列算法与散列码

本文主要是介绍散列算法与散列码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在 Statistics.java 中，标准类库中的类（Integer）被用作 HashMap 的“键”。它运作
得很好，因为它具备了“键”所需的全部性质。但是，如果你创建自己的类作为 HashMap
的“键”使用，通常会犯一个错误。例如，考虑一个天气预报系统，将 Groundhog（土拨
鼠）对象与 Prediction（预测）对象联系起来。看起来相当简单，创建这两个类，使用
Groundhog 作为“键”，Prediction 作为“值”：


//: c11:Groundhog.java
// Looks plausible, but doesn't work as a HashMap key.


public class Groundhog { 
protected int number;
public Groundhog(int n) { number = n; }
public String toString() { 
return "Groundhog #" + number;
  }
} ///:~
//: c11:Prediction.java
// Predicting the weather with groundhogs.


public class Prediction { 
private boolean shadow = Math.random() > 0.5; 
public String toString() { 
if(shadow) 
return "Six more weeks of Winter!";
else
return "Early Spring!";
  }
} ///:~
//: c11:SpringDetector.java
// What will the weather be?
import com.bruceeckel.simpletest.*; 
import java.util.*; 
import java.lang.reflect.*; 


public class SpringDetector { 
private static Test monitor = new Test(); 
// Uses a Groundhog or class derived from Groundhog:
public static void
  detectSpring(Class groundHogClass) throws Exception {
    Constructor ghog = groundHogClass.getConstructor( 
new Class[] {int.class});
    Map map = new HashMap(); 
for(int i = 0; i < 10; i++) 
      map.put(ghog.newInstance( 
new Object[]{ new Integer(i) }), new Prediction());
    System.out.println("map = " + map + "\n");
    Groundhog gh = (Groundhog) 
      ghog.newInstance(new Object[]{ new Integer(3) });
    System.out.println("Looking up prediction for " + gh); 
if(map.containsKey(gh)) 
      System.out.println((Prediction)map.get(gh)); 
else
      System.out.println("Key not found: " + gh); 
  }
public static void main(String[] args) throws Exception { 
    detectSpring(Groundhog.class); 
    monitor.expect(new String[] { 
"%% map = \\{(Groundhog #\\d=" + 
"(Early Spring!|Six more weeks of Winter!)" + 
"(, )?){10}\\}",
"",
"Looking up prediction for Groundhog #3",
"Key not found: Groundhog #3"
    });
    }
} ///:~


每个 Groundhog 被给予一个标识数字，于是可以在 HashMap 中这样查找 Prediction：
“给我与#3 号 Groundhog 相关的 Prediction。”Prediction 类包含一个 boolean 值，
使用 Math.random()对其初始化；而 toString()方法则为你解释它的意义。
detectSpring()方法使用映射机制创建实例，可以使用 Class Groundhog 或其子类。如
果我们为解决当前的问题，由 Groundhog 继承了一个新类的时候，detectSpring()方法
使用的这个技巧就变得很有用了。detectSpring()首先会使用 Groundhog 和与之相关联
的 Prediction 填充 HashMap。然后打印此 HashMap。所以你可以看到，它确实被填入
了一些内容。然后使用标识数字为 3 的 Groundhog 作为“键”，查找与之相关的 Prediction
（可以看到，它一定是在 Map 中）。
这看起来够简单了，但是它不工作。问题出在 Groundhog 继承自基类 Object（如果你不
特别指定父类，任何类都会自动继承自 Object，因此所有的类最终都继承自 Object）。
所以这里是使用 Object 的 hashCode()方法生成散列码，而它默认是使用对象的地址计算
散列码。因此，由 Groundhog(3)生成的第一个实例的散列码与由 Groundhog(3)生成的
第二个实例的散列码是不同的，而我们正是使用后者进行查找的。


可能你会认为，你只需重载一份恰当的 hashCode()方法即可。但是它仍然无法正常运行，
除非你同时重载 equals()方法，它也是 Object 的一部分。HashMap 使用 equals()判断
当前的“键”是否与表中存在的“键”相同。


正确的 equals()方法必须满足下列 5 个条件：


1. 自反性：对任意 x，x.equals(x)一定返回 true。
2.对称性：对任意 x 和 y，如果 y.equals(x)返回 true，则 x.equals(y)也返回 true。
3.传递性：对任意 x，y，z，如果有 x.equals(y)返回 ture，y.equals(z)返回 true，
则 x.equals(z)一定返回 true。
4.一致性：对任意 x 和 y，如果对象中用于等价比较的信息没有改变，那么无论
调用 x.equals(y)多少次，返回的结果应该保持一致，要么一直是 true，要么
一直是 false。
5.对任何不是 null 的 x，x.equals(null)一定返回 false。


再说一次，默认的 Object.equals()只是比较对象的地址，所以一个 Groundhog(3)并不
等于另一个 Groundhog(3)。因此，如果要使用自己的类作为 HashMap 的“键”，你必
须同时重载 hashCode()和 equals()，如下所示：


//: c11:Groundhog2.java
// A class that's used as a key in a HashMap
// must override hashCode() and equals().


public class Groundhog2 extends Groundhog {
public Groundhog2(int n) { super(n); } 
public int hashCode() { return number; } 
public boolean equals(Object o) { 
return (o instanceof Groundhog2)
      && (number == ((Groundhog2)o).number);
  }
} ///:~//: c11:SpringDetector2.java
// A working key.
import com.bruceeckel.simpletest.*; 
import java.util.*; 
 






public class SpringDetector2 { 
private static Test monitor = new Test(); 
public static void main(String[] args) throws Exception { 
    SpringDetector.detectSpring(Groundhog2.class);
    monitor.expect(new String[] { 
"%% map = \\{(Groundhog #\\d=" + 
"(Early Spring!|Six more weeks of Winter!)" + 
"(, )?){10}\\}",
"",
"Looking up prediction for Groundhog #3",
"%% Early Spring!|Six more weeks of Winter!"
    });
  }
} ///:~


Groundhog2.hashCode()返回 Groundhog 的标识数字（编号）作为散列码。在此例中，
程序员负责确保不同的 Groundhog 具有不同的编号。hashCode()并不需要总是能够返回
唯一的标识码（稍后你会更加理解其原因），但是 equals()方法必须能够严格地判断两个
对象是否相同。此处的 equals()是判断 Groundhog 的号码，所以作为 HashMap 中的“键”，
如果两个 Groundhog2 对象具有相同的 Groundhog 编号，程序就出错了。


看起来 equals()方法只是检查其参数是否 Groundhog2 的实例（使用第十章学过的
instanceof 关键字），但是 instanceof 悄悄地检查了此对象是否为 null，因为如果
instanceof 左边的参数为 null，它会返回 false。如果 equals()的参数不为 null 且类型正
确，则基于 ghNumber 进行比较。从输出中可以看到，现在的方式是正确的。

当你在 HashSet 中使用自己的类作为“键”时，必须注意这个问题。

这篇关于散列算法与散列码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---