devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java基础学习之对象复制与对象序列化

作者：笔触狂放9 | 2024-02-08 10:47:57

赞

踩

java 拷贝一个对象使用clone还是json序列化

        在工作中,会经常涉及到对象的拷贝和序列化,看似平常普通的知识点,其实还是有很多需要我们去学习、研究、注意的,对日后学习很多技术都有很大的帮助,今天就整理一下有关对象拷贝和序列化的知识。

        对象的复制有三种方式:引用复制,clone复制,序列化复制

1. 引用复制

        新建一个实体类如下:

  1. public class Customer {
  2.  
  3.     private String userName;
  4.  
  5.     private String password;
  6.  
  7.     public String getUserName() {
  8.         return userName;
  9.     }
  10.  
  11.     public void setUserName(String userName) {
  12.         this.userName = userName;
  13.     }
  14.  
  15.     public String getPassword() {
  16.         return password;
  17.     }
  18.  
  19.     public void setPassword(String password) {
  20.         this.password = password;
  21.     }
  22.  
  23.     @Override
  24.     public boolean equals(Object o) {
  25.         if (this == o) return true;
  26.         if (o == null || getClass() != o.getClass()) return false;
  27.         Customer customer = (Customer) o;
  28.         return Objects.equals(userName, customer.userName) &&
  29.                 Objects.equals(password, customer.password);
  30.     }
  31.  
  32.     @Override
  33.     public int hashCode() {
  34.         return Objects.hash(userName, password);
  35.     }
  36.  
  37.     @Override
  38.     public String toString() {
  39.         return "Customer{" +
  40.                 "userName='" + userName + '\'' +
  41.                 ", password='" + password + '\'' +
  42.                 '}';
  43.     }
  44. }

测试引用复制

  1.     public static void main(String[] args) {
  2.  
  3.         Customer c1 = new Customer();
  4.         c1.setUserName("张三");
  5.         c1.setPassword("123456");
  6.         Customer c2 = c1;
  7.  
  8.         System.out.println(c1.equals(c2));
  9.         System.out.println(c1 == c2);
  10.         System.out.println("c1 = " + c1);
  11.         System.out.println("c2 = " + c2);
  12.  
  13.     }
  14.  
  15.  
  16.  
  17. D:\java\jdk1.8\bin\java.exe ...
  18. true
  19. true
  20. c1 = Customer{userName='张三', password='123456'}
  21. c2 = Customer{userName='张三', password='123456'}
  22.  
  23. Process finished with exit code 0

引用复制 由于是两个对象的引用是相同,共同指向堆中的同一个对象,所以其中一个对象修改属性,会影响另一个对象的属性

  1.     public static void main(String[] args) {
  2.  
  3.         Customer c1 = new Customer();
  4.         c1.setUserName("张三");
  5.         c1.setPassword("123456");
  6.         Customer c2 = c1;
  7.         c2.setPassword("654321");
  8.         System.out.println(c1.equals(c2));
  9.         System.out.println(c1 == c2);
  10.         System.out.println("c1 = " + c1);
  11.         System.out.println("c2 = " + c2);
  12.  
  13.     }
  14.  
  15.  
  16.  
  17. D:\java\jdk1.8\bin\java.exe ...
  18. true
  19. true
  20. c1 = Customer{userName='张三', password='654321'}
  21. c2 = Customer{userName='张三', password='654321'}
  22.  
  23. Process finished with exit code 0

所以使用引用复制对象时需要注意这一点.

2. clone拷贝复制

        clone拷贝复制分为浅拷贝和深拷贝

    2.1 浅拷贝

        新建实体类实现cloneable接口,重写clone方法

  1. public class Customer implements Cloneable {
  2.  
  3.     private String userName;
  4.  
  5.     private String password;
  6.  
  7.     public String getUserName() {
  8.         return userName;
  9.     }
  10.  
  11.     public void setUserName(String userName) {
  12.         this.userName = userName;
  13.     }
  14.  
  15.     public String getPassword() {
  16.         return password;
  17.     }
  18.  
  19.     public void setPassword(String password) {
  20.         this.password = password;
  21.     }
  22.  
  23.     @Override
  24.     protected Object clone() throws CloneNotSupportedException {
  25.         return super.clone();
  26.     }
  27.  
  28.     @Override
  29.     public boolean equals(Object o) {
  30.         if (this == o) return true;
  31.         if (o == null || getClass() != o.getClass()) return false;
  32.         Customer customer = (Customer) o;
  33.         return Objects.equals(userName, customer.userName) &&
  34.                 Objects.equals(password, customer.password);
  35.     }
  36.  
  37.     @Override
  38.     public int hashCode() {
  39.         return Objects.hash(userName, password);
  40.     }
  41.  
  42.     @Override
  43.     public String toString() {
  44.         return "Customer{" +
  45.                 "userName='" + userName + '\'' +
  46.                 ", password='" + password + '\'' +
  47.                 '}';
  48.     }
  49. }

