从头学Java之"equals"和"=="的故事

妖狐艹你老母 2022-07-15 15:28 159阅读 0赞

简言:为什么说叫这个标题，因为本人甚是很惭愧，第一是已经很久没有更新博客了，总是各种理由和借口，有一天我看到hyman的一篇博客，那篇博客没有聊技术更多的是聊hyman大神个人写博客的经历，看后甚是感触很大；第二是虽然不更新了博客，但是偶尔还会有一些支持我的朋友路过赞下以前的文章，心里老实说有种莫名的感伤，时间都去哪了。第三为什么叫这个标题，因为发现自己的之前的java学的简直太次了，所以决定在写android的同时，重头开始学习java。这次Java学习之路不同于以前的蜻蜓点水，浪费时间，目的在于加深和巩固。好了，矫情了那么久进入正题，今天来聊下"equals"和“==”的关系。

“equals”与“==”之间的关系可以说大家都已经非常清楚了，但是对于一个重头学习java的我来说，请大神们不要喷。目的在于学习和巩固。这两者关系是android和java面试和笔试题目中经常考核的问题，也很简单。下面将从这几方面聊下他们之间的故事。

一、“equals”和“==”的关系。

大家都很清楚 “equals”比较是两个对象的内容是否相等，而“==”则表示比较的是两个对象的引用是否相等(也即是两个引用是否指向同一个对象)

注意：equals这个方法不适用基本数据类型，而==则适用基本数据类型（故下面讨论的话题，不包含基本数据类型的讨论，只针对引用数据类型）

好就这些了吗？貌似就这些了，没错我第一次学习的时候也就学到这了。一般的笔试题也就考这么简单。但是我觉得下面几个例子也许你会感兴趣的。

第一个非常简单的例子相信你看一眼就知道答案了。

package com.mikyou.test;
    
    public class TestDemo1 {
      public static void main(String[] args) {
    	Integer num1 = new Integer(100);//使用包装器类型(属于引用数据类型)，可以使用equals
    	Integer num2 = new Integer(100);
    	System.out.println(num1 == num2);
    	System.out.println(num1.equals(num2));
     }
    }

输出结果:

![Center][]

输出结果毋庸置疑，证明了我们之前说的equals比较的是两个对象的内容，而"=="则比较的是两个对象的引用是否相等。

好，记住这句话，那么请看第二个例子。

package com.mikyou.test;
    
    public class TestDemo2 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
          Num num1 = new Num();//创建一个自定义Num类的实例对象，属于引用类可以使用equals
          num1.n = 100;
          
          Num num2 = new Num();
          num2.n = 100;
          
          System.out.println(num1.equals(num2));
          
    	}
    }

输出结果:

![Center 1][]

大家可能看到这个结果多少会有些疑惑吧，没错呀，引用类型使用equals比较的是内容，我们分别给num1、num2对象中的n成员赋了相同的值，比较的是内容的话应该输出结果是true才对呀。为何会有这样的思维呢？这就是我们平时不好的习惯，平时就像是在喊口号似的，“equals比较的是内容，==比较的是引用”。貌似我们得出以上分析结论是背下来，而没有去真正的分析为什么会是这样的呢。因为这就是我的真实写照，第一次学Java就是背口号似的把这个给硬记下来了，也不知道为啥。

既然是重头学习，那就一起聊下为什么吧？

注意：实际上equals的默认行为才是真正的比较引用而不是比较内容。可是为何第一个例子对的呢？难道第一个例子输出结果有问题？

其实第一个例子没有问题，很正确，为什么会有这样的结果？大家仔细看下第一个例子用的是Integer类包装器类属于Java中的类库，而第二例子属于我们自己定义的类

问题就出现在这。因为equals的默认行为是比较引用，所以第二个例子当然结果当然就是false了，而第一个例子使用的Integer包装器类型为什么是true,因为在大部分的java的类库中都对equals这个方法进行了覆盖，为了比较方便重写了equals方法，使得所有java类库中的equals方法都是比较内容，从而修改了equals比较引用的默认行为。因为在Java类库用的比较多，所以一般就这样把equals说成比较内容相同。如果不信的话，我们来看下Integer包装器类的源码，源码中equals是否被重写了。

![Center 2][]

可以看到Integer包装器类中确实重写了equals将一个Object类型转化成Integer类型并取出值比较内容是否相等。

为了做比较我们一起来看下最原始的equals方法长得啥样。

![Center 3][]

很明显我们可以看到最原始的equals方法比较的是引用而不是内容，比较传入对象引用是否与当前的对象引用相等，而且很明显一个是equals应该是直接属于Object这个类的一个原始方法。所以到这里我想应该对于equals是比较内容还是引用有个更清楚认识吧。

说完上面的“equals”再来聊下“==”中一个有趣的问题。这个问题也是我在逛csdn的时候看到某大神写了的，因为看着与我这篇博客符合，所以放在一起，至于哪个大神不好意思忘了，写进来也就给我这个重头学Java的人一个学习。

不管太多，先来看段很简单很简单的代码:

package com.mikyou.test;
    
    public class TestDemo3 {
    	public static void main(String[] args) {
    		Integer num1 = 100;
    		Integer num2 = 100;
    		Integer num3 = 200;
    		Integer num4 = 200;
            System.out.println(num1 == num2);
            System.out.println(num3 == num4);
    	}
    }

