== 和 equals

==

1. == 是Java中的运算符
2. == 在比较基本数据类型的后比较的是基本数据类型的值是否一致

   	 // 定义两个基本数据类型的变量
       int a = 10;
       int b = 10;
       int c = 11;
       System.out.println(a == b); // 返回true
       System.out.println(b == c); // 返回false

3. == 在比较引用数据类型的时候比较的是引用地址是否是同一个

 	// 比较引用变量
  	Student stu1 = new Student("测试",20,"男");
    Student stu2 = new Student("测试",20,"男");
    Student stu3 = stu1;
    System.out.println("第三个结果输出："+ (stu1 == stu2));   // 返回false
    System.out.println("第四个结果输出："+ (stu1 == stu3));   // 返回true

equals

4. equals是Object基类中的一个比较方法，在没用重写过Object中的equals方法时本质上和==是一致的。可以看下Object中equals方法的源码

public boolean equals(Object obj) {
       // 本质上就是返回 == 比较后的结果，注释是我自己加的
       return (this == obj);
   }

5. equals不能比较基本数据类型的变量
6. String和包装类中的equals方法是重写后的方法，比较是字符串的内容是否一致，看下重写后的String类型的源码如下

public boolean equals(Object anObject) {
		// 首选比较字符串在内存中的地址是否一致，如果一致说明两个字符串是同一个字符串，一定相同，直接返回true
       if (this == anObject) {
           return true;
       }
       // 当地址不一致时，比较类型是否一致或是其子类，不满足比较条件返回fasle
       if (anObject instanceof String) {
       // 转换类型一致
           String anotherString = (String)anObject;
           int n = value.length;
           // 比较长度是否一致，如果一致比较内容，不一致返回false
           if (n == anotherString.value.length) {
               char v1[] = value;
               char v2[] = anotherString.value;
               int i = 0;
               // 遍历比较字符串中的各个字符的位置是否都一致，如果有一个不一致则返回false
               while (n-- != 0) {
                   if (v1[i] != v2[i])
                       return false;
                   i++;
               }
               return true;
           }
       }
       return false;
   }

总结重写equals方法的步骤一般为：

1、先比较对象在内存中的地址是否一致，如果一致则说明两个变量指向的是同一个地址，一定是相同的。
2、比较变量的类型是否一致或是其子类(直接子类和间接子类)，如果不是则返回fasle，
3、如果类型一致或是其子类，做一下强制类型转换，保持类型一致
4、比较引用数据类型中的属性的值是否都一致，如果都一致则返回true

测试用例

测试引用数据类型引用类

	/**
     * 引用数据类型的student测试类
     */
  public class student{
        private String name;
        private Integer age;
        private String sex;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }
        // 全参构造
		public Student(String name, Integer age, String sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
		// 重写equals
        @Override
        public boolean equals(Object obj) {
            // 比较地址是否是同一个地址
            if (this == obj){
                // 调用父类的方法
                return super.equals(obj);
            }
            // 比较对象的类型是否一致或是其子类
            if (obj instanceof Student){
                // 强制一致数据类型
                Student val = (Student) obj;
                // 比较引用对象中的属性值是否都一致
                if (val.name.equals(this.name)
                        && val.age.equals(this.age)
                        && val.sex.equals(this.sex)){
                   return true;
                }
            }
            return false;
        }
    }

主方法测试

public static void main(String[] args) {
        // System.out.println("==========测试==比较开始==========");
        // // 1、定义两个基本数据类型的变量
        // int a = 10;
        // int b = 10;
        // int c = 11;
        // System.out.println("第一个结果输出："+ (a == b)); // 返回true
        // System.out.println("第二个结果输出："+ (b == c)); // 返回false
        // // 2、比较引用变量
        // Student stu1 = new Student("测试",20,"男");
        // Student stu2 = new Student("测试",20,"男");
        // Student stu3 = stu1;
        // System.out.println("第三个结果输出："+ (stu1 == stu2));   // 返回false
        // System.out.println("第四个结果输出："+ (stu1 == stu3));   // 返回true
        // System.out.println("==========测试==比较结束==========");

        System.out.println("==========测试equals()比较开始==========");
        // 1、未重写equals方法比较引用数据类型
        // Student stu1 = new Student("测试",20,"男");
        // Student stu2 = new Student("测试",20,"男");
        // Student stu3 = stu1;
        // System.out.println("第五个结果输出："+ stu1.equals(stu2));   // 返回false
        // System.out.println("第六个结果输出："+ stu1.equals(stu3));   // 返回true
        // 2、重写equals方法后比较引用数据类型
        Student stu1 = new Student("测试",20,"男");
        Student stu2 = new Student("测试",20,"男");
        Student stu3 = stu1;
        System.out.println("第七个结果输出："+ stu1.equals(stu2));   // 返回true
        System.out.println("第八个结果输出："+ stu1.equals(stu3));   // 返回true
        System.out.println("==========测试equals()比较开始==========");
    }

总结

== 和 equals比较的区别：

1. == 是运算符，equasl是Object中的一个比较方法，在未重写equals方法前equals与 == 的本质是一样的
2. 一般情况下重写后的equals方法是比较两个对象的属性是否全部一致
3. equals不能比较基本数据类型(不包括包装类，包装类属于引用数据类型)的变量，== 可以比较基本数据类型的变量。
4. 当 == 比较引用数据类型时比较的是两个变量的地址是否是同一个地址，equals(重写后的)比较变量时比较的是内容
5. == 如果比较返回true的话，equals一定为true。equals比较为true时， ==返回的不一定是true

内容来源于网络，本人学习Java后工作之余整理出来，欢迎各位大佬查漏补缺