Java中如何實現對象拷貝

這篇文章給大家介紹Java中如何實現對象拷貝，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

引用的拷貝

1 //引用拷貝
2     private static void copyReferenceObject(){
3         Person p = new Person(23, "zhang");
4         Person p1 = p;
5         System.out.println(p);
6         System.out.println(p1);
7     }

這里打印的結果： 
Person@3654919e 
Person@3654919e 
可以看到，打印的結果是一樣的，也就是說，二者的引用是同一個對象，并沒有創建出一個新的對象。因此要區分引用拷貝和對象拷貝的區別，下面要介紹的就是對象拷貝。 

淺拷貝

• 如果pojo中存在的是基本數據類型 ，String 除外 ，實現Cloneable 覆寫Clone 方法 這個就是淺拷貝

- code 

1 package core.java.deeporshoawcopy;
 2 
 3 /**
 4  * @author DGW-PC
 5  * @date 2018年6月7日
 6  * @see 驗證   淺拷貝  一般要求實體類使用包裝類型 對于深拷貝 類中存在對其他類的引用，也需要實現cloneable接口
 7  */
 8 
 9 class Person implements Cloneable{
10     private String name;
11     private Integer age;
12     public String getName() {
13         return name;
14     }
15     public void setName(String name) {
16         this.name = name;
17     }
18     public Integer getAge() {
19         return age;
20     }
21     public void setAge(Integer age) {
22         this.age = age;
23     }
24     @Override
25     protected Object clone() throws CloneNotSupportedException  {
26         /*Person p=null;
27         try{
28             p=(Person) super.clone();
29         }catch (CloneNotSupportedException e) {
30         }*/
31         return super.clone();
32     }
33 }
34 
35 public class Base {
36     
37      public static void main(String[] args) throws CloneNotSupportedException {
38         Person person = new Person();
39         person.setName("a");
40         person.setAge(12);
41         Person per1=(Person) person.clone();
42         per1.setName("b");
43         per1.setAge(14);;
44         System.out.println(person.getName()+">  深拷貝- 如果你的POJO 存在的不是基本上數據類型，可以是自己定義類型，也可以其他包提供的類型 這里以java 提供的Data 的為例子 可以看下面的代碼 自身實現clone 方法 你在涉及到使用拷貝的時候一定要注意別的包提供的類是否出現了問題1  /**
 2      * Return a copy of this object.
 3      */
 4     public Object clone() {
 5         Date d = null;
 6         try {
 7             d = (Date)super.clone();
 8             if (cdate != null) {
 9                 d.cdate = (BaseCalendar.Date) cdate.clone();
10             }
11         } catch (CloneNotSupportedException e) {} // Won't happen
12         return d;
13     } - 下面介紹一下基本深拷貝的代碼 很短 ： 你一定主要 主類包裝了多少其他的引用類型的其他類，那么其他必須都要實現Cloneable 接口 以及clone 方法1 package core.java.deeporshoawcopy;
 2 
 3 
 4 /**
 5  * @author DGW-PC
 6  * @date 2018年6月7日
 7  * @see 實現序列化  深拷貝
 8  */
 9 
10 class Dog implements Cloneable{
11     private String name;
12 
13     public String getName() {
14         return name;
15     }
16 
17     public void setName(String name) {
18         this.name = name;
19     }
20     @Override
21     protected Object clone() throws CloneNotSupportedException {
22         return super.clone();
23     }
24 }
25 class User implements Cloneable{
26     private String name;
27     private Dog dog;
28     public String getName() {
29         return name;
30     }
31     public void setName(String name) {
32         this.name = name;
33     }
34     public Dog getDog() {
35         return dog;
36     }
37     public void setDog(Dog dog) {
38         this.dog = dog;
39     }
40     @Override
41     protected Object clone() throws CloneNotSupportedException {
42         User u=(User) super.clone();
43         u.dog=(Dog) dog.clone(); //多個需要在全部把關系搞清楚
44         return u;
45     }
46 }
47 
48 public class ObjCloner {
49         public static void main(String[] args) throws CloneNotSupportedException {
50             Dog dog = new Dog();
51             dog.setName("田園犬");
52             User user = new User();
53             user.setDog(dog);
54             user.setName("王二");
55             User user1=(User) user.clone();
56             user1.setName("張三");
57             Dog dog2 = new Dog();
58             dog2.setName("德國牧羊犬");
59             user1.setDog(dog2);
60             System.out.println(user.getName()+"養了"+ user.getDog().getName());
61             System.out.println(user1.getName()+"養了"+ user1.getDog().getName());
62         }
63 }  結果：   串行化方式實現深拷貝 - 以下代碼著重注意一下 CloneObj方法 ，就行。 1 package core.java.deeporshoawcopy;
  2 
  3 import java.io.ByteArrayInputStream;
  4 import java.io.ByteArrayOutputStream;
  5 import java.io.ObjectInputStream;
  6 import java.io.ObjectOutputStream;
  7 import java.io.Serializable;
  8 
  9 /**
 10  * @author DGW-PC
 11  * @date 2018年6月7日
 12  * @since 串行化 實現 深拷貝
 13  */
 14 
 15 class Body implements Serializable{
 16     /**
 17      * 
 18      */
 19     private static final long serialVersionUID = 1L;
 20     private String name;
 21     private Fonter fonter;
 22     private Head head;
 23     public String getName() {
 24         return name;
 25     }
 26     public void setName(String name) {
 27         this.name = name;
 28     }
 29     public Fonter getFonter() {
 30         return fonter;
 31     }
 32     public void setFonter(Fonter fonter) {
 33         this.fonter = fonter;
 34     }
 35     public Head getHead() {
 36         return head;
 37     }
 38     public void setHead(Head head) {
 39         this.head = head;
 40     }
 41     @Override
 42     public String toString() {
 43         return "Body [name=">轉自 https://www.cnblogs.com/dgwblog/p/9152358.html

關于Java中如何實現對象拷貝就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。