Java的==和equals()的区别-个人总结

文章目录

      • 一、写这个原因
      • 二、== 和 equals()意义
        • 2.1 == 运算符
        • 2.2 equals()方法
      • 三、== 运算符见解与例子
        • 3.1 个人见解
        • 3.2 例子
          • 3.2.1 基础数据类型
          • 3.2.2 引用类型
          • 3.2.3 基础类型和引用类型
        • 3.3 结果分析
      • 四、equals()方法总结与例子
        • 4.1 总结
        • 4.2 常见重写equals方法的java类
          • 4.2.1 String
          • 4.2.2 基本类型的各个包装类
            • 4.2.2.1 Integer
            • 4.2.2.2 Character
            • 4.2.2.3 Boolean
            • 4.2.2.4 Short
            • 4.2.2.5 Byte
            • 4.2.2.6 Long
            • 4.2.2.7 Float
            • 4.2.2.8 Double
      • 五、 基本类型包装类的初始缓存 (需要额外注意)

一、写这个原因

看了网上很多文章,写的很乱,干脆自己总结了下。

二、== 和 equals()意义

2.1 == 运算符

在《java核心技术卷 1》中将 == 归类于关系运算符;
== 常用于相同的基本数据类型之间的比较,也可用于相同类型的对象之间的比较;

  1. 如果 == 比较的是基本数据类型,那么比较的是两个基本数据类型的值是否相等;
  2. 如果 == 是比较的两个对象,那么比较的是两个对象的引用,也就是两个对象是否为同一个对象,并不是比较的对象的内容;
2.2 equals()方法

在《java核心技术卷 1》中对 Object 类的描述:Object 类是java中所有类的始祖,在java中每个类都是由Object类扩展而来;每个类都默认继承Object类,所以每一个类都有Object类中的方法;从而每一个类都有equals方法;

  1. equals方法主要用于两个对象之间,检测一个对象是否等于另一个对象;

  2. equals方法在Object的代码如下,在代码上可以看出Object的实现类里面equals方法其实也是 == 的关系运算符。

所以问题的关键就是将 == 运算符说明白就好了。

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

三、== 运算符见解与例子

3.1 个人见解

== 运算符是比较栈上数据是否相等,比如基础类型的数据和对象的引用地址都是栈上的数据。

3.2 例子
3.2.1 基础数据类型

代码例子

public void basicDataTest(){
        int intValue1 = 188;
        int intValue2 = 188;
        float floatValue1 = 188;
        char charValue1 = 188;
        System.out.println(intValue1 == intValue2);
        System.out.println(intValue1 == floatValue1);
        System.out.println(intValue1 == charValue1);
    }

结果

true
true
true
3.2.2 引用类型

代码例子

public void yinYongDataTest(){
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = obj1;

        System.out.println(obj1 == obj2);
        System.out.println(obj1 == obj3);
    }

结果

false
true
3.2.3 基础类型和引用类型

代码例子

public class MyTestMain {

    public static void main(String[] args) {
        Integer integer1 = new Integer(1024);
        int intValue1 = 1024;

        boolean b = integer1 == intValue1;
        System.out.println(b);
    }
}

结果

true

代码反编译

public class top.san.es.MyTestMain {
  public top.san.es.MyTestMain();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Integer
       3: dup
       4: sipush        1024
       7: invokespecial #3                  // Method java/lang/Integer."":(I)V
      10: astore_1
      11: sipush        1024
      14: istore_2
      15: aload_1
      16: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
      19: iload_2
      20: if_icmpne     27
      23: iconst_1
      24: goto          28
      27: iconst_0
      28: istore_3
      29: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      32: iload_3
      33: invokevirtual #6                  // Method java/io/PrintStream.println:(Z)V
      36: return
}

3.3 结果分析

通过过3.2.1和3.2.2的例子是支持基础类型的数据和对象的引用地址都是栈上的数据 这个结论的。但是3.2.3这个例子需要反编译分析,通过反编译可以看到第16行指令就是做一个拆箱操作,其实就是基本类型(int)和对象类型(Integer)做比较时会有一个对象类型拆箱的一个过程,然后两者都已基本类型进行比较了。

四、equals()方法总结与例子

4.1 总结

