== 与equals的对比

== 与equals的对比：

• == 是运算符，它对基本类型判断是判断 == 左右两边的数值;对引用数据类型来说比较的是两个数据的引用地址

• equals()是一个方法不是运算符，

  只能用来比较引用数据类型 ==>>

  可以用来比较基本类型，因为没经过封装的equals()与 ==运算符用法相同

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

• 但是在object类中equals方法的定义与==的作用是相同的，比较引用类型指向地址是否相同

  • 当需要比较引用类型数据时，如string，Date，需要重写，把他改为比较对象的实体内容是否相同

    • 重写思路：

      1. 先判断两个字符的引用地址是否相同，相同返回true，不同继续进行②判断
      2. 再判断比较的字符是不是String类型的实例，若不是，返回false，若是继续进行③判断
      3. 若是string实例，则比较两个字符长度是否相同，若不相等，返回false，若是相同继续进行④
      4. 针对两个字符串的每一个字符进行比较，全部相同返回true，有不同就返回false

          public boolean equals(String str3,Object obj){
              if (str3 == obj){
                  return true;
              }
              if (obj instanceof String){
                  int n1 = str3.length();
                  int n2 = ((String) obj).length();
                  if (n1 == n2){
                      char c1[] = str3.toCharArray();
                      char c2[] = ((String) obj).toCharArray();
                      for (int i = 0; i < n1; i++) {
                          if (c1[i] != c2[i]){
                              return false;
                          }
                      }
                      return true;
                  }
                  return false;
              }
              return false;
          }
      

• 对于基本类型的封装类，它们的本质就是引用数据类型，所以不能用 == 判断，只能用重写的equals()方法

  • 装箱：基本数据类型 -> 包装类

    将基本数据类型封装成相应的对象

    Integer integer = new Integer(100);
    Integer integer = new Integer("100");//也可以包装基本数据类型
    //自动装箱
    Integer integer2 = Integer.valueOf("100");//也可以包装基本数据类型
    Integer integer2 = Integer.valueOf(100);
    

  • 拆箱：包装类 -> 基本数据类型

    拆箱是将封装的对象变成相应的数据类型

    //可以通过调用intvalue()方法进行拆箱
    Integer ite = 100;
    int in = ite.intValue();
    //jdk1.5后实现了自动封箱拆箱
    int in2 = ite;
    

    //intValue方法逻辑
    public int intValue() {
     return value;
    }
    

• 比较基本类型的封装类时也需要重新比较方法

  1. 先比较数据类型是否是封装类的实例，若不是则返回false，若是进行②
  2. 将封装类转化为基本数据类型进行比较，返回比较的值

  public boolean equals(Integer Integer1,Object obj){
          if (obj instanceof Integer){
              return Integer1.intValue() == ((Integer)obj).intValue();
          }
          return false;
      }
  

• 对装箱方式的类型比较

  • 比较手动装箱的类型时返回是false，因为比较的是引用地址类型
  • 但是自动封装类型下在[-128,127]内的会直接引用Java缓存的[-128,127]的数据，所以指向同一个地址

  Integer integer0 = new Integer(100);
          Integer integer1 = new Integer(100);
          System.out.print("integer0 == integer1:");
          System.out.println(integer0 == integer1); //false
          System.out.println("integer0："+ VM.current().addressOf(integer0));
          System.out.println("integer1："+ VM.current().addressOf(integer1));
  
          Integer integer11 = new Integer("100");
          System.out.print("integer0 == integer11:");
          System.out.println(integer0 == integer11);//false
          System.out.println("integer11："+ VM.current().addressOf(integer11));
  
          Integer integer2 = Integer.valueOf("100");
          Integer integer3 = Integer.valueOf(100);
          System.out.print("integer2 == integer3:");
          System.out.println(integer2 == integer3);//true
          System.out.println("integer2："+ VM.current().addressOf(integer2));
          System.out.println("integer3："+ VM.current().addressOf(integer3));
  
          Integer integer4 = Integer.valueOf("300");
          Integer integer5 = Integer.valueOf(300);
          System.out.print("integer4 == integer5:");
          System.out.println(integer4 == integer5);//false
          System.out.println("integer4："+ VM.current().addressOf(integer4));
          System.out.println("integer5："+ VM.current().addressOf(integer5));
  
  
          Integer integer6 = new Integer(300);
          Integer integer7 = new Integer(300);
          System.out.print("integer6 == integer7");
          System.out.println(integer6 == integer7);//false
          System.out.println("integer6："+ VM.current().addressOf(integer6));
          System.out.println("integer7："+ VM.current().addressOf(integer7));
  
          /**
           * integer0 == integer1:false
           * integer0：32169375256
           * integer1：32169375272
           * integer0 == integer11:false
           * integer11：32169376160
           * integer2 == integer3:true
           * integer2：29151878968
           * integer3：29151878968
           * integer4 == integer5:false
           * integer4：32169377544
           * integer5：32169377560
           * integer6 == integer7false
           * integer6：32169378392
           * integer7：32169378408
           */