测试浅拷贝

  1.     public static void main(String[] args) throws CloneNotSupportedException {
  2.  
  3.         Customer c1 = new Customer();
  4.         c1.setUserName("张三");
  5.         c1.setPassword("123456");
  6.         Customer c2 = (Customer)c1.clone();
  7.         System.out.println(c1.equals(c2));
  8.         System.out.println(c1 == c2);
  9.         System.out.println("c1 = " + c1);
  10.         System.out.println("c2 = " + c2);
  11.  
  12.     }
  13.  
  14.  
  15. D:\java\jdk1.8\bin\java.exe ...
  16. true
  17. false
  18. c1 = Customer{userName='张三', password='123456'}
  19. c2 = Customer{userName='张三', password='123456'}
  20.  
  21. Process finished with exit code 0

从面的代码可以看出浅拷贝是重新生成了一个对象,两个对象的引用并不相同,这一点和引用复制不同,我们再试一下浅拷贝是否存在和引用复制一样的问题

  1.     public static void main(String[] args) throws CloneNotSupportedException {
  2.  
  3.         Customer c1 = new Customer();
  4.         c1.setUserName("张三");
  5.         c1.setPassword("123456");
  6.         Customer c2 = (Customer)c1.clone();
  7.         c2.setPassword("654321");
  8.         System.out.println(c1.equals(c2));
  9.         System.out.println(c1 == c2);
  10.         System.out.println("c1 = " + c1);
  11.         System.out.println("c2 = " + c2);
  12.  
  13.     }
  14.  
  15.  
  16.  
  17. D:\java\jdk1.8\bin\java.exe ...
  18. false
  19. false
  20. c1 = Customer{userName='张三', password='123456'}
  21. c2 = Customer{userName='张三', password='654321'}
  22.  
  23. Process finished with exit code 0

这里我们可以看出浅拷贝不会出现和引用复制一样的问题,因为来个对象指向的引用并不相同.

但是浅拷贝也一样存在他自己的问题.

我们重新新建一个实体类,在实体类中加入引用其他类的成员变量

  1. public class Customer implements Cloneable {
  2.  
  3.     private String userName;
  4.  
  5.     private String password;
  6.     
  7.     private User user;
  8.  
  9.     public String getUserName() {
  10.         return userName;
  11.     }
  12.  
  13.     public void setUserName(String userName) {
  14.         this.userName = userName;
  15.     }
  16.  
  17.     public String getPassword() {
  18.         return password;
  19.     }
  20.  
  21.     public void setPassword(String password) {
  22.         this.password = password;
  23.     }
  24.  
  25.     @Override
  26.     protected Object clone() throws CloneNotSupportedException {
  27.         return super.clone();
  28.     }
  29.  
  30.     public User getUser() {
  31.         return user;
  32.     }
  33.  
  34.     public void setUser(User user) {
  35.         this.user = user;
  36.     }
  37.  
  38.     @Override
  39.     public boolean equals(Object o) {
  40.         if (this == o) return true;
  41.         if (o == null || getClass() != o.getClass()) return false;
  42.         Customer customer = (Customer) o;
  43.         return Objects.equals(userName, customer.userName) &&
  44.                 Objects.equals(password, customer.password) &&
  45.                 Objects.equals(user, customer.user);
  46.     }
  47.  
  48.     @Override
  49.     public int hashCode() {
  50.         return Objects.hash(userName, password, user);
  51.     }
  52.  
  53.     @Override
  54.     public String toString() {
  55.         return "Customer{" +
  56.                 "userName='" + userName + '\'' +
  57.                 ", password='" + password + '\'' +
  58.                 ", user=" + user +
  59.                 '}';
  60.     }
  61. }
  62.  
  63.  
  64.  
  65.  
  66. public class User {
  67.  
  68.     private int age;
  69.  
  70.     private int sex;
  71.  
  72.     public int getAge() {
  73.         return age;
  74.     }
  75.  
  76.     @Override
  77.     public boolean equals(Object o) {
  78.         if (this == o) return true;
  79.         if (o == null || getClass() != o.getClass()) return false;
  80.         User user = (User) o;
  81.         return age == user.age &&
  82.                 sex == user.sex;
  83.     }
  84.  
  85.     @Override
  86.     public int hashCode() {
  87.         return Objects.hash(age, sex);
  88.     }
  89.  
  90.     public void setAge(int age) {
  91.         this.age = age;
  92.     }
  93.  
  94.     public int getSex() {
  95.         return sex;
  96.     }
  97.  
  98.     public void setSex(int sex) {
  99.         this.sex = sex;
  100.     }
  101.  
  102.     @Override
  103.     public String toString() {
  104.         return "User{" +
  105.                 "age=" + age +
  106.                 ", sex=" + sex +
  107.                 '}';
  108.     }
  109. }

