Java : 关于值传递你需要了解的事情

最新推荐文章于 2023-07-20 23:44:22 发布

程序员小樊

最新推荐文章于 2023-07-20 23:44:22 发布

阅读量251

点赞数 2

文章标签： java 值传递引用传递

本文链接：https://blog.csdn.net/u011785648/article/details/80905320

版权

我们都知道，在Java中，方法的参数传递永远都是指值传递。让我们来看一看基本类型和集合的参数传递在内存中是如何体现的。

原文链接：https://dzone.com/articles/java-pass-by-reference-or-pass-by-value

在讨论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");

}