首页 > 编程语言 >注意！JAVA中的值传递

注意！JAVA中的值传递

时间：2023-07-31 21:59:27浏览次数：49  
标签：node JAVA val System 传递 注意 println TreeNode out

前言：今天在解决一个问题时，程序总是不能输出正确值，分析逻辑思路没问题后，发现原来是由于函数传递导致了这个情况。

LeetCode 113

问题：给你二叉树的根节点root和一个整数目标和targetSum，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

示例

 

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

我的代码如下

 1 class Solution {
 2     public void traversal(TreeNode root, int count, List<List<Integer>> res, List<Integer> path) {
 3         path.add(root.val);
 4         if (root.left == null && root.right == null) {
 5             if (count - root.val == 0) {
 6                 res.add(path);
 7             }
 8             return;
 9         }
10 ​
11         if (root.left != null) {
12             traversal(root.left, count - root.val, res, path);
13             path.remove(path.size() - 1);
14         }
15         if (root.right != null) {
16             traversal(root.right, count - root.val, res, path);
17             path.remove(path.size() - 1);
18         }
19     }
20 ​
21     public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
22         List<List<Integer>> res = new ArrayList<>();
23         List<Integer> path = new ArrayList<>();
24         if (root == null) return res;
25         traversal(root, targetSum, res, path);
26 ​
27         return res;
28     }
29 }

该题的思路是采用递归，traversal函数内root是当前树的根节点，count是目标值，res是存储结果，path是路径。该代码对于示例的输入输出为

1 输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
2 输出：[[5],[5]]

经过排查最终问题在于代码中的add方法

原代码部分内容为

1 if (root.left == null && root.right == null) {
2     if (count - root.val == 0) {
3         res.add(path);
4     }
5     return;
6 }

该部分内容需要改为

1 if (root.left == null && root.right == null) {
2     if (count - root.val == 0) {
3         res.add(new ArrayList(path));
4     }
5     return;
6 }

此时所有代码对于示例的输入输出为

1 输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
2 输出：[[5,4,11,2],[5,8,4,5]]

在java中，存在8大基本数据类型，且均有对应的包装类

数据类型占用位数默认值包装类
byte(字节型) 8 0 Byte
short(短整型) 16 0 Short
int(整型) 32 0 Integer
long(长整型) 64 0.0l Long
float(浮点型) 32 0.0f Float
double(双精度浮点型) 64 0.0d Double
char(字符型) 16 "/u0000" Character
boolean(布尔型) 1 false Boolean

在java中，函数传递只有值传递，是指在调用函数时，将实际参数复制一份传递给函数，这样在函数中修改参数(形参)时，不会影响到实际参数。

基本数据类型的值传递

测试类

 1 public class TestClass {
 2     public static void test(int value) {
 3         value = 2;
 4         System.out.println("形参value的值：" + value);
 5     }
 6 ​
 7     public static void main(String[] args) {
 8         int value = 1;
 9         System.out.println("调用函数前value的值：" + value);
10         test(value);
11         System.out.println("调用函数后value的值：" + value);
12     }
13 }

结果为

1 调用函数前value的值：1
2 形参value的值：2
3 调用函数后value的值：1

结论：可以看到，int类型的value初始为1，调用函数后，value仍然为1，基本数据类型在函数中修改参数(形参)时不会影响到实参的值。

引用数据类型的值传递

类TreeNode

 1 public class TreeNode {
 2     int val;
 3     TreeNode left;
 4     TreeNode right;
 5 ​
 6     TreeNode() {
 7     }
 8 ​
 9     TreeNode(int val) {
10         this.val = val;
11     }
12 ​
13     TreeNode(int val, TreeNode left, TreeNode right) {
14         this.val = val;
15         this.left = left;
16         this.right = right;
17     }
18 }

测试类1

 1 public class TestClass {
 2     public static void test(TreeNode node) {
 3         node.val = 2;
 4         System.out.println("形参node的val值：" + node.val);
 5     }
 6 ​
 7     public static void main(String[] args) {
 8         TreeNode node = new TreeNode(1);
 9         System.out.println("调用函数前node的val值：" + node.val);
10         test(node);
11         System.out.println("调用函数后node的val值：" + node.val);
12     }
13 }

结果为

1 调用函数前node的val值：1
2 形参node的val值：2
3 调用函数后node的val值：2

结论：可以看到，TreeNode类型的node对象的val值初始为1，调用函数后，node对象的val值被修改为2，引用数据类型在函数中修改参数(形参)时影响到了实参的值。

现在看另一个示例

测试类2

 1 public class TestClass {
 2     public static void test(TreeNode node) {
 3         node = new TreeNode(2);
 4         System.out.println("形参node的val值：" + node.val);
 5     }
 6 ​
 7     public static void main(String[] args) {
 8         TreeNode node = new TreeNode(1);
 9         System.out.println("调用函数前node的val值：" + node.val);
10         test(node);
11         System.out.println("调用函数后node的val值：" + node.val);
12     }
13 }