然后对实体类进行浅拷贝

  1.     public static void main(String[] args) throws CloneNotSupportedException {
  2.  
  3.         Customer c1 = new Customer();
  4.         c1.setUserName("张三");
  5.         c1.setPassword("123456");
  6.         User user = new User();
  7.         user.setAge(18);
  8.         user.setSex(0);
  9.         c1.setUser(user);
  10.         Customer c2 = (Customer)c1.clone();
  11.         System.out.println(c1.equals(c2));
  12.         System.out.println(c1 == c2);
  13.         System.out.println("c1 = " + c1);
  14.         System.out.println("c2 = " + c2);
  15.         user.setSex(1);
  16.         user.setAge(16);
  17.         System.out.println("c1_1 = " + c1);
  18.         System.out.println("c2_1 = " + c2);
  19.         System.out.println(c1.getUser() == c2.getUser());
  20.         System.out.println(c1.getUser().equals(c2.getUser()));
  21.     }
  22.  
  23.  
  24.  
  25.  
  26. D:\java\jdk1.8\bin\java.exe ...
  27. true
  28. false
  29. c1 = Customer{userName='张三', password='123456', user=User{age=18, sex=0}}
  30. c2 = Customer{userName='张三', password='123456', user=User{age=18, sex=0}}
  31. c1_1 = Customer{userName='张三', password='123456', user=User{age=16, sex=1}}
  32. c2_1 = Customer{userName='张三', password='123456', user=User{age=16, sex=1}}
  33. true
  34. true
  35.  
  36. Process finished with exit code 0

我们发现clone方法之后引用类型的成员变量并没有被拷贝出一个新的对象,而是直接被引用过来的,修改任何一个对象的引用变量,另一个对象的引用变量都会改变,这里是秉着不对引用变量的对象强加意义和不改变其设计原则的原则,所以并没有对引用的对象进行clone,这里如果需要对引用变量进行clone,也就是深拷贝就需要将引用变量的对象得类也实现cloneable接口,并重写clone方法,这样就会在clone时将引用对象也一起拷贝.

2.2  深拷贝

