Java：==，equals()，hashCode()的比较

王小二(海阔天空)

已于 2024-09-06 18:11:36 修改

阅读量457

点赞数 5

分类专栏：编程语言(Java基础) 文章标签： java 开发语言 equals hashCode

于 2017-12-20 17:20:08 首次发布

本文链接：https://blog.csdn.net/qq_29229567/article/details/78855497

版权

编程语言(Java基础) 专栏收录该内容

95 篇文章 25 订阅

订阅专栏

1、==

“==”操作符的用途如下：

a、用于基本数据类型的比较;
b、判断引用是否指向堆内存的同一块地址（比较两个对象在JVM中的地址）。

在简单类型中(int等)，可以使用该方法进行比较，这种类型没有equals方法，int的值是存在栈中的，==比较的是栈的内容是否相同。

在String类型中，比较特殊，用String=“”；这种进行赋值时，两个相同的值用==比较也是相同的。但是用new String()，赋值就不相同。说明String=“”时，java会检查在堆中是否由相同的值，如果有，把新对象的地址也同老对象的地址赋为相同，因此==比较会相同。但是new String()开辟的就是两个栈，因此用==比较不会相同。

对于包装类，如Integer=“”；时，在-128-127会有缓存。其他的情况与String类似。测试代码见下文。

2、equals()

equals是根类Obeject中的方法，包含在jdk里面，但并不适合绝大多数场景，通常需要重写。源代码如下：

public boolean equals(Object obj) {
    //默认的equals方法，直接调用==，比较对象地址
    return (this == obj);   
}

equals的作用：用于判断两个变量是否是对同一个对象的引用，即堆中的内容是否相同，返回值为布尔类型。如int，float等和String类对象（因为该类已重写了equals和hashcode方法）时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址。

equals的基本使用： boolean b = obj1.equals(obj2);

比较不同对象内容是否相同，应该重写equals，因为==用于比较引用类型和比较基本数据类型时具有不同的功能。

对于equals：当是String类型或者是包装类，如Integer时，比较的就是堆中的值，Integer也无缓存之说。对于普通类，equals比较的内存的首地址，这时候和==是一样的，即比较两边指向的是不是同一个对象。测试代码见下文。

3、hashCode()

hashCode是根类Obeject中的方法。默认情况下，Object中的hashCode() 返回对象的32位jvm内存地址。也就是说如果对象不重写该方法，则返回相应对象的32为JVM内存地址。

String类源码中重写的hashCode方法如下：

public int hashCode() {
    //Default to 0 ### String类中的私有变量
    int h = hash;    

    //private final char value[]; ### Sting类中保存的字符串内容的的数组
    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源码中使用private final char value[];保存字符串内容，因此String是不可变的。

看下面的例子，没有重写hashCode方法的类，直接返回32位对象在JVM中的地址；Long类重写了hashCode方法，返回计算出的hashCode数值：

public class ComHashcode{
      public static void main(String[] args) throws Exception {
          ComHashcode a = new ComHashcode();
          ComHashcode b = new ComHashcode();
          System.out.println(a.hashCode());    //870919696
          System.out.println(b.hashCode());    //298792720
          
          Long num1 = new Long(8);
          Long num2 = new Long(8);
          System.out.println(num1.hashCode());    //8
          System.out.println(num2.hashCode());    //8
     }
 }

4、测试代码

a.==的测试代码如下：

class Demo{
    int i;
    public Demo(int i){
        this.i = i;
    }
}

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        //基本类型a==b:true
        System.out.println(a == b);
        System.out.println("");
        
        String s1 = "abc";
        String s2 = "abc";
        //String类型比较s1==s2:true
        System.out.println(s1 == s2);
        System.out.println("");
        
        String s3 = new String("abc");
        String s4 = new String("abc");
        //String类型用new String()比较s3==s4:false
        System.out.println(s3 == s4);
        //String类型用new String()比较s1==s3:false
        System.out.println(s1 == s3);
        System.out.println("");
        
        Integer i1 = 1;
        Integer i2 = 1;
        //包装类型比较i1==i2:true
        System.out.println(i1 == i2);
        System.out.println("");
        
        Integer i3 = 128;
        Integer i4 = 128;
        //包装类型比较i3==i4:false
        //此时输出false是因为Integer在-128-127之间会缓存，超出这个范围就不会缓存了，详解请看https://blog.csdn.net/qq_29229567/article/details/84628651
        System.out.println(i3 == i4);
        System.out.println("");
        
        Integer i5 = new Integer("1");
        Integer i6 = new Integer("1");
        //包装类型用new Integer()比较i5==i6:false
        //用new Integer()多少都不会缓存
        System.out.println(i5 == i6);
        System.out.println("");
        
        Demo a1 = new Demo(1);
        Demo a2 = new Demo(1);
        Demo a3 = a2;
        //普通引用类型比较a1 == a2：false
        System.out.println(a1 == a2);
        //普通引用类型比较a2 == a3：true
        //对象赋给新对象连地址都是相同的
        System.out.println(a2 == a3);
        System.out.println("");
    }
}

b.equals的测试代码如下：

public class Test {

    public static void main(String[] args) {
        System.out.println("基本类型没有equals方法");
        System.out.println("");
        
        String s1 = "abc";
        String s2 = "abc";
        //String类型的equals方法:true
        System.out.println(s1.equals(s2));
        System.out.println("");
        
        String s3 = new String("abc");
        String s4 = new String("abc");
        //String类型的new String()的equals方法：true
        //可以看出比较equals方法比较的是堆里的值是否相同
        System.out.println(s3.equals(s4));
        System.out.println("");
        
        //String用==赋值和用new String()赋值的比较：true
        System.out.println(s1.equals(s3));
        System.out.println("");
        
        Integer i1 = 1;
        Integer i2 = 1;
        //包装类的equals方法：true
        System.out.println(i1.equals(i2));
        System.out.println("");
        
        Integer i3 = new Integer(1);
        Integer i4 = new Integer(1);
        //包装类的new Integer()用equals方法：true
        System.out.println(i3.equals(i4));
        System.out.println("");
        
        //Integer用==赋值和用new Integer()赋值的比较：true
        System.out.println(i1.equals(i3));
        System.out.println("");
    }

}

c.对象比较的测试代码如下：

class Student{
    public String name;
    public int age;

    public Student(){
        
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void test(){
        System.out.println(this.name);
        System.out.println(this.age);
    }
}

public class Test {

    public static void main(String[] args) {
        Student s1 = new Student("张三",21);
        Student s2 = new Student("张三",21);
        Student s3 = new Student();
        Student s4 = new Student();
        Student s5 = s1;

        //普通类对象的==非默认构造：false
        System.out.println(s1 == s2);
        //普通类对象的==非默认构造：true
        System.out.println(s1 == s5);
        System.out.println("-");
        
        //普通类对象的equals非默认构造：false
        System.out.println(s1.equals(s2));
        //普通类对象的equals非默认构造：true
        System.out.println(s1.equals(s5));
        System.out.println("");
        
        //普通类对象的==默认构造：false
        System.out.println(s3 == s4);
        System.out.println("");
        
        //普通类对象的equals默认构造：false
        System.out.println(s3.equals(s4));
        System.out.println("");
        
        //对普通对象的属性进行比较equals：true
        System.out.println(s1.name.equals(s2.name));
        //对普通对象的属性进行比较==：true
        System.out.println(s1.name == s2.name);
    }
}