java 深复制与浅复制

末蓝、 2022-08-11 03:28 186阅读 0赞

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。

实现深复制的关键：以流的形式读写对象的二进制表示

测试代码如下：

Clone：

package com.study.clone;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Clone implements Cloneable, Serializable {
    	
    	private Child child;
    	
    	public Clone() {}
    	
    	public Clone(Child child) {
    		this.child = child;
    	}
    
    	/**
    	 * 实现对象浅复制
    	 * 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的
    	 * @param o
    	 * @return
    	 * @throws CloneNotSupportedException
    	 */
    	public Object lightClone() throws CloneNotSupportedException {
    		Object newObject = null;
    		newObject = super.clone();
    		return newObject;
    	}
    	
    	/**
    	 * 实现对象深复制
    	 * 深复制: 将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的
    	 * @param o
    	 * @return
    	 * @throws IOException 
    	 * @throws ClassNotFoundException 
    	 */
    	public Object deepClone() throws IOException, ClassNotFoundException {
    		Object newObject = null;
    		ByteArrayOutputStream bos = new ByteArrayOutputStream();
    		ObjectOutputStream oos = new ObjectOutputStream(bos);
    		// 将对象写到bos流中
    		oos.writeObject(this);
    		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    		ObjectInputStream ois = new ObjectInputStream(bis);
    		newObject = ois.readObject();
    		return newObject;
    	}
    	
    	public Child getChild() {
    		return child;
    	}
    	
    	public void setChild(Child child) {
    		this.child = child;
    	}
    	
    	public static void main(String[] args) {
    		Clone clone0 = new Clone(new Child("child0"));
    		Child child0 = clone0.getChild();
    		// 测试浅复制
    		try {
    			Clone clone1 = (Clone)clone0.lightClone();
    			Child child1 = clone1.getChild();
    			if(child0 == child1) {
    				System.out.println("浅复制");
    			}
    		} catch (CloneNotSupportedException e) {
    			e.printStackTrace();
    		}
    		
    		// 测试深复制
    		try {
    			Clone clone2 = (Clone) clone0.deepClone();
    			Child child2 = clone2.getChild();
    			if(child0 != child2) {
    				System.out.println("深复制");
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

Child：

package com.study.clone;
    
    import java.io.Serializable;
    
    public class Child implements Serializable {
    	
    	private String name;
    	
    	public Child() {}
    	
    	public Child(String name) {
    		this.name = name;
    	}
    	
    	public String getName() {
    		return this.name;
    	}
    
    }

结果输出为：

浅复制
    深复制