代码如下:

  1. public class Customer implements Cloneable {
  2.  
  3.     private String userName;
  4.  
  5.     private String password;
  6.  
  7.     private User user;
  8.  
  9.     public String getUserName() {
  10.         return userName;
  11.     }
  12.  
  13.     public void setUserName(String userName) {
  14.         this.userName = userName;
  15.     }
  16.  
  17.     public String getPassword() {
  18.         return password;
  19.     }
  20.  
  21.     public void setPassword(String password) {
  22.         this.password = password;
  23.     }
  24.  
  25.     @Override
  26.     protected Object clone() throws CloneNotSupportedException {
  27.         Customer customer = (Customer)super.clone();
  28.         customer.user = (User)user.clone();
  29.         return customer;
  30.     }
  31.  
  32.     public User getUser() {
  33.         return user;
  34.     }
  35.  
  36.     public void setUser(User user) {
  37.         this.user = user;
  38.     }
  39.  
  40.     @Override
  41.     public boolean equals(Object o) {
  42.         if (this == o) return true;
  43.         if (o == null || getClass() != o.getClass()) return false;
  44.         Customer customer = (Customer) o;
  45.         return Objects.equals(userName, customer.userName) &&
  46.                 Objects.equals(password, customer.password) &&
  47.                 Objects.equals(user, customer.user);
  48.     }
  49.  
  50.     @Override
  51.     public int hashCode() {
  52.         return Objects.hash(userName, password, user);
  53.     }
  54.  
  55.     @Override
  56.     public String toString() {
  57.         return "Customer{" +
  58.                 "userName='" + userName + '\'' +
  59.                 ", password='" + password + '\'' +
  60.                 ", user=" + user +
  61.                 '}';
  62.     }
  63. }
  64.  
  65.  
  66. public class User implements Cloneable{
  67.  
  68.     private int age;
  69.  
  70.     private int sex;
  71.  
  72.     public int getAge() {
  73.         return age;
  74.     }
  75.  
  76.     @Override
  77.     public boolean equals(Object o) {
  78.         if (this == o) return true;
  79.         if (o == null || getClass() != o.getClass()) return false;
  80.         User user = (User) o;
  81.         return age == user.age &&
  82.                 sex == user.sex;
  83.     }
  84.  
  85.     @Override
  86.     public int hashCode() {
  87.         return Objects.hash(age, sex);
  88.     }
  89.  
  90.     public void setAge(int age) {
  91.         this.age = age;
  92.     }
  93.  
  94.     public int getSex() {
  95.         return sex;
  96.     }
  97.  
  98.     public void setSex(int sex) {
  99.         this.sex = sex;
  100.     }
  101.  
  102.     @Override
  103.     public String toString() {
  104.         return "User{" +
  105.                 "age=" + age +
  106.                 ", sex=" + sex +
  107.                 '}';
  108.     }
  109.  
  110.     @Override
  111.     protected Object clone() throws CloneNotSupportedException {
  112.         return super.clone();
  113.     }
  114. }
  115.  
  116.  
  117.     public static void main(String[] args) throws CloneNotSupportedException {
  118.  
  119.         Customer c1 = new Customer();
  120.         c1.setUserName("张三");
  121.         c1.setPassword("123456");
  122.         User user = new User();
  123.         user.setAge(18);
  124.         user.setSex(0);
  125.         c1.setUser(user);
  126.         Customer c2 = (Customer)c1.clone();
  127.         System.out.println(c1.equals(c2));
  128.         System.out.println(c1 == c2);
  129.         System.out.println("c1 = " + c1);
  130.         System.out.println("c2 = " + c2);
  131.         user.setAge(16);
  132.         user.setSex(1);
  133.         System.out.println("c1_1 = " + c1);
  134.         System.out.println("c2_1 = " + c2);
  135.         System.out.println(c1.getUser().equals(c2.getUser()));
  136.         System.out.println(c1.getUser() == c2.getUser());
  137.     }
  138.  
  139.  
  140.  
  141. D:\java\jdk1.8\bin\java.exe ...
  142. true
  143. false
  144. c1 = Customer{userName='张三', password='123456', user=User{age=18, sex=0}}
  145. c2 = Customer{userName='张三', password='123456', user=User{age=18, sex=0}}
  146. c1_1 = Customer{userName='张三', password='123456', user=User{age=16, sex=1}}
  147. c2_1 = Customer{userName='张三', password='123456', user=User{age=18, sex=0}}
  148. false
  149. false
  150.  
  151. Process finished with exit code 0

3.  序列化复制

序列化是将对象的拷贝写到流中,原对象还存在于内存中

反序列化是将流中的对象读到内存中

将序列化主要目的是为了实现对象的跨域跨平台传输

java实现RMI、JMS等的基础

学习一下java中关于对象的序列化知识.

常用序列化方式有:jdk, json, xml, hessian, kryo, thrift, protostuff, fst.选择什么方式的序列化主要从以下几点去考虑:跨平台,序列化的性能,序列化文件大小

