Java中equals()方法和==号的区别及用法

equals()方法和==号的区别及用法

1.两者比较的内容

1. ==号可以比较基本数据类型，也可以比较引用数据类型。基本数据类型比较的是值，引用数据类型比较的是地址值。
2. equals()方法比较的是引用数据类型，分为两种情况，若没有重写equals()方法，则比较的是两个对象之间的地址值，调用的是Object类的equals()方法。代码如下：

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

若重写了equals()方法，则调用的是重写后的equals()方法，比较的是两个对象的属性值。

2.String类中的equals()方法使用

1. String类中equals()的源码

    //调用equals()方法，传入要比较的对象
    public boolean equals(Object anObject) {            
        //判断传入的对象是否是同一对象，此时比较的是地址值
        if (this == anObject) {
            return true;
        }
        //判断anObject是否是String的实例
        if (anObject instanceof String) {
            //强制转换，Object强转为String类型
            String anotherString = (String)anObject;
            //得到String字符串自身的长度
            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;
    }

1. 使用示例：第一个输出为true，是因为字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。所以第一个调用比较的是同一个地址值。
   第二个输出的为true，是因为调用的是String类中的equals()方法，比较的的是字符串的内容。内容相同则输出结果为true。
   第三个输出为true，“+”号是字符串串联符号。Java中有常量优化机制，在编译的时就将String s3 = “a” + “b"中的s3转化为"ab”，而常量池中已有此对象，所以比较时调用的地址值相同。
   第四个与第二个同理。

 public class Mt {
    public static void main(String args[]){
        String s1 = "ab";
        String s2 = "ab";
        String s3 = "a" + "b";
        System.out.println(s1 == s2);//输出为true
        System.out.println(s1.equals(s2));//输出为true
        System.out.println(s2 == s3);//输出为true
        System.out.println(s2.equals(s3));//输出为true
    }
}

3.使用Object类中equals()方法的示例

1. 写一个Student类，但不重写equals()方法，代码如下：

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

写一个测试类代码如下：
第一个输出的是false，原因是使用new关键字创建了新的对象，所以地址值肯定不相同。
第二个输出的是false，原因是Student类中没有重写equals()方法，调用的是Object类中的equals()方法。底层依赖的依然是==号，比较的是地址值，所以输出为false。但是这样调用equals()方法就没有意义，所以一般我们重写equals()方法。

 public class Demo {
    public static void main(String args[]){
        Student student = new Student("mt",20);
        Student student1 = new Student("mt",20);
        System.out.println(student == student1);//输出为false
        System.out.println(student.equals(student1));//输出为false
    }
}

4.重写equals()方法后的示例

1.重写了equals()方法后的Student类代码如下：

 public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

重新运行刚才的测试代码：
代码如下：第一个输出的为false，地址值不同。
第二个输出的是true，原因是我们重写了Student类中的equals()方法。此时先判断是否是同一对象，接着判断传入的对象是否是Student类的一个实例。对传入的对象的属性值age进行比较，然后比较属性值name此时name调用的equals()方法是String类中的方法，比较两个name的字符串是否相同。
2.重写equals()方法时一般重写hashcode()方法，若上例未重写hashcode()方法，则会造成，equals()输出为true，但是此时的两个对象的hashcode值不相等。若重写了hashcode()方法，则两个对象视为同一对象的时候，hashcode()值相等，equals()方法输出也为true。

public class Demo {
    public static void main(String args[]){
        Student student = new Student("mt",20);
        Student student1 = new Student("mt",20);
        System.out.println(student == student1);//输出为false
        System.out.println(student.equals(student1));//输出为true
    }
}