结果为

1 调用函数前node的val值：1
2 形参node的val值：2
3 调用函数后node的val值：1

结论：可以看到，TreeNode类型的node对象的val值初始为1，调用函数后，node对象的val值仍然为1，引用数据类型在函数中修改参数(形参)时未影响到实参的值。

那么，为什么会出现这种问题呢？

首先，在JAVA中，函数传递都是采用值传递，实际参数都会被复制一份给到函数的形式参数，所以形式参数的变化不会影响到实际参数，基本数据类型的值传递示例可以发现这个性质。但引用数据类型的值传递为什么会出现修改形式参数的值有时会影响到实际参数，而有时又不会影响到实际参数呢？其实引用数据类型传递的内容也会被复制一份给到函数的形式参数，这个内容类似C++中的地址，示例中的node对象存储于堆中，虽然形参与实参是两份内容，但内容值相同，都指向堆中相同的对象，故测试类1在函数内修改对象值时，函数外查看时会发现对象值已被修改。测试类2在函数内重新构造了一个对象node，在堆中申请了一个新对象(新对象与原对象val值不相同)，让形参指向这个对象，所以不会影响到原对象node的值。测试类1与测试类2的区别在于引用数据类型的指向对象发生了变化。

以下代码可验证上述分析

测试类1

 1 public class TestClass {
 2     public static void test(TreeNode node) {
 3         System.out.println("test:node" + node);
 4         node.val = 2;
 5         System.out.println("test:node" + node);
 6         System.out.println("形参node的val值：" + node.val);
 7     }
 8 ​
 9     public static void main(String[] args) {
10         TreeNode node = new TreeNode(1);
11         System.out.println("调用函数前node的val值：" + node.val);
12         System.out.println("main node:" + node);
13         test(node);
14         System.out.println("调用函数后node的val值：" + node.val);
15         System.out.println("main node:" + node);
16     }
17 }

结果为

1 调用函数前node的val值：1
2 main node:TreeNode@1540e19d
3 test:nodeTreeNode@1540e19d
4 test:nodeTreeNode@1540e19d
5 形参node的val值：2
6 调用函数后node的val值：2
7 main node:TreeNode@1540e19d

测试类2

 1 public class TestClass {
 2     public static void test(TreeNode node) {
 3         System.out.println("test:node" + node);
 4         node = new TreeNode(2);
 5         System.out.println("test:node" + node);
 6         System.out.println("形参node的val值：" + node.val);
 7     }
 8 ​
 9     public static void main(String[] args) {
10         TreeNode node = new TreeNode(1);
11         System.out.println("调用函数前node的val值：" + node.val);
12         System.out.println("main node:" + node);
13         test(node);
14         System.out.println("调用函数后node的val值：" + node.val);
15         System.out.println("main node:" + node);
16     }
17 }

结果为

1 调用函数前node的val值：1
2 main node:TreeNode@1540e19d
3 test:nodeTreeNode@1540e19d
4 test:nodeTreeNode@677327b6
5 形参node的val值：2
6 调用函数后node的val值：1
7 main node:TreeNode@1540e19d

对于测试类1，形参和实参都是指向相同的对象，所以利用形参修改对象的值，实参指向的对象的值发生改变。对于测试类2，形参在函数开始和实参指向相同的对象，让其指向新的对象后，实参指向的对象的值不会发生改变。简要说，测试类1形参复制了实参的地址，修改了地址对应的对象值，但并未修改地址值，测试类2形参复制了实参的地址，并修改了地址值，但并未修改原地址值对应的对象值。

有了目前的结论，可以理解为什么res.add()函数内path修改为new ArrayList(path)就可代码运行成功。因为我的path类型为List<Integer>，为引用数据类型，且path的值一直在发生变化。随着递归代码的运行，path的值发生变化，res内最初的List<Integer>值会发生变化(就是path的值)。但将path修改为new ArrayList(path)后，是在堆中新构造了对象，并指向该对象，原对象的变化不会影响到该对象的值，那么res内List<Integer>值就不会发生变化。

listList.add()方法直接传入list1

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 ​
 4 public class TestClass {
 5     public static void main(String[] args) {
 6         List<List<Integer>> listList = new ArrayList<>();
 7         List<Integer> list1 = new ArrayList<>();
 8         list1.add(1);
 9         listList.add(list1);  //直接add list1
10         List<Integer> list2 = new ArrayList<>();
11         list2.add(2);
12         listList.add(list2);
13         System.out.println("list1改变前");
14         for (List<Integer> l : listList) {
15             for (Integer i : l) {
16                 System.out.println(i);
17             }
18             System.out.println("---");
19         }
20         list1.set(0, 2);    //将list1的0号元素改为2
21         System.out.println("list1改变后");
22         for (List<Integer> l : listList) {
23             for (Integer i : l) {
24                 System.out.println(i);
25             }
26             System.out.println("---");
27         }
28     }
29 }

