java:==,equals(),hashCode()的比较

java:==,equals(),hashCode()的比较

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) {
       return (this == obj);   //默认的equals方法,直接调用==,比较对象地址
}

    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() {
      int h = hash;    //Default to 0 ### String类中的私有变量,
      if (h == 0 && value.length > 0) {    //private final char value[]; ### Sting类中保存的字符串内容的的数组
          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;
        System.out.print("基本类型比较a==b:");
        System.out.println(a == b);
        System.out.println("");
        
        String s1 = "abc";
        String s2 = "abc";
        System.out.print("String类型比较s1==s2:");
        System.out.println(s1 == s2);
        System.out.println("");
        
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.print("String类型用new String()比较s1==s2:");
        System.out.println(s3 == s4);
        System.out.println(s1 == s3);
        System.out.println("");
        
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.print("包装类型比较i1==i2:");
        System.out.println(i1 == i2);
        System.out.println("");
        
        Integer i3 = 128;
        Integer i4 = 128;//此时输出false是因为Integer在-128-127之间会缓存,超出这个范围就不会缓存了,详解请看https://blog.csdn.net/qq_29229567/article/details/84628651
        System.out.print("包装类型比较i3==i4:");
        System.out.println(i3 == i4);
        System.out.println("");
        
        Integer i5 = new Integer("1");
        Integer i6 = new Integer("1");
        System.out.print("包装类型用new Integer()比较i5==i6:");
        System.out.println(i5 == i6);//用new Integer()多少都不会缓存
        System.out.println("");
        
        Demo a1 = new Demo(1);
        Demo a2 = new Demo(1);
        Demo a3 = a2;
        System.out.print("普通引用类型比较a1 == a2:");
        System.out.println(a1 == a2);
        System.out.println(a2 == a3);//对象赋给新对象连地址都是相同的
        System.out.println("");
    }
}

比较结果为:

基本类型a==b:true

String类型比较s1==s2:true

String类型用new String()比较s1==s2:false
false

包装类型比较i1==i2:true

包装类型比较i3==i4:false

包装类型用new Integer()比较i5==i6:false

普通引用类型比较a1 == a2:false
true

    b.equals的测试代码如下:

public class Test {

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

}

比较结果为:

基本类型没有equals方法

String类型的equals方法:true

String类型的new String()的equals方法:true

String用==赋值和用new String()赋值的比较:true

包装类的equals方法:true

包装类的new Integer()用equals方法:true

Integer用==赋值和用new Integer()赋值的比较:true

    b.对象比较的测试代码如下:

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;

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

比较结果为:

普通类对象的==非默认构造:false
true

普通类对象的equals非默认构造:false
true

普通类对象的==默认构造:false

普通类对象的equals默认构造:false

对普通对象的属性进行比较equals:true
对普通对象的属性进行比较==:true

5.总结

    a.绑定。当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。
    b.绑定原因。Hashtable实现一个哈希表,为了成功地在哈希表中存储和检索对象,用作键的对象必须实现 hashCode 方法和 equals 方法。同a,必须保证equals相等的对象,hashCode 也相等。因为哈希表通过hashCode检索对象。
    c.默认。
            ==默认比较对象在JVM中的地址。
            hashCode 默认返回对象在JVM中的存储地址,重写后需要自定义规则。
            equal比较对象,默认也是比较对象在JVM中的地址,同==,重写后需要自定义规则。

©️2020 CSDN 皮肤主题: Age of Ai 设计师: meimeiellie 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值