再论 “Java 是值传递还是地址传递?”

青旅半醒 2022-04-24 22:04 176阅读 0赞

### 文章目录 ###

*   *   *   *   *  前言
                 *  先说说上次测试的标准、结论及纠错
                 *  为什么从新讨论这个问题?
                 *  刨根问底:值传递的本质和地址传递的本质
                 *  思考两个问题,认识 Java 的引用传递
                 *   *  =null 后 Java Heap 中的对象消失了吗?
                     *  以 Map 区分Java 是引用传递而非地址传递
                     *  对象在方法内部实例化后会受影响吗?
                     *  for 循环中的实例化
                 *  最佳实践
                 *   *  不要通过形参方式试图实例化一个方法外变量
                 *  参考文档

##### 前言 #####

> 体能状态先于精神状态,习惯先于决心,聚焦先于喜好.

##### 先说说上次测试的标准、结论及纠错 #####

> 关于 Java 是值传递还是地址传递的问题在很早之前就遇到过,当时自己还做了一个实验,  
> 当时的标准是,将一个局部变量传递到一个void 类型的方法种进行赋值,之后在方法外打印参数,如果参数值未修改,说明该类型是值传递,否则就是地址传递  
> 当然经过本次探究,我上一次的标准是错误的,因为我把Java的引用传递和地址传递混为一谈了,修正后的结论[(详情)][Link 1]  
> Java 8种基本类型(boolean、char、byte、short、int、long、float、double)以及对应的包装类型是值传递、String是值传递、Date类型是值传递  
> 剩下的POJO 、List、Map、Set ,还有数组是引用传递,而本质上依旧是值传递

##### 为什么从新讨论这个问题? #####

> 最近看《重构》,在小标题 \*\*移除对参数的赋值(Remove Assignments to Parameters)\*\*中,Martin Fowler (作者,这样感觉我们很熟一样有没有)强调`Java 使用按值传递的函数调用方式,着常常造成许多人迷惑,在所有地点,Java 都严格采用值传递方式`,这使我不禁窃喜,终于看到权威的论断了,可惜的是书中提供的例子是 Date 类型,然后这个并无法推翻我之前的逻辑,所以一定是哪里出了问题.

##### 刨根问底:值传递的本质和地址传递的本质 #####

> 值传递的本质是被调用者的拷贝传递给调用者,一般是实参传递给形参,形参修改不影响实参数,除非实参从新被形参赋值  
> 地址传递的本质是将被调用者将自身的地址传递给调用者,并且允许调用者修改自身的内容  
> 乍一看,Java 的POJO对象就是地址传递是吧?哈哈哈,且看下面的例子

##### 思考两个问题,认识 Java 的引用传递 #####

> 上面一条说到,地址传递允许被调用者修改自己在内存中的内容,接着思考下面两个问题

###### =null 后 Java Heap 中的对象消失了吗? ######

> 下面的第三步,list=null 会立即将 Java Heap 中 list 指向的对象空间清空吗?如果你了解 JVM 垃圾回收机制,这一步并不会导致空间被立即收回,尽管会促使 JVM 进行垃圾回收,因为list 只是指向了内存的一个地址,而不能说就是内存的内容.

List<String> list =new List<String>();
    list.add("1");
    list=null;

###### 以 Map 区分Java 是引用传递而非地址传递 ######

> 下面的例子中,输出结果是 jecket,如果Java Map 地址传递,那么最终输出结果应该是”hello world“,但是最终的结果表明,testMap 只是表示内存中的引用,事实上main中的map也只是内存地址的引用,及Java 是引用传递

public static void main(String[] args) { 
    		Map<String,String> map=new HashMap<String,String>();
    		testMap(map);
    		System.out.println(map.get("name"));//输出 jacket
    	}
    	
    	public static void testMap(Map<String,String> map) { 
    		map.put("name", "jacket");
    		map=new HashMap<String,String>();
    		map.put("name", "hello world");
    	}

###### 对象在方法内部实例化后会受影响吗? ######

> 答案是:不会  
> 在方法内部重新实力化是无法影响方法外的对象的,  
> 这样只是将方法内部的局部变量指向了一个新地址,再次证明Java 不是地址传递,这里是引用传递

