原文链接：https://dzone.com/articles/java-pass-by-reference-or-pass-by-value
我们都知道，在Java中，方法的参数传递永远都是指值传递。让我们来看一看基本类型和集合的参数传递在内存中是如何体现的。
在讨论Java中参数是如何传递之前，我们有必要先弄清楚Java的变量（主要指的是基本类型和对象）是怎么存储在内存中的。
基本类型一般都存储在堆栈中；对于Java对象，实际的对象数据存储在堆中，而对象的指针（指向推中的对象）存储在堆栈中。
1.传值 vs 传引用
“传值”和“传引用”分别是什么意思：
- 传值：当方法参数是值传递时，意味着原参数的一个拷贝被传到了参数内部而不是原始参数，所以任何对于该参数的改变都只会影响这个拷贝值。
- 传引用：当方法参数是引用传递时，意味着原始参数的引用或者说指针被传递到了方法内部，而不是这个原始参数的内容。
2.在Java中参数是怎么传递的
在Java中，不管原始参数的类型是什么，参数都是按值传递的。每次当一个方法被执行的时候，在堆栈中就会为每个参数创建一个拷贝，这个拷贝会被传递到方法内部。
- 如果原始参数是基本类型，那么在堆栈中创建的便是这个参数的简单拷贝
- 如果原始参数不是基本类型，那么在堆栈中创建的便是指向真正对象数据的新的引用或指针。这个新的引用被传递到方法内部（在这种情况下，有2个引用指向了同一个对象数据）
3.解决疑惑
在接下来的示例中，我们通过往方法中传递不同类型的参数（基本类型，包装类，集合类，自定义类），在方法执行完成后去检查他们是否被修改了来尝试证明“在Java中参数传递永远是值传递”。
基本类型参数
public static void main(String[] args) {
int x = 1;
int y = 2;
System.out.print("Values of x & y before primitive modification: ");
System.out.println(" x = " + x + " ; y = " + y );
modifyPrimitiveTypes(x,y);
System.out.print("Values of x & y after primitive modification: ");
System.out.println(" x = " + x + " ; y = " + y );
}
private static void modifyPrimitiveTypes(int x, int y)
{
x = 5;
y = 10;
}
输出：
Values of x & y before primitive modification: x = 1 ; y = 2
Values of x & y after primitive modification: x = 1 ; y = 2
说明：
x,y这2个参数是基本类型，所以存储在堆栈中。当调用modifyPrimitiveTypes()方法时，在堆栈中创建了这2个参数的拷贝（我们就叫它们w,z）,实际上是w,z被传递到了方法中。所以原始的参数并没有被传递到方法中，在方法中的任何修改都只作用于参数的拷贝w,z
包装类
public static void main(String[] args) {
Integer obj1 = new Integer(1);
Integer obj2 = new Integer(2);
System.out.print("Values of obj1 & obj2 before wrapper modification: ");
System.out.println("obj1 = " + obj1.intValue() + " ; obj2 = " + obj2.intValue());
modifyWrappers(obj1, obj2);
System.out.print("Values of obj1 & obj2 after wrapper modification: ");
System.out.println("obj1 = " + obj1.intValue() + " ; obj2 = " + obj2.intValue());
}
private static void modifyWrappers(Integer x, Integer y)
{
x = new Integer(5);
y = new Integer(10);
}
输出：
Values of obj1 & obj2 before wrapper modification: obj1 = 1 ; obj2 = 2
Values of obj1 & obj2 after wrapper modification: obj1 = 1 ; obj2 = 2
说明：
包装类存储在堆中，在堆栈中有一个指向它的引用
当调用modifyWrappers()方法时，在堆栈中为每个引用创建了一个拷贝，这些拷贝被传递到了方法里。任何在方法里面的修改都只是改变了引用的拷贝，而不是原始的引用
P.S: 如果方法中的表达式为x += 2，x值得改变也不会影响到方法外部，因为包装类是immutable类型的。当他们的state变化时，他们就会创建一个新的实例。如果你想了解更多关于immutable类，可以阅读How to create an immutable class in Java。字符串类型和包装类相似，所以以上的规则对于字符串也有效。
集合类型
public static void main(String[] args) {
List<Integer> lstNums = new ArrayList<Integer>();
lstNums.add(1);
System.out.println("Size of list before List modification = " + lstNums.size());
modifyList(lstNums);
System.out.println("Size of list after List modification = " + lstNums.size());
}
private static void modifyList(List<Integer> lstParam)
{
lstParam.add(2);
}
输出：
Size of list before List modification = 1
Size of list after List modification = 2
说明：
当我们创建一个ArrayList或任意集合，在堆栈中便会创建一个指向堆中多个对象的引用。当modifyList()被调用时，一个引用的拷贝被创建中传递到了方法中。现在有2个引用指向了真正的对象数据，其中任何一个引用的数据改变会影响到另一个。
在方法中，当我们调用lstParam.add(2)时，一个Integer对象在堆中被创建，添加到了现有的list对象。所以原始的list引用可以看见这次修改，因为2个引用都指向了内存中的同一个对象
自定义对象
public static void main(String[] args) {
Student student = new Student();
System.out.println("Value of name before Student modification = " + student.getName());
modifyStudent(student);
System.out.println("Value of name after Student modification = " + student.getName());
}
private static void modifyStudent(Student student)
{
student.setName("Alex");
}
输出：
Value of name before Student modification = null
Value of name after Student modification = Alex
说明：
student对象在堆中被创建，在堆栈中存储着指向它的引用。当调用calling modifyStudent()，在堆栈中创建了这个引用的拷贝，传递到了方法中。所以任何对这个对象属性的修改会影响原始的对象引用
结论
在Java中，参数都是按值传递的。被传递到方法中的拷贝值，要不就是一个引用或一个变量，取决于原始参数的类型。从现在开始，下面的几条规则将帮助你理解方法中对于参数的修改怎么影响原始参数变量。
- 在方法中，修改一个基础类型的参数永远不会影响原始参数值。
- 在方法中，改变一个对象参数的引用永远不会影响到原始引用。然而，它会在堆中创建了一个全新的对象。（译者注：指的是包装类和immutable对象）
- 在方法中，修改一个对象的属性会影响原始对象参数。
- 在方法中，修改集合和Maps会影响原始集合参数。
转载自我的博客：刘文哲的博客
