记一个回文链表中的小坑——Java对象与对象的比较

首先看下题目

题目是LeetCode的一道题：
面试题02.06 回文链表
编写一个函数，检查输入的链表是否是回文的。

示例 1：
输入： 1->2
输出： false
示例 2：
输入： 1->2->2->1
输出： true

题目本身还是很容易的，我最快想到的一种实现方式是，先遍历一遍，把所有元素取出来放到ArrayList里面；再遍历一遍，双指针一头一尾向中间靠拢，迭代判断头尾值是否相等。
于是，按这个思路，我写出来的代码长这样：

public boolean isPalindrome(ListNode head) {
        if(head == null){
            return true;
        }
        ArrayList<Integer> list = new ArrayList<>();
        while(head != null){
            list.add(head.val);
            head = head.next;
        }
        int i = 0, j = list.size() - 1;
        while(i < j){
            if(list.get(i++) != list.get(j--)){
                return false;
            }
        }
        return true;
    }

咋一看好像没啥问题，题目逻辑也简单，写完之后也通过了LeetCode给的例子，于是乎满怀信心地点了提交，以为可以AC。结果发现没通过，[-129,-129]这个用例没过去！

问题

也是奇怪，这个用例这么简单，而且按逻辑这个用例应该不是问题才对，由于我是直接在LeetCode上答题，没办法调试，所以打算在LeetCode上再试几个用例，看能不能找到问题。

当我尝试了[1,1],[-1,-1],[-128,-128]之后，发现这些用例都可以通过！偏偏[-129,-129]没法通过？

-129这个数字很奇怪，刚好小于Byte的最小值，也就是说，可能只有Byte范围内[-128,127]的值才能比较？测试了[127,127]和[128,128]之后发现确实如此！用例[127,127]执行结果为true，[128,128]执行结果为false！至于为啥会有这个现象，我们后面再说。

继续定位问题，按理说，给的用例都是两个相同的数，没理由部分通过部分不通过，这种情况一般是由于Java语言有一些小坑可能没注意到，使用语言写的代码不规范，不经意就踩进去了。于是重新检视了下代码，找到了问题：

        while(i < j){
            if(list.get(i++) != list.get(j--)){
                return false;
            }
        }

问题就出在上面第2行：

if(list.get(i++) != list.get(j--)){

这里面，list是一个ArrayList，里面放的是Integer的对象！

因此通过list.get()获取的返回值是Integer对象，在比较的时候，也是在用对象进行比较。而对象的比较会比较地址，在[-128,127]范围之外的Integer对象，是不同对象，尽管值一样，然而地址不一样，当然比较结果就是false了。

解决办法

此处可以与字符串做类比，比较两个字符串对象的值是否相同的时候，我们会使用对象的equals方法，而不是用两个等号（==）。因此，解决这个问题可以同样使用Integer对象的equals方法：

if(!list.get(i++).equals(list.get(j--)){

由于Integer的特殊性，也可以利用自动拆箱的特性进行比较：

int m = list.get(i++);
int n = list.get(j--);
if(m != n){

还可以使用Integer对象本身封装的方法intValue()来获取Integer对象的int值：

if(list.get(i++).intValue() != list.get(j--).intValue()){

按上面任一方式修改代码提交后，就AC了。

[-129,129]问题

题是解了，还有个坑没填。

上面提到了，经过尝试之后发现，[-128,-128]和[127,127]都没有问题，而[-129,-129]和[128,128]都有问题，执行后结果不对。

结合刚刚发现的代码问题，可以得出如下结论：

• 用-128到127之间的数创建的Integer对象，只要值相同，创建出来的就是同一个对象（地址相同），可以用==比较，结果为true。
• 用在此范围外的数创建的Integer对象，是不同对象，地址不同，用==比较只会得到false。

那么原因呢？

上源码：

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

这里提一下，在往ArrayList里添加数据的时候，由于ArrayList需要的是一个Integer的对象，而add的时候给的入参又是int型的数字，这时候Java的自动装箱特性会把int转换为Integer，调用的就是Integer类里的这个valueOf方法。

然后我们来看下源码，这里可以发现，当i在IntegerCache.high和IntegerCache.low之间的时候，返回的是IntegerCache的缓存数组（cache）中的对象，除此之外返回的是一个新的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.lang.Integer.IntegerCache.high的情况下，high是127，low是-128，cache数组会提前把-128到127的所有Integer对象缓存起来，这样在这个范围内自动装箱获取的对象会是同一个。

结语

题目虽简单，但还是会不小心踩坑。其实规范些写代码可以避免很多问题，比如要判断对象的内容是否相等的时候，使用对象的equals方法，而不是==。此处简单记录下这个小坑，避免重蹈覆辙。