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

转载：https://blog.csdn.net/weixin_43461520/article/details/106174909