老生常谈之基础面试题：==和equals的区别

==

1.对于基本数据类型（8种） ==比较的是值相等。例如：1==1 

2.对于引用类型，                 ==比较的是他们在内存中的地址是不是想等

重点：对于第二种类型，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。因为每new一次，都会重新开辟堆内存空间。

equals

　引用类型：默认情况下，比较的是地址值。
注：不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

那么重写equals方法是怎么回事呢？

我们先看object中的equals方法，发现它用的是==。

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

我们以String中的equals为例子。

//String 中equals被重写的的源码  
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        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;
    }

ps:通过阅读String的equals方法我们发现String的equals比较的是内容是否相等、

然后我们做一个测试

 public class StringDemo {
     public static void main(String[] args) {
         String s1 = "Hello";
         String s2 = "Hello";
         System.out.println(s1 == s2);   // true  因为S1和S2都只想了内存中的相同的Hello
    }
 }

现在我们做一个改变，new 一个新的Hello字符串做比较

 public class StringDemo {
     public static void main(String args[]) {
          String str1 = "Hello";
          String str2 = new String("Hello");
          String str3 = str2; // 引用传递
          System.out.println(str1 == str2); // false  地址不同了 new 就是出来一个新的对象，要开辟新的内存地址
          System.out.println(str1 == str3); // false
          System.out.println(str2 == str3); // true
          System.out.println(str1.equals(str2)); // true 
         System.out.println(str1.equals(str3)); // true
         System.out.println(str2.equals(str3)); // true
     }
 }

我们再来做对象的比较。在不重写的equals方法的时候。

 public static void main(String[] argss) {
        Student student1 = new Student("生命壹号",22,"成都");
        Student student2 = new Student("生命壹号",22,"成都");
                System.out.println(student1==student2); //false  因为比较的是地址 new对象都是重新开辟一个新地址 所以false
                System.out.println(student1.equals(student2)); //false
 }
    static class Student {
        private String name;
        private int age;
        private String address;

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

我们继续来做对象的比较。重写的equals方法让比较内容。

 public static void main(String[] argss) {
        Student student1 = new Student("生命壹号",22,"成都");
        Student student2 = new Student("生命壹号",22,"成都");
                System.out.println(student1==student2); //比较地址 false
                System.out.println(student1.equals(student2)); //重写equals后比较内容 true
 }
    static class Student {
        private String name;
        private int age;
        private String address;

        public Student(String name, int age, String address) {
            this.name = name;
            this.age = age;
            this.address = address;
        }
        public boolean equals(Object obj){
                   //为了提高效率：如果两个内存地址相等，那么一定是指向同一个对内存中的对象，就无需比较两个对象的属性值（自己跟自己比，没啥意义嘛）
            if(this==obj){
                return true;
                         }

                     //为了提供程序的健壮性
                     //我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
                     //这个时候，我们要判断的是对象是否是某个类的对象?
                     //记住一个格式：对象名 instanceof 类名。表示：判断该对象是否是该类的一个对象
                    if(!(obj instanceof Student)){
                             return false;
                         }

                     //如果是就继续
                     Student s = (Student)obj;//强制转换，即向下转型（毕竟Object类型没有具体的对象属性）
                     return this.name.equals(s.name) && this.age == s.age && this.address.equals(s.address);//判断两个对象的属性值是否相等
                 }
    }