【java系列】==和equals的详解(含源码)_hashcode

大家好，我是walker
一个从文科自学转行的程序员~
爱好编程，偶尔写写编程文章和生活
欢迎关注公众号【I am Walker】，一块学习编程~

== 和 equals 的区别是什么

==

• 它的作用是判断两个对象的地址是不是相等。
• 即:判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)

面试中常考的有Integer和String问题

Integet问题

package objectOrientedTest;


public class EqualsDemo {
    public static void main(String[] args) {

        /**
        * 当==比较的是引用数据类型是，比较的是内存地址
         * 但是这里存在区别，因为Integer在-128,127之前，可以视为一个对象
         * 在超出这个范围的时候，就会新建对象，所以i1和i2结果为false
         * i3和i4结果为true
        */
        Integer i1=128;
        Integer i2=128;
        System.out.println(i1 == i2); //false
        Integer i3=126;
        Integer i4=126;
        System.out.println(i3 == i4); //true
        /**
        * 当==比较的是基本数据类型时，比较的是值
        */
        int ia=7;
        int ib=7;
        System.out.println(ia == ib); //true
    }
}

String问题

在==的问题上，String经常被拿出来当面试题，主要是String新建对象时，与常量池有关
1、如果是使用new String()创建对象，则会直接创建对象
2、如果是使用="xxx"生成对象，则会将该值放在常量池中，那么下次使用这种方式创建对象的时候，就会先去查找常量池是否存在该数据，如果存在的话，则直接返回常量池中的地址。

        String aa = new String("ab");
        String bb = new String("ab");

        String s1="ab";
        String s2="ab";
        /**
        * aa和bb是使用new String创建的，因此是不同对象
        */
        System.out.println(aa == bb); //false
        /**
        * s1和s2是使用=“”的方式，因此都是从常量池获取数据，对象一致
        */
        System.out.println(s1 == s2); //true
        /**
        * new String的数据不会放入常量池，因此对象不同
        */
        System.out.println(s1 == aa); //false

equals() :

它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

情况1：类没有覆盖 equals() 方法。

则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。

例如：

package objectOrientedTest;


public class EqualsDemo {
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        /**
        * equals没被重写，Object的equals是比较对象地址的
        */
        System.out.println(a.equals(b));
    }
}

情况2：类覆盖了 equals() 方法。

一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
举个例子：

package objectOrientedTest;


public class EqualsDemo {
    public static void main(String[] args) {
    
        String aa = new String("ab");
        String bb = new String("ab");

        String s1="ab";
        String s2="ab";

        System.out.println(s1 == aa); //false

        /**
        * 因为equals被String重写过，因此返回值都一致
        */
        System.out.println(s1.equals(aa)); //true
        System.out.println(s1.equals(s2)); //true
        System.out.println(aa.equals(bb)); //true



    }
}

String重写equals源码

//String内部实现数据结构
private final char value[];    


public boolean equals(Object anObject) {
        //如果对象地址相等，则返回true
        if (this == anObject) {
            return true;
        }
        
        //如果参数类型为String
        if (anObject instanceof String) {
            //将Object转成String
            String anotherString = (String)anObject;
            //原本String的字符长度
            int n = value.length;
            //判断原本String的长度和参数的字符长度是否相同
            if (n == anotherString.value.length) {
                //如果相同，则获取两者的字符数组
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                //如果n【字符长度】不等0.则循环比较，如果字符有一个不同，则返回false
                //全部相同则返回true
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

hashCode 与 equals (重要)

什么是hashCode()

hashCode() 的作用是获取哈希码，也称为散列码；
它实际上是返回一个int整数。
这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode()函数。

public native int hashCode();

散列：
散列也叫散列函数，是一种可以将任意长度的输入转换为固定长度输出的算法，因此不同的输入可能产生相同的输出。

散列码：
散列码就是按照散列函数生成的结果。

散列表：
存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

为什么要有 hashCode

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

• 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。
• 但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

hashCode()与equals()的相关规定

1、如果两个对象相等，则hashcode一定也是相同的

        String s1="ab";
        String s2="ab";
        System.out.println(s1.hashCode() == s2.hashCode()); //true

2、两个对象相等，对两个对象分别调用equals方法都返回true

        String s1="ab";
        String s2="ab";
        System.out.println(s1.equals(s2)); //true

3、两个对象有相同的hashcode值，它们也不一定是相等的

        /**
        * hashcode相同的字符串
        */
        String aa="儿女";
        String bb="农丰";
        //两者的hashcode都为667668，hashcode是相同的
        System.out.println(aa.hashCode());
        System.out.println(bb.hashCode());
        System.out.println(aa.equals(bb)); //返回为false

因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
hashCode() 的默认行为是对堆上的对象产生独特值。
如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

对象的相等与指向他们的引用相等，两者有什么不同？

• 对象的相等 比的是内存中存放的内容是否相等而
• 引用相等 比较的是他们指向的内存地址是否相等。

String的hashcode源码

//哈希    
private int hash; // Default to 0    
//字符数组
    private final char value[];



    public int hashCode() {
        int h = hash;
        //如果hash==0，然后value的长度>0
        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;
    }

疑问：为什么选择31作为系数？

参考链接：关于hashcode 里面 使用31 系数的问题
在存储数据计算hash地址的时候，我们希望尽量减少有同样的hash地址，所谓“冲突”。如果使用相同hash地址的数据过多，那么这些数据所组成的hash链就更长，从而降低了查询效率！所以在选择系数的时候要选择尽量长(31 = 11111[2])的系数并且让乘法尽量不要溢出(如果选择大于11111的数，很容易溢出)的系数，因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。
31可以 由i*31== (i<<5)-1来表示，现在很多虚拟机里面都有做相关优化，使用31的原因可能是为了更好的分配hash地址，并且31只占用5bits！
在java乘法中如果数字相乘过大会导致溢出的问题，从而导致数据的丢失.
而31则是素数（质数）而且不是很长的数字，最终它被选择为相乘的系数的原因不过与此！