输出的结果：

![Center 4][]

看到上面的例子你是不是又感到疑惑了，不瞒你说，我刚开始的时候看到也懵逼了，因为第一次Java学的很浅显。没有深入学习。

这个例子按照我们前面例子来说，Integer属于包装器类型，而且==比较的是引用，那么按道理应该输出的是false,false才对呀。如果我们这样分析的话，还是思维定式了，思维太死了。得出这个结论只因为我们对Integer这个包装器类不熟悉。

注意:实际上在Integer包装器类中还有一个IntegerCache内部类，这是Integer包装类中的一个缓存类，用于缓存-128到127大小的整数。首先说下为什么会有这个缓存的类的存在，因为我们在编程过程-128到127范围这些数使用的频繁度更高，为了提高效率和优化性能，所以设计一个缓存的类来帮助实现。

为了更好理解我们来看下Integer类中的IntegerCache源码

/**
         * Cache to support the object identity semantics of autoboxing for values between
         * -128 and 127 (inclusive) as required by JLS.
         *
         * The cache is initialized on first usage.  The size of the cache
         * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
         * During VM initialization, java.lang.Integer.IntegerCache.high property
         * may be set and saved in the private system properties in the
         * sun.misc.VM class.
         */
    
        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() {}
        }

从上面的源码我们缓存的范围是-128~127  
例子中的Integer num1 = 100;实际上就是Integer num1 = Integer.valueOf(100);

我们可以一起再来看下,Integer中的valueOf方法的具体实现。

/**
         * Returns an {@code Integer} instance representing the specified
         * {@code int} value.  If a new {@code Integer} instance is not
         * required, this method should generally be used in preference to
         * the constructor {@link #Integer(int)}, as this method is likely
         * to yield significantly better space and time performance by
         * caching frequently requested values.
         *
         * This method will always cache values in the range -128 to 127,
         * inclusive, and may cache other values outside of this range.
         *
         * @param  i an {@code int} value.
         * @return an {@code Integer} instance representing {@code i}.
         * @since  1.5
         */
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }

我们可以很明显的看到，首先会判断传入进去的数据是否在缓存中（-128-127）中，如果在的话就直接取缓存中cache数组中的数，这个cache数组中我们清楚看到它是事先就在静态代码块中预先初始化好了，也就是说cache数组中的包含-128~127范围的对象引用。例子中第一次100，因为在缓存中，就去找到cache数组中的100所对应的Integer对象引用，第二次100也还是将这个cache为100的引用赋值。所以两次的100引用所指的是同一个对象，所以输出为true.而超过缓存范围的我们可以看到会重新new 一个Interger对象，所以第一次200不在范围内，所以会new一个新的对象，第二次也会new一个新的对象，很明显不是同一个对象所以输出false。

说到这是不是觉得很神奇。那么既然很神奇的话，不妨做个更加神奇的事。

通过源码我们可以看到缓存的实现主要是通过IntegerCache类中的cache数组，而这个数组的大小就是保存从-128到127的总共为256长度的元素对象。我们可以通过Java中的反射机制，来修改这个缓存数组，从而使得通过Integer创建的对象的数且在该缓存范围的数大小由我们而定。来看这段代码。

package com.mikyou.test;
    
    import java.lang.reflect.Field;
    
    public class TestDemo4 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    			Class cache = Integer.class.getDeclaredClasses()[0]; //得到Integer类中的内部类的Class类型
    			  Field myCache = cache.getDeclaredField("cache"); //我们从源码可看到cache这个数组是static所以直接通过反射出的类即可得到这个缓存数组
    			  myCache.setAccessible(true);//设置个数组是可访问的
    			  Integer[] newCache = (Integer[]) myCache.get(cache);
    			  newCache[127] = newCache[129]; 
    			  //我们知道cache是-128~127的数组对应0~256数组下标，下标为127的为-1，下标为129的为1;此操作也就是将缓存的中的1覆盖-1
    		} catch (SecurityException | NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
    			e.printStackTrace();
    		}
    		  Integer a = -1; 
    	      Integer b = a * 3; 
    	      System.out.println(b);//-1 * 3 = -3，可最后b=3,因为通过反射将缓存中的数据-1修改为1，然后1 * 3 =3 
    	}
    
    }

输出结果:

![Center 5][]

说到这，今天的有关equals和==内容就说到这了，欢迎大家留言，一起分享有关equals和==的故事。好了已经很晚了，该睡了，想想明天的还得早起上班，不过很开心，已经很久都没有这种熬夜写博客的感觉了。

[Center]: /images/20220715/9cd2aaa8a0484757b44d59481d4e7466.png
[Center 1]: /images/20220715/1a796169d8ca4359880e7458762608db.png
[Center 2]: /images/20220715/71e08d4b9dbb40b4bcd56b304dfe2666.png
[Center 3]: /images/20220715/63efe44e3e684f2c920e4ac5a68d167e.png
[Center 4]: /images/20220715/64aebda9080644f19a45c7b2d229aa5d.png
[Center 5]: /images/20220715/1fe2b40425764e978c4d79a8964bee1b.png