java-散列和散列码

正在看《Thinking in java》学习散列码相关的知识,在这总结一下吧。

先来看一个例子

class Student{    protected int id;//当前类的成员与继承该类的类能访问.    public Student(int id) {        this.id = id;    }    @Override    public String toString() {        return "Student #" + id;    }}class Score{    private static Random random = new Random(47);    private int score = random.nextInt(100);    @Override    public String toString() {        return String.valueOf(score);    }}public class HashCodeTest {    public static <T extends Student> void studScore(Class<T> type) throws Exception{        Constructor<T> stud = type.getConstructor(int.class);        //利用反射机制来实例化及使用Student类和任何从Student派生出来的类        Map<Student, Score> map = new HashMap<>();        for (int i = 0; i < 10; i++) {            map.put(stud.newInstance(i), new Score());        }        System.out.println("map" + map);        Student student = stud.newInstance(3);//使用id为3的Student作为键        System.out.println("寻找学生: " + student);        if (map.containsKey(student)) {            System.out.println(map.get(student));        }else {            System.out.println("此学生不存在");        }    }    public static void main(String[] args) throws Exception{        studScore(Student.class);    }}

输出

map{Student #1=55, Student #4=61, Student #5=29, Student #3=61, Student #8=22, Student #7=0, Student #0=58, Student #2=93, Student #9=7, Student #6=68}寻找学生: Student #3此学生不存在

但是结果它无法找到id为3的键。问题出在Student是自动继承自基类Object，这里是使用Object的hashCode()方法生成散列码，默认是使用对象的地址计算散列码。第一个Student(3)的实例和第二个的散列码是不同的。所以无法找到。

所以需要恰当的覆盖hashCode()方法。并且同时覆盖equals方法。因为HashMap使用equals()判断当前的键是否与表中存在的键相同

equals()满足下列条件：
1）自反性 对于任意x, x.equals(x)必定返回true。
2）对称性 对于任意x,y，x.equals(y)与y.equals(x)的返回值相同。
3）传递性 对于任意x,y,z，如果x.equals(y)与y.equals(z)返回值相同，那么x.equals(z)返回值也相同。
4）一致性 对于任意的x,y，无论x.equals(y)执行多少次，返回值要么是true，要么为false。
5）对于任意x != null, x.equals(null)返回false。

所以要使用自己的类作为HashMap的键，必须同时覆盖hashCode()和equals().

class Student2 extends Student{    public Student2(int id) {        super(id);    }    @Override    public int hashCode() {        return id;//返回id作为散列码    }    @Override    public boolean equals(Object obj) {        return obj instanceof Student2 && (id == ((Student2)obj).id);        //instanceof检查了此对象是否为null，然后基于每个对象中实际的id进行比较    }}public class HashCode2 {    public static void main(String[] args) throws Exception {        HashCodeTest.studScore(Student2.class);    }}

输出

map{Student #0=58, Student #1=55, Student #2=93, Student #3=61, Student #4=61, Student #5=29, Student #6=68, Student #7=0, Student #8=22, Student #9=7}寻找学生: Student #361

为速度而散列

线性查询是最慢的查询方法
散列将键保存在某处，以便能够很快找到。存储一组元素最快的数据结构是数组，所以使用它来表示键的信息。
数组并不保存键本身，而是通过键对象生成一个数字，将其作为数组的下标，这个数字就是散列码。
冲突有外部链接处理，数组并不直接保存值，而是保存值得list。然后对list中的值使用equals()方法进行线性的查询。（这部分的查询会比较慢）

散列表的“槽位”(slot)通常被称为桶位（bucket）,Java的散列函数使用2的整数次方（求余和除法是最慢的操作，使用2的整数次方长度的散列码，可以用掩码代替除法，可以减少get()中%操作的开销）。

覆盖hashCode()
无论何时，对同一个对象调用hashCode()都应该生成同样的值。且不能依赖易变的数据。
也不应该使hashCode()依赖于唯一性的对象信息。

以String类为例，如果程序中有多个String对象，都包含相同的字符串序列，那么这些String对象都映射到同一块内存区域。

public class StringTest {    public static void main(String[] args) {        String str1 = new String("hello");        String str2 = new String("hello");        System.out.println(str1.hashCode());        System.out.println(str2.hashCode());        System.out.println(str1.equals(str2));        System.out.println(str1 == str2);        //双等号就是比较的栈里面的内容，原始数据类型和地址都是放在栈里面的。而equals则是根据地址拿到堆里面的内容进行比较。    }}

输出

9916232299162322truefalse

对String而言，hashCode()明显是基于String的内容的。根据对象的内容生成散列码，散列码不一定是独一无二，但是通过hashCod()和equals()必须能够完全确定对象的身份

来看看String的源码

public int hashCode() {        int h = hash;        if (h == 0 && value.length > 0) {            char val[] = value;            for (int i = 0; i < value.length; i++) {                h = 31 * h + val[i];            }            hash = h;        }        return h;    }   //String类中的hashCode计算方法还是比较简单的，就是以31为权，每一位为字符的ASCII值进行运算.public boolean equals(Object anObject) {        if (this == anObject) {            return true;        }        if (anObject instanceof String) {            String anotherString = (String)anObject;            int n = value.length;            if (n == anotherString.value.length) {                char v1[] = value;                char v2[] = anotherString.value;                int i = 0;                while (n-- != 0) {                    if (v1[i] != v2[i])                        return false;                    i++;                }                return true;            }        }        return false;    }