@Test
    	public void test5() { 
    		List<String> list=new ArrayList<String>();
    		List<String> list2=new ArrayList<String>();
    		list.add(0, "100");
    		list2.add(0, "100");
    		System.out.println("外围1:"+(list==null)+";list:"+list.get(0)+";list2:"+list2);
    		initList(list);
    		changeList(list2);
    		System.out.println("外围2:"+(list==null)+";list:"+list.get(0)+";list2:"+list2);
    	}
    	/** * 内部从新 实例化,无法修改外面的参数 * */
    	public void initList(List<String> l) { 
    		System.out.println("内部1:"+(l==null)+l.get(0));
    		l=new ArrayList<String>();
    		l.add(0,"200");
    		System.out.println("内部2:"+(l==null)+l.get(0));
    	}
    	/** * 内部仅仅新增一个 参数 * */
    	public void changeList(List<String> l) { 
    		System.out.println("内部3:"+(l==null)+l.get(0));
    		l.add(0,"200");
    		System.out.println("内部4:"+(l==null)+l.get(0));
    	}

外围1:false;list:100;list2:[100]
    内部1:false100
    内部2:false200
    内部3:false100
    内部4:false200
    外围2:false;list:100;list2:[200, 100]

###### for 循环中的实例化 ######

> 比如我们使用一个循环创建新对象,然后放入List中,下面的代码也是可以的,因为new会将声明的对象指向新分配的地址,而不是将其原地址改为另一个值,但是笔者并不建议这个做,从封装的角度来看,应该尽可能小的暴露

public static void main(String[] args) { 
    		Person p=null;
    		List<Person> list=new ArrayList<Person>();
    		
    		for(int i=0;i<2;i++) { 
    		//建议在内部声明 Person p=new Person();
    		//=并不会影响原内存地址内容,而是指向新的对象地址
    			p=new Person();
    			p.setAge(i);
    			list.add(p);
    		}
    		
    		System.out.println(list.get(0).getAge());//0
    		System.out.println(list.get(1).getAge());//1
    	}

##### 最佳实践 #####

> 尽管证明了Java 是值传递,但是Java 也存在本质是值传递的引用传递,请牢记  
> **Java 8种基本类型(boolean、char、byte、short、int、long、float、double)以及对应的包装类型是值传递、String是值传递、Date类型是值传递  
> 剩下的POJO 、List、Map、Set ,还有数组是引用传递**

###### 不要通过形参方式试图实例化一个方法外变量 ######

> 鉴于你无法通过形参真正的操作一个对象的真实地址  
> 所以,你不应该通过形参方法进行实例化工作(new一个对象),或者 =null  
> 如果你想提供一个类似的方法,要么直接操作全局变量,要么提供返回值  
> 思考一个工厂方法,产生一个对象,然后返回这个新建对象  
> 当然,如果只是修改对象的属性值,这个是可以影响方法外的对象的.总之,不要认为你可以通过形参修改方法外对象在内存中的地址

List<String> list;
    	
    /** * 通过形参无法对方法外参数进行实力化- * @param list */
    public void init(List list) { 
    	list=new ArrayList<String>();
    	list.add("100");
    }
    
    @Test
    public void test5() { 
    	System.out.println((list==null)?null:list.get(0));
    	init(list);
    	System.out.println((list==null)?null:list.get(0));
    }

##### 参考文档 #####

\[1\]、https://blog.csdn.net/qq\_43171869/article/details/83349282  
\[2\]、https://www.jianshu.com/p/b4d0c87273b6

[Link 1]: https://blog.csdn.net/bestcxx/article/details/74937365#%C2%B7Java%20%E4%B8%AD%E5%B8%B8%E8%A7%81%E7%9A%84%E5%87%A0%E4%B8%AA%E7%B1%BB%E5%9E%8B%E6%98%AF%E5%80%BC%E4%BC%A0%E9%80%92%E8%BF%98%E6%98%AF%E5%9C%B0%E5%9D%80%E4%BC%A0%E9%80%92%E7%9A%84%E5%88%A4%E6%96%AD