JAVA Harshtable创建“关键”类——散列码与对象地址的差异

本文链接：https://blog.csdn.net/dong24k/article/details/110420834

import java.util.Hashtable;

class Groundhog{
    int ghNumber;
    Groundhog(int n){ghNumber=n;}
//    public String toString(){
//        return Integer.toString(ghNumber);
//    }
}
class Prediction{
    boolean shadow=Math.random()>0.5;
    public String toString(){
        if (shadow)
            return "Six more weeks of Winter!";
        else
            return "Early Spring!";
    }
}

public class SpringDetector {
    public static void main(String[] args) {
        Hashtable ht=new Hashtable();
        for (int i=0;i<10;i++)
            ht.put(new Groundhog(i),new Prediction());
        System.out.println("ht=" + ht + "\n");
        System.out.println("Looking up prediction for groundhog #3: ");
        Groundhog gh=new Groundhog(3);
        if (ht.containsKey(gh)) {
            System.out.println(ht.get(gh));
        } else {
            System.out.println("....");
        }

    }
}

每个Groundhog都具有一个标识码，所以在散列表中查找一个Prediction，只需要指示它“告诉我与Groundhog号码相关的Prediction”。Prediction类包含了一个布尔值，用Math.randon()进行初始化，以及一个toString()为我们解释结果。在main()中，用Groundhog以及与它相关的Prediction填充一个散列表。散列表被打印出来之后，以便我们可以看出它确实是被填充了。随后用一个标识号码为3的一个Groundhog查找与Groundhog#3对应的预报。
看起来十分的简单但是，实际上是不可行的。问题在于Groundhog是从通用的Object根类继承的（若当初没有指定基础类，则所有类最终都是从Object继承）。事实上用Object的hashcode()方法生成每个对象的散列码，而且默认情况下只是用他的对象的地址。所以，Goundhog(3)的第一个实例并不会产生于Groundhog(3)第二个实例相等的散列码，而我们使用第二个实例进行检索的。
运行的结果如下：

ht={c08.Groundhog@b4c966a=Six more weeks of Winter!, c08.Groundhog@5f184fc6=Six more weeks of Winter!, c08.Groundhog@10f87f48=Early Spring!, c08.Groundhog@7b23ec81=Early Spring!, c08.Groundhog@5b480cf9=Six more weeks of Winter!, c08.Groundhog@6acbcfc0=Early Spring!, c08.Groundhog@723279cf=Early Spring!, c08.Groundhog@15aeb7ab=Six more weeks of Winter!, c08.Groundhog@3feba861=Early Spring!, c08.Groundhog@6f496d9f=Six more weeks of Winter!}

Looking up prediction for groundhog #3: 
....

大家或许认为此时要做的全部事情就是正确的覆盖hashcode()。但这样依然不行，除非再做另一件事情：覆盖也属于Object一部分的equals()。当散列表试图判断我们的键是否等于表内的某个键时，就会用到这个方法。
同样的，默认的Object.equals()只是简单的比较对象地址，所以一个Groundhog(3)并不会等于另一个Groundhog(3)。
因此为了在散列表中将自己的类作为键使用，必须同时覆盖hashcode()和equals()，就像下面展示的那样：

import java.util.Hashtable;

class Groundhog2{
    int ghNumber;
    Groundhog2(int n) {ghNumber=n;}
    public int hashCode() {return ghNumber;}
    public boolean equals(Object o){
        return (o instanceof Groundhog2)
                && (ghNumber == ((Groundhog2)o).ghNumber);
    }
}
public class SpringDetector2 {
    public static void main(String[] args) {
        Hashtable ht=new Hashtable();
        for (int i=0;i<10;i++)
            ht.put(new Groundhog2(i),new Prediction());
        System.out.println("ht= "+"\n"+ht+"\n");
        System.out.println("Looking up prediction for groundhog #3: ");
        Groundhog2 gh=new Groundhog2(3);
        if (ht.containsKey(gh))
            System.out.println((Prediction)ht.get(gh));
    }
}

运行的结果是：

ht= 
{c08.Groundhog2@9=Six more weeks of Winter!, c08.Groundhog2@8=Early Spring!, c08.Groundhog2@7=Early Spring!, c08.Groundhog2@6=Early Spring!, c08.Groundhog2@5=Early Spring!, c08.Groundhog2@4=Early Spring!, c08.Groundhog2@3=Early Spring!, c08.Groundhog2@2=Six more weeks of Winter!, c08.Groundhog2@1=Six more weeks of Winter!, c08.Groundhog2@0=Six more weeks of Winter!}

Looking up prediction for groundhog #3: 
Early Spring!

Groundhog2.hashcode()将土拨鼠作为为一个标识符返回（在这个例子中，程序员需要保证没有两个土拨鼠使用同样的ID号码并存）。为了返回独一无二的标识符，并不需要hashcode()，equals()方法必须能够判断两个对象是否相等。
equals()方法要进行两种检查：检查对象是否为null；若不为null，则继续检查是否为Groundhog2的一个实例(要用到instanceof关键字)。即使为了继续执行equals()，它也应该是一个Groundhog2。正如大家看到的那样，这种比较建立在实际ghNumber的基础上，这一次一旦我们运行程序，就会看到它最终产生了正确的输出（许多java库的类都覆盖这两种方法，以便与自己提供的内容相适应）。