【深入Java基础】java中的hash和equals

关于hash的基本知识

Hash，一般翻译做“散列”，也有直接音译为”哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系

了解了hash基本定义，就不能不提到一些著名的hash算法，MD5 和 SHA1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢？
这里简单说一下：

1) MD4
MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现–它是基于 32 位操作数的位操作来实现的。

2) MD5
MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好

3) SHA1 及其他
SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。

那么这些Hash算法到底有什么用呢？
Hash算法在信息安全方面的应用主要体现在以下的3个方面：

1) 文件校验
我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。
MD5 Hash算法的”数字指纹”特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。

2) 数字签名
Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称”数字摘要”进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。

3) 鉴权协议
如下的鉴权协议又被称作”挑战–认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。

Java中的hashCode

1. Object中的hashCode

HashCode是用来在散列存储结构中确定对象的存储地址的，通过计算hash值，来快速定位对象的位置，避免了逐个查找的效率低的问题

举个例子，如果有0，1，2，… ，9，这10个存储空间，如果随机的存放一个对象，则查找的时候需要一次遍历这10个存储空间，而有了hashCode后，可以计算对象的hash值直接定位到该对象的存储空间，大大提高了查找效率。

另外，hashCode对于HashTable、HashMap也有很有用。

我们通过以下代码进入到Object中的hashCode方法

    Object o = new Object();
    o.hashCode();

源码只有一句话，如下：

     public native int hashCode();

看似是一个接口中的方法，其实不是。它是一个本地方法。也就是说它是又非java语言实现的（比如是用C/C++实现的），并且被编译成dll库，让Java程序去调用。

对于如何调用dll库，将在下一篇文章中学习讨论。

对于这样存在于Object中的一个方法，很显然是需要让其子类重写这个方法的。

我们选中这个方法，然后ctr+alt+B查找他的子类重写：

可以看到有996个类重写了hashCode方法。

我们找到最常用的String、Integer和Double类，找出其中的hashCode方法：

String中的hashCode：

    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;
    }

2. Integer中的hashCode：

    public static int hashCode(int value) {
        return value;
    }

3. Double中的hashCode：

     public static int hashCode(double value) {
        long bits = doubleToLongBits(value);
        return (int)(bits ^ (bits >>> 32));
    }

其中String中的hashCode在上一篇文章（switch用String作参数）中已经学习过了。这里看一下另外两个。

Integer中的hashCode很简单，就是返回它的值。

Double中的hashCode是先获取doubleToLongBits为bits，然后将bits进行无符号右移32位，然后再与bits进行异或运算得到hasCode.

这里有个doubleToLongBits方法，查源码：

    public static long doubleToLongBits(double value) {
        long result = doubleToRawLongBits(value);
        // Check for NaN based on values of bit fields, maximum
        // exponent and nonzero significand.
        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
              DoubleConsts.EXP_BIT_MASK) &&
             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
            result = 0x7ff8000000000000L;
        return result;
    }

    public static native long doubleToRawLongBits(double value);

它返回的IEEE754规定的浮点数的表示方法的二进制转换为10进制后的Long类型。

对于数的表示方法日后再论。

Java中的equals

equals是判断两个对象的值是否相等的常用方法。

1. Integer中的equals

查看源码：

     public boolean equals(Object obj) {
        if (obj instanceof Integer) {//判断obj是否是Integer的一个实例
            return value == ((Integer)obj).intValue();判断两个Integer对象的值是否相等
        }
        return false;//不同类型自然是不想等的，返回false
    }

可以看到它是判断同一对象的值是否相等，如果相等就返回true，否则返回false。

2. String中的equals

查看源码：

     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;
    }

可以看到，第一个if里边用了==判断，如果当前对象==另一对象，那么它就是同一个对象的引用，完全相同，所以对象的值必然相等。

第二个if里边通过比较两个字符数组的对应位置的字符是否相等来判断字符串是否相等，很容易理解。

3. Double中的equals

查看源码：

        public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

可以看到它比较的是doubleToLongBits的值。

所以对于equals来说，仅仅比较的是两个对象的值（仅限于基本数据类型的包装类和String），如果值相等就为true，不相等就为false。

而==对于对象是比较的两个对象的地址，即只有是同一个对象（的引用）时才为true，比较更为严格。对于基本数据比较的也是值。

事实上，Object里的equals就是用的==，源码如下：

        public boolean equals(Object obj) {
            return (this == obj);
        }

所以，我们自己写的类是默认继承它的equals方法的，所以如果我们不自己重写equals方法的话实际上就相当于用的是==。

这是一个重写equals方法的例子：

Stu类：

    public class Stu {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

我们假设只有年龄和姓名同时相等才为同一个学生，重写equals如下：

     @Override
    public boolean equals(Object obj) {
        if(this == obj)
            return true;
        if(obj instanceof Stu){
            Stu s = (Stu)obj;
            if(s.name==name&&s.age==age){
                return true;
            }
        }
        return false;
    }

当重写了equals时最好重写一下hashCode，避免产生混淆（因为按照规定，如果equals为true则hashCode必须相等，反之依然）。

  @Override
    public int hashCode(){
        Stu s = (Stu)this;
        return name.hashCode();        
    }

当然我这里用name作为Stu对象的hashCode是有问题的，因为name是可能重复的，所以实际情况下应用类似于id等属性或者采用某种算法来保证不同对象的hashCode的唯一性。