好好学习，天天向上
本文已收录至我的Github仓库DayDayUP：github.com/RobodLee/DayDayUP，欢迎Star，更多文章请前往：目录导航
前言
今天我在刷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;
}
……