结果为

 1 list1改变前
 2 1
 3 ---
 4 2
 5 ---
 6 list1改变后
 7 2
 8 ---
 9 2
10 ---

listList.add()方法重新构造新对象（内容与list1相同）

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 ​
 4 public class TestClass {
 5     public static void main(String[] args) {
 6         List<List<Integer>> listList = new ArrayList<>();
 7         List<Integer> list1 = new ArrayList<>();
 8         list1.add(1);
 9         listList.add(new ArrayList<>(list1)); //构造新对象 再调用add
10         List<Integer> list2 = new ArrayList<>();
11         list2.add(2);
12         listList.add(list2);
13         System.out.println("list1改变前");
14         for (List<Integer> l : listList) {
15             for (Integer i : l) {
16                 System.out.println(i);
17             }
18             System.out.println("---");
19         }
20         list1.set(0, 2);    //将list1的0号元素改为2
21         System.out.println("list1改变后");
22         for (List<Integer> l : listList) {
23             for (Integer i : l) {
24                 System.out.println(i);
25             }
26             System.out.println("---");
27         }
28     }
29 }

结果为

 1 list1改变前
 2 1
 3 ---
 4 2
 5 ---
 6 list1改变后
 7 1
 8 ---
 9 2
10 ---

 

结论：调用构造函数后，函数指向新的对象，原对象的值发生改变，函数内值也不会改变。同理，新对象的值发生改变，原对象的值也不会发生改变。

标签：node,JAVA,val,System,传递,注意,println,TreeNode,out
From： https://www.cnblogs.com/huskysir/p/17594578.html

相关文章

  • Java面试题 P22：Redis篇：Redis做为缓存，Redis的数据淘汰策略是什么？
          ......
  • Java面试题 P20：Redis篇：Redis做为缓存，数据的持久化是怎么做的？
    Redis做为缓存，数据的持久化是怎么做的？在Redis中提供了两种数据持久化的方式：1、RDB  2、AOF       ......
  • 使用OpenFeign传递二进制流
    在现代的分布式系统中，服务之间的通信变得越来越普遍。OpenFeign是一个流行的JavaHTTP客户端工具，它简化了在微服务架构中进行服务间通信的过程，本文将简单介绍如何使用OpenFeign传递二进制流。什么是OpenFeign？OpenFeign是一个用于声明式、模板化的HTTP客户端的Java库。它简化了编......
  • Java面试题 P19：Redis篇：Redis做为缓存，mysql的数据如何与redis进行同步呢（双写一致）
    双写一致性：当修改了数据库的数据也要同时更新缓存的数据，缓存和数据库的数据要保持一致。     共享锁：读锁代码 排他锁，写数据。读锁和写锁的值要一致。   MQ异步消息通知：    ......
  • JavaScript基础01
    javaScript作用1.嵌入动态文本于HTML页面。2.对浏览器事件做出响应。3.读写HTML元素。4.在数据被提交到服务器之前验证数据。5.检测访客的浏览器信息。控制cookies，包括创建和修改等。6.基于Node.js技术进行服务器端编程。js主要的内容ECMAScript语法变量......
  • Java面试题 P18：Redis篇：Redis使用场景-缓存-缓存雪崩
          缓存雪崩：是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量的请求到达数据库，带来巨大压力。                            ......
  • 深入理解Java虚拟机（JVM）：原理、结构与性能优化
    1.介绍Java虚拟机（JVM）是Java程序的核心执行引擎，负责将Java源代码编译成可执行的字节码，并在运行时负责解释执行字节码或将其编译成本地机器代码。本文将深入探讨JVM的原理、结构以及性能优化的相关技术。2.JVM原理与结构2.1JVM运行时数据区域JVM运行时数据区域由以下几部分组......
  • access VBA 当变量会被当成参数进行传递时,最好不要在声明过程偷懒
    Dima,b,cAsString不用讲,大家都这么玩过.实际上,它只将c声明为String类型，而a和b实际上是未声明的Variant类型。然后，当你尝试将未声明类型的变量a作为参数传递给ByRef参数的函数时，会导致类型不匹配的错误。SubMySub(ByRefxAsString)’函数代码EndSubMy......
  • Java基础2
    面向对象基础面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。对象实体与对象引用new运算符，new创建对象实例（对象实例在内存中），对象引用指向对象实例（对象引用存放在栈内存中）。关于相等......
  • Java修饰符与继承
    一、class（类）可以继承类（仅限一个）继承普通类：不一定要重写父类的所有方法继承抽象类：必须重写父类的所有抽象方法，除非将自己定义为抽象类只可继承父类【public、protected】的字段、方法（privated不可继承）包含父类的构造方法子类将从父类继承过来的方法的地址信息保存到自己的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99