LeetCode刷题时引发的思考:Java中ArrayList存放的是值还是引用?

前言

今天我在刷LeetCode的时候遇到了一个问题,就是ArrayList添加不进去数据,其实不是没有添加进去,而是添加进去的数据被改变了,为什么会改变了呢?其实涉及到ArrayList存放的是值还是引用的问题,网上有很多回答是:如果是基本数据类型则存放的是值,如果是对象存放的就是引用。那么到底是什么呢,让我们来一探究竟吧!

正文

原题在此:

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

我一开始写的代码是这样的:

class Solution {

    private List<List<Integer>> result = new ArrayList();
    private ArrayList<Integer> solution = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtracking(candidates,target,0);
        return result;
    }

    public  void backtracking(int[] candidates, int residual, int start) {
        if (residual < 0) {
            return;
        }

        if (residual == 0) {
            result.add(solution);
            return;
        }
        for(int i = start;i<candidates.length;i++) {
            solution.add(candidates[i]);
            backtracking(candidates,residual-candidates[i],i);
            solution.remove(solution.size()-1);
        }
    }

}

看了一遍,没什么问题,非常自信的点了运行,结果懵逼了,List里面什么也没有

遇Bug没关系,首先来分析一下:既然输出是两个 [],那么List中肯定添加过两次数据,也就是进入了if语句中,那么可能的原因就是代码写的有问题导致 solution中没有数据,那就打印一下看看呗。

修改代码:


    ……
        if (residual == 0) {
            System.out.println(solution.toString());    //打印solution
            result.add(solution);
            return;
        }
    ……

看一下控制台,solution正常打印了,而且结果是正确的

既然solution有正确的数据,那么问题就应该出现在List的添加上,那就再打印一下看看。

修改代码:


    ……
        if (residual == 0) {
            result.add(solution);
            System.out.println("----------");
            for (List<Integer> integers : result) {
                System.out.println(integers.toString());    //打印List中的内容
            }
            System.out.println("==========");
            return;
        }
    ……

从打印的内容上看,第一次添加的是 [2,2,3],没有问题。但是第二次的打印结果就很奇怪,是两个 [7],也就是我第一次添加的内容被修改了。那么可能的原因只有一个,List中添加进去的是一个引用,而并非实际的值,不然结果怎么会改变呢。但是List中存放的真的是引用吗?我们来进一步的验证。

首先我们将ArrayList中的泛型指定为基本数据类型的包装类和我们自定义的一个User类:

public class ArrayListTest {

    static class User {
        private String name;
        private int age;

        public User(String name , int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    public static void main(String[] args) {
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        int testInt = 10;
        integerArrayList.add(testInt);
        testInt = 20;
        integerArrayList.add(testInt);
        System.out.println(integerArrayList.toString());

        ArrayList<Double> doubleArrayList = new ArrayList<>();
        double testDouble = 100.0;
        doubleArrayList.add(testDouble);
        testDouble = 200.0;
        doubleArrayList.add(testDouble);
        System.out.println(doubleArrayList.toString());

        ArrayList<User> userArrayList = new ArrayList<>();
        User testUser = new User("张三",20);
        userArrayList.add(testUser);
        testUser.age = 22;
        userArrayList.add(testUser);
        for (User user : userArrayList) {
            System.out.println(user.toString());
        }
    }

这里我们试了Integer和Double两种,看一下结果:

由此可见,修改int和double不会对之前的内容造成影响,但是修改User会对之前的内容造成影响。所以,ArrayList中如果是基本数据类型,那么存放的就是值,如果是对象,那么存放的就是对象的引用而不是对象的拷贝。看样子这个结论是正确的,但是需要注意的一个问题就是ArrayList可以存放基本数据类型吗?如果将泛型指定为基本数据类型就会报错:

所以说,ArrayList不存在存放的是基本数据类型的问题,只能存放基本数据类型的包装类,也就是说存放基本数据类型的时候会自动装箱成一个对象,然后把引用存放进去。那好,就算基本数据类型存不了,存的是包装类,那么我修改了里面的内容之后,Integer和Double两次却存放了不同的值,而User修改后存放了两个相同的内容。因为如果泛型是Integer或Double的话,两次存放的是不同的对象的引用而不是一个,如果是一个的话,那当然会导致之前的内容改变咯。《Java编程思想》里面说过:无论何时,对同一个对象调用hashCode()都应该生成同样的值。所以我们来打印一下他们的hash值就可以判断是不是同一个对象。我们使用System.identityHashCode()来获取hash值:

    ……
    public static void main(String[] args) {
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        int testInt = 10;
        integerArrayList.add(testInt);
        testInt = 20;
        integerArrayList.add(testInt);
        for (Integer integer : integerArrayList) {
            System.out.println(integer + " : "+ System.identityHashCode(integer));
        }
        System.out.println();

        ArrayList<Double> doubleArrayList = new ArrayList<>();
        double testDouble = 100.0;
        doubleArrayList.add(testDouble);
        testDouble = 200.0;
        doubleArrayList.add(testDouble);
        for (Double aDouble : doubleArrayList) {
            System.out.println(aDouble + " : "+ System.identityHashCode(aDouble));
        }

        ArrayList<User> userArrayList = new ArrayList<>();
        User testUser = new User("张三",20);
        System.out.println("\nUser修改前:");
        System.out.println(testUser.toString());
        System.out.println(System.identityHashCode(testUser));
        userArrayList.add(testUser);
        testUser.age = 22;
        System.out.println("User修改后:");
        System.out.println(testUser.toString());
        System.out.println(System.identityHashCode(testUser));
        userArrayList.add(testUser);
        System.out.println("\n遍历ArrayList<User>:");
        for (User user : userArrayList) {
            System.out.println(user.toString());
            System.out.println(System.identityHashCode(user));
        }

    }
    ……

打印的结果如下:

从打印的结果可以看出,Integer和Double并不是修改内容,而是存了一个新的对象的引用进去,所以存放基本数据类型的包装类也是引用并非是值,而User对象修改后却可以影响到之前已经存储的内容,两个User是同一个。

为什么Integer和Double修改不了呢?因为他们都属于不可变量,都是final修饰的,也就是说第二次赋值的时候指向的是一个新的对象,而不是修改之前的内容。从源码中我们可以看到:

可以看到,基本数据类型的包装类和String一样都是final修饰的,而且Double和Integer等基本数据类型包装类中也没有提供修改值的方法,也就是说之前看样子是在修改数据,其实是指向了一个新的内存地址,ArrayList中第二次存放数据的时候,并没有改变第一次存放的引用中的内存地址中的值,而是存了一个新的引用。

结论

那么到现在为止,就可以得出一个结论了: ArrayList中存放的是引用而不是值

网上有的人说“存基本数据类型存的是值,存对象存的是引用”这个结论是错误的。回到最开始的问题,我这题应该怎么写?其实只要克隆一份就好了:


    ……
        if (residual == 0) {
            result.add((List<Integer>) solution.clone());
            return;
        }
    ……