上述展示了equals方法在Object中实现,内部就是一个 == 运算符,又因为只有引用类型才有 equals 方法,所以在对于所有未重写equals方法的类的对象调用equals方法,都是比较其所在的堆内存地址(栈上存的值)是否一致。
但是Java中很多类都重写了equals方法,所以对于重写了equals方法的类,其对象调用equals方法时都需要根据其内部实现而定。

4.2 常见重写equals方法的java类
4.2.1 String
  1. 重写实现代码
  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;
    }

  1. 例子

代码

public void stringDataTest() {
        String str1 = new String("hello");
        String str2 = new String("hello");
        String str3 = str1;
        String str4 = "hello";

        System.out.println(str1.equals(str2));
        System.out.println(str1.equals(str3));
        System.out.println(str1.equals(str4));

        System.out.println(str1 == str2);
        System.out.println(str1 == str4);
    }

结果

true
true
true
false
false
  1. 分析
    String 的 equals方法的源码很简单,就是先比较栈上指向的内存地址是否一致,然后再去比价其内部对应的字符串值。例子的前三个输出都是支持这一结论的。第四和五个输出说明了使用==运算符去做比较,只是比较了其栈上的内存地址。
4.2.2 基本类型的各个包装类
4.2.2.1 Integer
  1. 源码
 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
  1. 例子
    代码
 public void integerDataTest() {
        Integer integer1 = new Integer(1024);
        Integer integer2 = new Integer(1024);
        Integer integer3 = integer1;
        Integer integer4 = 1024;

        System.out.println(integer1.equals(integer2));
        System.out.println(integer1.equals(integer3));
        System.out.println(integer1.equals(integer4));
    }

结果

true
true
true
  1. 分析
    Integer的equals方法重写实现就是做了其成员属性的value(int)的 == 运算符,也就是基本类型的值的比较,例子输出都是支持结论的。
4.2.2.2 Character
  1. 源码
 public boolean equals(Object obj) {
        if (obj instanceof Character) {
            return value == ((Character)obj).charValue();
        }
        return false;
    }
4.2.2.3 Boolean
  1. 源码
  public boolean equals(Object obj) {
        if (obj instanceof Boolean) {
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }
4.2.2.4 Short
  1. 源码
  public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }
4.2.2.5 Byte
  1. 源码
  public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }
4.2.2.6 Long
  1. 源码
  public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }
4.2.2.7 Float
  1. 源码
   public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }
4.2.2.8 Double
  1. 源码
      public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

五、 基本类型包装类的初始缓存 (需要额外注意)

所有的包装类型都有一个初始缓存,这里Integer为例子。

  1. 代码
public void integerDataTest() {
        Integer integer1 = new Integer(10);
        Integer integer2 = new Integer(10);

        Integer integer3 = 10;
        Integer integer4 = 10;

        Integer integer5 = 128;
        Integer integer6 = 128;


        System.out.println(integer1 == integer2);
        System.out.println(integer1.equals(integer2));
        System.out.println(integer3 == integer4);
        System.out.println(integer5 == integer6);
    }
  1. 结果
false
true
true
false
  1. 分析
  • 第一个结果为false,是因为integer1和integer2是两个不同的对象,都是运行时自己调用Integer的构造方法实例化出来,两个对象 == 比较的是对象所在的堆地址,肯定是不等的。
  • 第二个结果为true,是因为两个Integer调用来equals方法来比较时,参考4.2.2.1的源码例子,可以知道这个操作会来比较其值是否相等,明显是相等的。
  • 第三个结果为true,是因为Integer3和Integer4是通过Integer的自动包装方法获取到的对象的,参考下面的源码,可以知道valueOf方法会先判断是否获取能获取到初始缓存的Integer对象,这个初始缓存的Integer对象,参考IntegerCache类可以知道是会初始-128~127数值范围的Integer对象。
    所以integer3和Integer4都是在 -128~127之间,所有其获得的对象都是初始的缓存对象,又因为它们的值是一样的,所有它们得到的对象是同一个。故这时其使用 == 比较,其对象堆地址是一样的,所以相等。
  • 第四个结果为false,是因为integer5和integer6也是通过valueOf方法进行自动包装的,但是注意128已经不在 -128~127的范围了,所以integer5和integer6都是被new出来的不同的对象,所以使用 == 比较对象堆地址是不一样的。

Integer自动包装类生成对象源码

 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

Integer内部一个静态内部类IntegerCache。

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

你可能感兴趣的:(java学习,java,开发语言,后端)