Java面试知识点（三十五）深拷贝和浅拷贝

客官°小女子只卖身不卖艺 2021-09-29 04:48 245阅读 0赞

Java 中的对象拷贝 (Object Copy) 指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象 A 和对象 B 都属于类 S，具有属性 a 和 b。那么对对象 A 进行拷贝操作赋值给对象 B 就是：B.a=A.a; B.b=A.b;

在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。

Java 中的对象拷贝主要分为：浅拷贝 (Shallow Copy)、深拷贝 (Deep Copy)。

Student stu1 = new Student();
    Student stu2 = stu1;

以上的代码，改变stu1或者stu2中任意一个对象的属性，另一个对象的属性也会随之改变。

原因出在 (stu2 = stu1) 这一句。该语句的作用是将 stu1 的引用赋值给 stu2，  
这样，stu1 和 stu2 指向内存堆中同一个对象。

那么如何复制一个对象呢，答案就是Object类的clone方法

### 一、浅拷贝 ###

一般步骤是（浅复制）：

1.  被复制的类需要实现 Clonenable 接口（不实现的话在调用 clone 方法会抛出 CloneNotSupportedException 异常) 该接口为标记接口 (不含任何方法)
2.  覆盖 clone () 方法，访问修饰符设为 public。方法中调用 super.clone () 方法得到需要的复制对象，（native 为本地方法)

Student类

class Student implements Cloneable{ 
    	private int number;
     
    	public int getNumber() { 
    		return number;
    	}
     
    	public void setNumber(int number) { 
    		this.number = number;
    	}
    	
    	@Override
    	public Object clone() { 
    		Student stu = null;
    		try{ 
    			stu = (Student)super.clone();
    		}catch(CloneNotSupportedException e) { 
    			e.printStackTrace();
    		}
    		return stu;
    	}
    }

Student类实现Cloneable接口，并重写clone方法（重写只是简单调用父类的clone方法即可），对于类中只有基本数据类型的对象，浅复制即可解决问题。

但是对于那些类成员变量是对象的类，浅复制的方式就不行了，因为浅复制只是复制了对象的成员变量的引用，对于基本数据类型是创建新的值，但是对于引用数据类型的对象，这只是复制了引用，两者指向的还是同一个对象。

### 二、深拷贝 ###

深拷贝的方式有多个

*  第一种  
    与通过重写 clone 方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现 Cloneable 接口并重写 clone 方法，最后在最顶层的类的重写的 clone 方法中调用所有的 clone 方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝 = 深拷贝。
 *  第二种  
    结合序列化来解决这个问题，先把对象序列化，然后再反序列化成对象，该对象保证每个引用都是崭新的。这个就形成了多个引用，原引用和反序列化之后的引用不在相同，具体实现：

【序列化代码实现】

public class Student implements Cloneable, Serializable { 
        private static final long serialVersionUID = 1L;
    
        private int age;
        private Address address;
    
        public void setAddress(Address address) { 
            this.address = address;
        }
    
        public Address getAddress() { 
            return address;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public int getAge() { 
            return age;
        }
    
        @Override
        protected Object clone() { 
            Student stu = null;
            try { 
                // 将对象写成byte array
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bos);
                oos.writeObject(this);
    
                // 从流中读出byte array
                ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bis);
                stu = (Student) ois.readObject();
            } catch (Exception e) { 
                e.printStackTrace();
            }
    
            return stu;
        }
    }

Student类需要实现Cloneable、Serializable两个接口，而且student中的成员变量对象都要实现serializable接口

public class Test { 
        public static void main(String[] args) { 
            Student stu1 = new Student();
            Address address = new Address();
            address.setAddress("beijing");
            stu1.setAge(20);
            stu1.setAddress(address);
            Student stu2 = (Student) stu1.clone();
    
            address.setAddress("jinan");
            stu2.setAge(10);
            //stu2.setAddress(address);
    
            System.out.println(stu1.getAge() + stu1.getAddress().getAddress());
            System.out.println(stu2.getAge() + stu2.getAddress().getAddress());
        }
    }

输出：  
20jinan  
10beijing

注意，通过address.setAddress(“jinan”);修改了address的值，但是引用没有变化  
所以stu1发生了变化，但是由于clone方法，stu2的address的引用已经发生变化了，所以stu2 的值没有发生变化，

若此时添加语句stu2.setAddress(address);  
则输出结果为：  
20jinan  
10jinan

因为把stu2的引用又修改为跟stu1一致了，此时深拷贝就没意义了。