java == 和equals()

==

== 是运算符    
1 :可以使用在基本数据类型变量和引用数据类型变量当中
2: 如果比较的是基本数据类型变量,比较两个变量保存的数据是否相等(不一定类型相同)  
   如果比较的是引用数据类型变量, 比较两个对象的地址值是否相等, 即两个引用是否指向同一个对象实体

       int i = 10;
        int y = 10;
        System.out.println(i==y);  // True

        TestEquals testOne = new TestEquals(17,"laowang");
        TestEquals testTwo = new TestEquals(18,"laowang");
        System.out.println(testOne==testTwo); //false  比较的是内存地址值都是两个对象了内存地址值肯定不同

equals()

equals()方法是Object类中所带有的  因为所有类都直接或间接的继承了Object类所以所有类有equals()
  一: 是一个方法而非运算符
  二: 只能适用于引用数据类型
  三:Object类中的定义
  public boolean equals(Object obj){
      return  (this==obj);
  }
  说明Object中equals()和==是相同的  判断
当比较的是引用数据类型时  == 和equals的作用是相同的
四: String  Date, File,包装类都重写了根父类的equals()方法,重写之后比较的不是引用地址是否相同,而是比较的    两个对象的"实体内容"是否相同  

五: 通常情况下,我们自定义的类如果使用equals()的话,也通常是比较两个对象的"实体内容"是否相等.那么我们如果想比较两个对象的值的时候就要在类中重写equals()方法了    

总结:

== 比的是地址值


equals() 比的是内容值


== 使用必须保证左右两边类型一致

Once类

public class Once {
    String name = "老王";
    int  age = 18;

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

    public  Once(){}
}

Tes类

public class Test {
    String name = "老王";
    int age = 17;
}

TestEquals类

public class TestEquals {


    public static void  main(String [] args){
        Once once = new Once();
        Test test = new Test();
        Once once1 = new Once("隔壁老王",   19);
        Once once2 = new Once("隔壁老李", 23);
        System.out.println(once.equals(test));  //false
        System.out.println(once.name.equals(test.name));  // true  String重写了  equals()方法
        System.out.println(once1.equals(once2)); // false 因为引用数据类型的是对比所有的属性
    }
    
}

重写equals

重写Test类中的equals方法

在Test类中重写 equals()



    @Override
    public boolean equals(Object object){
        
        if(this == object){
            return true;
        }
        
        
        if(object instanceof Test){
            Test test = (Test) object; //强制转为相同类
//            if(this.age == ((Test) object).age && this.name.equals(((Test) object).name)){  //因为基本数据类型必须用==
//                return true;
//            }else{
//                return false;
//            }
            //上面也可以用着一段
            //return (this.age == ((Test) object).age && this.name.equals(((Test) object).name));  
              return this.age == test.age && this.name.equals(test.name);
            
        }
        return false;
        
    }

练习:

1.编写Order类，有int型的orderId，String型的orderName，相应的 getter()和setter()方法，两个参数的构造器，重写父类的equals()方法: public boolean equals(Object obj)，并判断测试类中创建的两个对象是否 相等。
2.请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖 equals方法，使其判断当两个MyDate类型对象的年月日都相同时，结果 为true，否则为false。 public boolean equals(Object o)
 public class EqualsTest {
public static void main(String[] args) {
MyDate m1 = new MyDate(14, 3, 1976); MyDate m2 = new MyDate(14, 3, 1976); if (m1 == m2) {
System.out.println("m1==m2"); } else {
System.out.println("m1!=m2"); // m1 != m2 }
if (m1.equals(m2)) {
System.out.println("m1 is equal to m2");// m1 is equal to m2
} else {
System.out.println("m1 is not equal to m2");
} }
}

//1.编写Order类，有int型的orderId，String型的orderName，
// 相应的 getter()和setter()方法，两个参数的构造器，
// 重写父类的equals()方法: public boolean equals(Object obj)，并判断测试类中创建的两个对象是否 相等。


public class ORder {

    int orderId;
    String orderName;


    public  int getOrderId(){
        return orderId;
    }
    public void  setOrderId(int orderId){
        this.orderId = orderId;
    }


    public String getOrderName(){
        return getOrderName();
    }

    public  void  setOrderName(String orderName){
        this.orderName = orderName;
    }

    public   ORder(){

    }


    public  ORder(String orderName, int orderId){
        this.orderName = orderName;
        this.orderId = orderId;
    }


    @Override
    public boolean equals(Object object){
        if(object == this){
            return true;
        }
        if( object instanceof ORder ){
            ORder oRder = (ORder) object;
            if(this.orderId == ((ORder) object).orderId && this.orderName.equals(((ORder) object).orderName)){
                return true;
            }

        }

        return false;
    }
}








2:


//请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖 equals方法,
// 使其判断当两个MyDate类型对象的年月日都相同时，结果 为true，否则为false

public class EqualsTest {

    public static void main(String[] args) {
        MyDate m1 = new MyDate(14, 3, 1976);
//        MyDate m2 = new MyDate(14, 3, 1976);
        MyDate m3 = new MyDate(13,8,1986);
        if (m1 == m3) {
            System.out.println(111);
            System.out.println("m1==m2");
        } else {
            System.out.println(2222);
            System.out.println("m1!=m2"); // m1 != m2 }
            if (m1.equals(m3)) {
                System.out.println("m1 is equal to m2");// m1 is equal to m2
            } else {
                System.out.println("m1 is not equal to m2");
            }
        }
    }
}



public class MyDate {
    int age;
    int monty;
    int day;


    public MyDate(int age, int monty, int day) {
        this.age = age;
        this.monty = monty;
        this.day = day;
    }

    public int getAge() {
        return age;
    }

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

    public int getMonty() {
        return monty;
    }

    public void setMonty(int monty) {
        this.monty = monty;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }


    @Override
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj instanceof  MyDate){
            MyDate myDate = (MyDate) obj;
            if(this.age == myDate.age && this.day == myDate.day && this.monty == myDate.monty){
                return true;
            }else{
                return false;
            }

        }
        return false;
    }
}

面试题：==和equals的区别

1 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型 就是比较内存地址
2 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也 是==;我们可以看到String等类的equals方法是被重写过的，
　　　　　　　　而且String类在日常开发中 用的比较多，久而久之，形成了equals是比较值的错误观点。
3 具体要看自定义类里有没有重写Object的equals方法来判断。
4 通常情况下，重写equals方法，会比较类中的相应属性是否都相等

int it = 65; float fl = 65.0f; 
System.out.println(“65和65.0f是否相等？” + (it == fl)); //true


char ch1 = 'A'; char ch2 = 12; 
System.out.println("65和'A'是否相等？" + (it == ch1));//true System.out.println(“12和ch2是否相等？" + (12 == ch2));//true String 

str1 = new String("hello"); 
String str2 = new String("hello"); 
System.out.println("str1和str2是否相等？"+ (str1 == str2));//false


System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
System.out.println(“hello” == new java.util.Date()); //编译不通过