深拷貝和淺拷貝

值型別 vs 引用型別

1 // 學生的所學專業
2 public class Major {     
3     private String majorName; 
4     //
 
 專業名稱
5     private long majorId;    // 專業代號
6     // ... 其他省略 ...
7 }

1 // 學生
2 public class Student {
3     private String name;       // 姓名
4     private int age;    // 年齡
5     private Major major;      // 所學專業
6     // ... 其他省略 ...
7 }

賦值 vs 淺拷貝 vs 深拷貝

物件賦值

1 Student codeSheep = new
 
 Student();
2 Student codePig = codeSheep;

淺拷貝

深拷貝

淺拷貝程式碼實現

 1 public class Student implements Cloneable {
 2     private String name;      // 姓名
 3     private int age;    // 年齡
 4     private Major major;      // 所學專業
 5     @Override
 6     public Object clone() throws CloneNotSupportedException    {
 7         return super.clone();
 8     }
 9     // ... 其他省略 ...
10 }

 1 public class Test {    public static void main(String[] args) throws CloneNotSupportedException
 2     {        Major m = new Major("電腦科學與技術",666666);
 3         Student student1 = new Student("CodeSheep",18, m );
 4         // 由 student1 拷貝得到 student2
 5         Student student2 = (Student) student1.clone();        System.out.println( student1 == student2 );
 6         System.out.println( student1 );
 7         System.out.println( student2 );
 8         System.out.println( "\n");
 9         // 修改student1的值型別欄位
10         student1.setAge( 35);
11         // 修改student1的引用型別欄位
12         m.setMajorName( "電子資訊工程");
13         m.setMajorId( 888888);
14         System.out.println( student1 );
15         System.out.println( student2 );
16     }
17 }

• student1==student2列印false，說明clone()方法的確克隆出了一個新物件；
• 修改值型別欄位並不影響克隆出來的新物件，符合預期；
• 而修改了student1內部的引用物件，克隆物件student2也受到了波及，說明內部還是關聯在一起的

深拷貝程式碼實現

1、深度遍歷式拷貝

1 public class Major implements Cloneable {    
2 
3      @Override protected Object clone() throws CloneNotSupportedException    
4     {       
5           return super.clone();   
6     }  
7     // ... 其他省略 ...
8 }

 1 public class Student implements Cloneable {   
 2     @Override    
 3     public Object clone() throws CloneNotSupportedException
 4     {
 5         Student student = (Student)         super.clone();
 6         student.major = (Major) major.clone();         // 重要！！！
 7         return student;
 8     }
 9     // ... 其他省略 ...
10 }

2、利用反序列化實現深拷貝

 1 public class Student implements Serializable {    
 2     private String name;         // 姓名
 3     private int age;            // 年齡
 4     private Major major;       // 所學專業    
 5     public Student clone() {       
 6        try {
 7              // 將物件本身序列化到位元組流
 8              ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 9              ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream );
10              objectOutputStream.writeObject( this);
11              // 再將位元組流通過反序列化方式得到物件副本
12              ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));               
                return  (Student) objectInputStream.readObject();          
13         } catch(IOException e) {              
14              e.printStackTrace();
15         } catch(ClassNotFoundException e) {
16              e.printStackTrace();
17         }       
18         return null;
19      }
20      // ... 其他省略 ...
21 }

1 public class Major implements Serializable {
2   // ... 其他省略 ... 
3 }