java中==和equals和hashCode的區(qū)別

"=="亏钩、equals契沫、hashCode的含義

"==":在Java中沛婴，"=="是一種運算符，用來表示兩個變量是否相等督赤。

int a = 12;
int b = 10;
boolean boo = a == b;

equals是Object類的一個方法嘁灯，用于比較兩個對象是否相等，默認比較的是兩個對象的地址值够挂。

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

hashCode也是Object類的一個方法旁仿，返回一個離散的int型整數(shù)，hashCode通過計算返回兩個hash值孽糖，這個值可能是相同的可能是不同的枯冈，所以拿hashCode的值進行比較是不安全、不可靠的办悟。

System.out.println("1".hashCode());  // 結(jié)果是一個hash值尘奏，49

"=="與equals的對比

"=="比較的是地址值，equals如果沒有重寫的話也是拿兩個對象的地址值進行比較的病蛉。
我們在日常開發(fā)中經(jīng)常拿equals對String字符串進行比對炫加，拿到最終的Boolean類型值進行判斷，但是我們通常用到的equals都是通過String類重寫過的铺然。

 public boolean equals(Object anObject) {
        // 首先比較兩個值得地址值是否一樣
        if (this == anObject) {
            return true;
        }
        // 判斷該值是否是String類的一個實例
        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;
 }

所以得出結(jié)論，Object下的equals作用和"=="相同魄健，String下的equals作用和"=="不同赋铝。

equals與hashCode的關(guān)系

Java對于兩者有這樣的約束

如果兩個值equals，他們的hashCode就一定相同沽瘦。
如果兩個值不equals革骨，他們的hashCode可能相同，可能不同析恋。
如果兩個值的hashCode相同良哲，他們不一定equals。
如果兩個值的hashCode不同助隧，他們一定不equals筑凫。
同一個對象多次調(diào)用hashCode()，返回的值總是相等的并村。
特別注意如果我們重寫了equals漏健，必須要重寫hashCode，否則會為代碼埋下bug橘霎，從而導致該類無法結(jié)合所有基于散列的集合一起正常運作，這樣的集合包括HashMap殖属、HashSet和Hashtable姐叁。

如何重寫equals與hashCode

先來看一段只重寫equals而不重寫hashCode的代碼，看看會出現(xiàn)怎樣的問題。

bean類:重寫了equals外潜，判斷只當name相同就equals原环。

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

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object o) {
        if (name == null || o == null) {
            return false;
        }
        if (o instanceof Student) {
            Student student = (Student) o;
            // 名字相同就equals
            return name.equals(student.name);
        }
        return false;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Test類

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("hulk", 12);
        Student student2 = new Student("hulk", 13);

        System.out.println(student1.equals(student2));  // 輸出結(jié)果:true
        System.out.println(student1.hashCode());        // 輸出結(jié)果:1627674070
        System.out.println(student2.hashCode());        // 輸出結(jié)果:1360875712

        Set<Student> set = new HashSet<>();
        set.add(student1);
        set.add(student2);
        // 輸出結(jié)果:[Student{name='hulk', age=12}, Student{name='hulk', age=13}]
        System.out.println(set);
    }
}

可以看到當兩個對象equals時，他們的hashCode仍然不同处窥，這明顯不符合Java約束嘱吗，而且導致了在HashSet中存儲了兩份。

把重寫的hashCode加入之后看看會是怎樣的結(jié)果滔驾。

  @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + (name == null ? 0 : name.hashCode());
        return result;
    }

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("hulk", 12);
        Student student2 = new Student("hulk", 13);

        System.out.println(student1.equals(student2));  // 輸出結(jié)果:true
        System.out.println(student1.hashCode());        // 輸出結(jié)果:3214683
        System.out.println(student2.hashCode());        // 輸出結(jié)果:3214683

        Set<Student> set = new HashSet<>();
        set.add(student1);
        set.add(student2);
        // 輸出結(jié)果:[Student{name='hulk', age=12}]
        System.out.println(set);
    }
}

此時hashCode的值相等了谒麦，而且hashSet里也只有了一個hulk(學生的名字)。

一些關(guān)于"=="的面試題

public class exercises {
    public static void main(String[] args) {
        int int1 = 12;
        int int2 = 12;
        Integer Integer1 = new Integer(12);
        Integer Integer2 = new Integer(12);
        Integer Integer3 = new Integer(127);

        Integer a7 = 127;
        Integer b7 = 127;

        Integer a8 = 128;
        Integer b8 = 128;

        String s1 = "str";
        String s2 = "str";
        String str1 = new String("str");
        String str2 = new String("str");

        // int1 == int2 true,"=="是比較變量是否相等的
        System.out.println(int1 == int2);
        // int1 == Integer2 true,Integer會自動拆箱為int哆致，然后再比對
        System.out.println(int1 == Integer2);
        // Integer1 == Integer2 false,兩者地址值不同
        System.out.println(Integer1 == Integer2);
        // Integer3 == a7 false,Integer3是new出來的绕德，a7指向的是緩存中的127，地址值不同
        System.out.println(Integer3 == a7);
        // a7 == b7 true,都指向緩存中的127
        System.out.println(a7 == b7);
        // a8 == b8 false,緩存大小為[-128,127]
        System.out.println(a8 == b8);
        // s1 == s2 true,s1先在緩存中創(chuàng)建"str"摊阀，之后s2也指向了這個值
        System.out.println(s1 == s2);
        // str1 == str2 false,new出來的都是一個新的地址值耻蛇，所以地址值不同
        System.out.println(str1 == str2);
        // s1 == str1 false,地址值不同
        System.out.println(s1 == str1);
    }
}

Integer a7  = 127;
java在編譯的時候,被翻譯成-> Integer a7 = Integer.valueOf(127);

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}