Java基础之聊聊运算符“==”和equals方法

目录

一、“==”和equals方法的初步认识

二、String类的具体说明

三、Integer类的具体说明

---

一、“==”和equals方法的初步认识

在面试的过程中，说一说“==”和equals的区别算是一个比较经典也是一个很基础的问题了。但是可能每个人回答的角度都是对，但是往往都不全面，那怎么回他才是更全面的呢？分以下几点来看下。

首先，“==”和equals方法共同点是都是用来判断两个变量是否相同，为什么强调是变量呢，变量分为基本数据类型和引用数据类，从而引申出来不同的地方。

不同点，当使用运算符“==”比较基础数据类型时，只要基本数据类型表示的数值一致，那么“==”就是返回为结果为真也就是true。当比较两个变量是引用数据类型时，"=="是指两个对象的引用必须指向同一个对象返回结果才是true。

拿个栗子看看：

int a = 1;
int b = 1;
System.out.println(a == b);//true
Test01 test01 = new Test01();
Test01 test02 = test01;
System.out.println(test01 == test02);//true

equals方法针对的只是引用对象类型，因为引用对象都会默认继承Object类，而equals方法是Object的一个基础方法。在Object类中的equals是通过运算符“==”来实现的。所以说在没引用对象没有重写equals方法的前提下，equals和“==”可以是等价的。

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

从基本角度总结：

 “==”和equals方法都是用来判断两个变量是否相同，“==”可以用来比较基础数据类型两个数值是否相等，也可以用来比较两个引用数据类型是否指向同一个对象，而在引用对象没重写equals的前提下，equals方法是用来比较两个引用数据类型是否指向同一个对象。当引用对象没有重写equals方法时，equals方法比较结果等价于运算符“==”的运算结果。

二、String类的具体说明

但是上面的回答只能算是基本正确，面试官又怎么让你轻松过关，拿出来String的一个例子继续挖坑：

    String str2 = new String("abc");
    String st1 = "abc";
    System.out.println(st1 == str2);//false
    System.out.println(st1.equals(str2));//true

 这个例子就推翻了上面的结论，探其究竟发现String类中重写了equals方法（源码如下），首先通过“运算符”比较两个比较对象是否指向同一对象，如果是返回true；如果不是继续判断指定的对象是否属于String类，依然为真继续判断两个字符长的字符长度是否同等，字符长度相同在逐个比较每个字符是否相同，最终返回结果。总体看来String类重写equals方法的目的是为了比较两个字符串的值是否相同，所以在st1.equals(str2)返回为true,这也符合开发过程对于字符串的使用习惯。

 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;
    }

 但是对于st1 == str2的比较结果还没有分析，清楚再来看下面的例子。

     String st1 = "abc";
     String str2 = new String("abc");
     String str3 = "a"+"b"+"c";
     String s = "a";
     String str4 = s+"bc";
     System.out.println(st1 == str2);//false
     System.out.println(st1 == str3);//true
     System.out.println(st1 == str4);//fasle

由于在日常开发过程中，对于字符串的大量使用，为了避免字符串对象的大量销毁重建，在JVM的内存模型中开辟出一块内存专门存储字符串常量称之为字符串常量池，相对于其他引用对象来说，字符串的有特殊的声明方式String str = "abc"中产生的对象就被分配到常量池中，而且每个字符串只保留一份，所以str1 == str3的返回结果为真。而对于new String()的形式，是在堆中为对象str2开辟了一块内存，所以str1和str2指向的而不是一块内存地址，所以str1 == str2返回false。

而对于str1== str4为什么返回也是false?需要查看字节码来一探究竟。从字节码中可以看到，为例避免生成大量的String对象，在字符串拼接时，会先声明一个StringBuilder对象，通过StringBuilder类的appen方法将bc追加到a的后面，通过toString方法返回。所以str1==str4返回结果为false。

 总结：当引用对象为String类型时，因为重写了equals方法，equals方法实际上比较两个字符串的值是否同等。从而引申出，在不重写equals方法时，equals方法可以比较两个引用对象是否相同，但是当重写equals方法后需要根据重写的规则来判断比较的意图，当字符串发生拼接时，通过JVM编译器的优化先生成一个StringBuilder对象进行字符串的追加，从而避免产生大量字符串。

三、Integer类的具体说明

说完字符串，还有个一个很鲜明的例子int和其包装类Integer。看下面的例子：

   int x1 = 5;
   Integer x2 = 5;
   Integer x3 = new Integer(5);;
   Integer x4 = Integer.valueOf(5);

   Integer x5 = 325;
   Integer x6 = Integer.valueOf(325);

   System.out.println(x1 == x2);//true
   System.out.println(x2 == x3);//false
   System.out.println(x3== x4);//false
   System.out.println(x2== x4);//true
   System.out.println(x5== x6);//false
   System.out.println(x5.equals(x6));//true

这个例子中首先声明了基本数据类型变量x1,然后通过Integer的直接赋值（自动装箱，实际调用valueo方法），new一个实例以及静态方法的形式声明了5个Integer对象。先看x1 == x2返回为真，这就涉及了包装类型自动装箱和自动拆的原理，但和包装类型进行比较时，包装类型会自动拆箱为基本数据类型，所以 x1 == x2返回为true；再看x2和x3是两个不同的引用对象进行比较，返回false，x3和x4同理；再看x2和x4的返回结果是true，但是x5和x6和其结果类似但是返回却是false,这又是为什么？

来看下valueof方法的源码，在调用valueof方法时，首先会判断该数值是否大于-128和小于127，如果是则直接从静态内部类IntegerCache中取出来，如果不是则新new一个对象。这就是x2 == x4为true，x5 == x6返回false的原因。在加载Integer类时，会同时装载IntegerCache类，将-128-127缓存起来，当需要数据在此区间时直接获取，否则重新声明对象。

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

   //静态内部类
   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() {}
    }

最后在看一下 x5.equals(x6)返回的true，通过查看源码，Integer重新了equals方法，最终实现目的时，比较两个值的数值。

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

 总结一下：Integer重写了equals方法来比较两个比较对象的数值的大小，而通过三种声明方式中，除了通过new关键字实例化对象之外，直接赋值和静态方法valueof会先判断是否在缓存的范围中，如果在缓存范围中则直接获取，如果不是再通过new关键字实例化对象。因此比较Integer两个对象的数值是否相等应该尽量用equals方法。

四、equals方法和hashcode方法

这里首先记住最重要的一条。一个类中重写equals方法，必须重写hashcode方法。对象的存储内存中，是以散列表的形式存在，而每个对象都存在一个对应的散列码，hashcod方法就是计算散列码的方法。相等的对象必须具有相等的散列码。而equals不同的两个数据，则不要求hashcode一定不相同。