jdk序列化的实现方式: 实现序列化接口

  1. public class Customer implements Serializable {
  2.  
  3.     private String userName;
  4.  
  5.     private String password;
  6.  
  7.     public String getUserName() {
  8.         return userName;
  9.     }
  10.  
  11.     public void setUserName(String userName) {
  12.         this.userName = userName;
  13.     }
  14.  
  15.     public String getPassword() {
  16.         return password;
  17.     }
  18.  
  19.     public void setPassword(String password) {
  20.         this.password = password;
  21.     }
  22.  
  23.     @Override
  24.     public boolean equals(Object o) {
  25.         if (this == o) return true;
  26.         if (o == null || getClass() != o.getClass()) return false;
  27.         Customer customer = (Customer) o;
  28.         return Objects.equals(userName, customer.userName) &&
  29.                 Objects.equals(password, customer.password);
  30.     }
  31.  
  32.     @Override
  33.     public int hashCode() {
  34.         return Objects.hash(userName, password);
  35.     }
  36.  
  37.     @Override
  38.     public String toString() {
  39.         return "Customer{" +
  40.                 "userName='" + userName + '\'' +
  41.                 ", password='" + password + '\'' +
  42.                 '}';
  43.     }
  44. }
  45.  
  46.  
  47.  
  48.     public static void main(String[] args) {
  49.  
  50.         Customer c1 = new Customer();
  51.         c1.setUserName("张三");
  52.         c1.setPassword("123456");
  53.         ObjectOutputStream os = null;
  54.         try {
  55.             os = new ObjectOutputStream(new FileOutputStream("E:\\新建文件夹\\test.txt"));
  56.             os.writeObject(c1);
  57.         } catch (IOException e) {
  58.             e.printStackTrace();
  59.         }finally {
  60.             try {
  61.                 os.close();
  62.             } catch (IOException e) {
  63.                 e.printStackTrace();
  64.             }
  65.         }
  66.     }

执行完后会对象写到对应位置文件中

然后我们写在将文件中的对象反序列化到内存中

  1.     public static void main(String[] args) {
  2.  
  3.         ObjectInputStream is = null;
  4.         Customer customer;
  5.         try {
  6.             is = new ObjectInputStream(new FileInputStream("E:\\新建文件夹\\test.txt"));
  7.             customer = (Customer)is.readObject();
  8.             System.out.println(customer);
  9.         } catch (Exception e) {
  10.             e.printStackTrace();
  11.         }finally {
  12.             try {
  13.                 is.close();
  14.             } catch (IOException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         }
  18.     }
  19.  
  20.  
  21.  
  22. D:\java\jdk1.8\bin\java.exe ...
  23. Customer{userName='张三', password='123456'}
  24.  
  25. Process finished with exit code 0

序列化需要注意的几点

    3.1 SerialVersionUID(该字段必须是静态 (static)、最终 (final) 的 long 型字段)用于对象的版本控制。当您添加或修改类中的任何字段时，已经序列化的类将无法恢复，因为serialVersionUID已为新类生成与旧的序列化对象将不同。Java序列化过程依赖于正确的serialVersionUID恢复序列化对象的状态，并在serialVersionUID不匹配时抛出java.io.InvalidClassException 异常。

添加版本号之后将对象序列化到文件,再修改对象属性,反序列化得到的还是修改前的对象,代码结果如图

  1. D:\java\jdk1.8\bin\java.exe 
  2. Customer{userName='张三', password='123456', age='null'}
  3.  
  4. Process finished with exit code 0

挡序列化一个类的实例后,希望更改一个字段或添加一个字段，不设置serialVersionUID，所做的任何更改都将导致无法反序化旧有实例，并在反序列化时抛出一个异常。如果你添加了serialVersionUID，在反序列旧有实例时，新添加或更改的字段值将设为初始化值（对象为null，基本类型为相应的初始默认值），字段被删除将不设置。

序列化和反序列化序列号不一致,会抛异常

  1. D:\java\jdk1.8\bin\java.exe ...
  2. java.io.InvalidClassException: Customer; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
  3. 	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
  4. 	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1885)
  5. 	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1751)
  6. 	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2042)
  7. 	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
  8. 	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
  9. 	at Demo.main(Demo.java:16)
  10.  
  11. Process finished with exit code 0

    3.2 transient修饰符仅适用于变量，不适用于方法和类。在序列化时，如果我们不想序列化特定变量以满足安全约束，那么我们应该将该变量声明为transient。执行序列化时，JVM会忽略transient变量的原始值并将默认值保存到文件中。因此，transient意味着不要序列化。

将password加transient修饰后,代码运行结果

  1. D:\java\jdk1.8\bin\java.exe ...
  2. Customer{userName='张三', password='null'}
  3.  
  4. Process finished with exit code 0

    3.3 静态变量不是对象状态的一部分，因此它不参与序列化。

将userName加static修饰后,代码运行结果

  1. D:\java\jdk1.8\bin\java.exe ...
  2. Customer{userName='null', password='123456'}
  3.  
  4. Process finished with exit code 0

    3.4 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口

 

转载于:https://my.oschina.net/u/4149810/blog/3065435

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/68575
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号