序列化与反序列化

朱雀 2021-09-23 00:00 637阅读 0赞

概念

把对象的状态信息转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

  1. 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。
  2. 在网络上传送对象的字节序列。

从对象流中读取或输入的对象必须是支持 java.io.Serializable 或 java.io.Externalizable 接口的对象。readObject和writeObject方法用于从对象流中读取写入对象。在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

serialVersionUID

对象序列化时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联。在实现Serializable接口后，我们需要生成这么一串版本号。该序列号在反序列化过程中用于验证序列化对象的接收者是否为该对象加载了与序列化对象所兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者发送的类的对象的版本号不一样，则反序列化时将会抛出InvalidClassException。例如：
public class User implements Serializable{
private final long serialVersionUID = 1L;
}
如果实现了该接口但未显示声明serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值。但是强烈建议显示的去申明serialVersionUID，因为编译的实现和计算serialVersionUID的千差万别有可能在跨编译器编译时生成了不同的serialVersionUID，导致反序列化的时候抛出InvalidClassException。

API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数中指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

  1. package java.io;
  2. public class ObjectOutputStream
  3.     extends OutputStream implements ObjectOutput, ObjectStreamConstants{ }
  5. package java.io;
  6. public interface ObjectOutput extends DataOutput, AutoCloseable {
  7.     //部分
  8.     public void writeObject(Object obj) throws IOException;
  9. }

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

  1. package java.io;
  2. public class ObjectInputStream 
  3.     extends InputStream implements ObjectInput, ObjectStreamConstants{ }
  5. package java.io;
  6. public interface ObjectInput extends DataInput, AutoCloseable {
  7.     //部分
  8.     public Object readObject() throws ClassNotFoundException, IOException;
  9. }

java.lang.ClassNotFoundException(父类 java.lang.ReflectiveOperationException与java.io.IOException一个级别)

对象序列化包括如下步骤：写入

  1. 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流。

  2. 通过对象输出流的writeObject()方法将对象写入。（对象持久化）。

    final 修饰：java.io.ObjectOutputStream 类中的
    public final void writeObject(Object obj) throws IOException{ }

对象反序列化的步骤如下：读取

  1. 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流。

  2. 通过对象输入流的readObject()方法读取对象。

    final 修饰：java.io.ObjectInputStream 类中
    public final Object readObject(){ } //返回Object 类型，所以返回值要强制转换成对象的原类型

同一缓冲区的2个相同反序列对象具有相同内存地址，但跟原对象地址不一样。不同缓冲区的2个相同反序列对象具有不同的内存地址。

将一个对象序列化到一个对象流中两次，则第二次存入流中的对象实际是第一次存入流中的对象的别名，之后再两次从对象流中读出，则取出的两个对象指向同一个对象（与序列化之前的对象不一致，相当于克隆）。
将一个对象序列化倒两个对象流中，再次取出时两个对象不一致

序列化方式一：实现Serializable接口(隐式序列化)

通过实现Serializable接口，可以实现自动序列化所有非static和 非transient关键字修饰的成员变量。也可以手动序列化，见序列化方式三。

writeObject和readObject方法会在序列化、反序列化的过程中被自动调用。方法调用后可以关闭或刷新对象流。

若一个类的字段有引用对象，那么在序列化该类的时候不仅该类要实现Serializable接口，这个引用类型也要实现Serializable接口。

如果父类没有实现Serializable接口，但其子类实现了此接口，那么这个子类是可以序列化的，但是在反序列化的过程中会调用父类的无参构造函数，所以在其直接父类（注意是直接父类）中必须有一个无参的构造函数。即：如果直接父类中无构造函数，可以反序列化，但直接父类中定义了构造函数，则必须还要显式添加一个无参的构造函数。否则，只能在父类也实现Serializable接口。该无参构造函数只要不是被private修饰就可以，这与Externalizable接口的实现类的构造方法的要求不一样。

  1. Serializable 源码：
  2. package java.io;
  3. public interface Serializable {
  4. }
  6. 完整例子：
  7. import java.io.ByteArrayInputStream;
  8. import java.io.ByteArrayOutputStream;
  9. import java.io.IOException;
  10. import java.io.ObjectInputStream;
  11. import java.io.ObjectOutputStream;
  12. import java.io.Serializable;
  13. class Student implements Serializable{
  14.     private static final long serialVersionUID = 1L;
  15.     private String name;
  16.     private int age;
  17.     public static int QQ = 1234;
  18.     private transient String address = "CHINA";
  19.     public Student(String name, int age ){
  20.         this.name = name;
  21.         this.age = age;
  22.     }
  23.     public String toString() {
  24.         return "name: " + name + "\n"
  25.                 +"age: " + age + "\n"
  26.                 +"QQ: " + QQ + "\n" 
  27.                 + "address: " + address;
  28.     }
  29.     public void SetAge(int age) {
  30.         this.age = age;
  31.     }
  32. }
  33. public class Demo {
  34.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  35.         System.out.println("原来的对象：");
  36.         Student stu = new Student("Ming", 16);
  37.         System.out.println(stu);
  38.         //创建目标输出流(缓冲区)
  39.         ByteArrayOutputStream buff = new ByteArrayOutputStream();
  40.         //创建对象输出流
  41.         ObjectOutputStream out = new ObjectOutputStream(buff);
  42.         //将序列化对象存入缓冲区
  43.         out.writeObject(stu);
  44.         //修改相关值
  45.         Student.QQ = 6666; 
  46.         // 发现打印结果QQ的值被改变(没被序列化,static修饰的变量属于类，每个对象里都是这个修改后的值)
  47.         stu.SetAge(18);   //发现值没有被改变
  48.         //从缓冲区取回被序列化的对象
  49.         ObjectInputStream in = 
  50.             new ObjectInputStream(new ByteArrayInputStream(buff.toByteArray()));
  51.         Student newStu = (Student) in.readObject();
  52.         System.out.println("序列化后取出的对象：");
  53.         System.out.println(newStu);
  54.     }
  55. }
  56. Output：
  57. 原来的对象：
  58. name: Ming
  59. age: 16
  60. QQ: 1234
  61. address: CHINA
  62. 序列化后取出的对象：
  63. name: Ming
  64. age: 16
  65. QQ: 6666
  66. address: null

分析：发现address(被transient修饰)和QQ(被static修饰)没有被序列化。static成员不属于对象，所以没办法序列化（如果将static变量序列化，该变量仍可在其他对象中改变；但每个该类的对象的static变量值都应该是一致的，即修改后的，而此时某对象序列化后的字节序列中的staic变量值并没有被同时修改，反序列化后数据会不一致），序列化是序列化某个对象。由于address被反序列化后没有对应的引用，所以为null。而且Serializable不会调用构造方法。
序列化可以保存对象的初始信息，在以后还可以回到这个初始状态。 

  1. class Demo2 implements Serializable{
  2.      String s="name";
  3.      public Demo2(int x) {     
  4.      }     
  5.  }
  6.  class Demo1 extends Demo2 implements Serializable{
  7.     private static final long serialVersionUID = 1L;
  8.     public transient int age = 23;
  9.     public String name ;
  10.     public Demo1(String name) {
  11.         super(45);
  12.         this.name = name;
  13.     }
  14.     public String toString() {
  15.         return "年龄" + age + "  " + name; 
  16.     }
  17. 可正常序列化与反序列化Demo1 子类。父类子类构造器都不会在反序列化时被调用。
  19. package delete;
  21. import java.io.ByteArrayInputStream;
  22. import java.io.ByteArrayOutputStream;
  23. import java.io.IOException;
  24. import java.io.ObjectInputStream;
  25. import java.io.ObjectOutputStream;
  26. import java.io.Serializable;
  27.  class Demo2 {
  28.      String s="name";
  29.      public Demo2(int x) {
  30.          System.out.println("constructor 1");
  31.      }
  32.      public Demo2( ) {
  33.          System.out.println("constructor null");
  34.      } 
  35.  }
  36. public class Demo1 extends Demo2 implements Serializable{
  37.     private static final long serialVersionUID = 1L;
  38.     public transient int age = 23;
  39.     public String name ;
  40.     public Demo1(String name) {
  41.         super(45);
  42.         System.out.println("constructor 2");
  43.         this.name = name;
  44.     }
  45.     public String toString() {
  46.         return "年龄" + age + "  " + name; 
  47.     }
  48.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  49.         Demo1 stu = new Demo1("Ming");
  50.         System.out.println(stu);
  51.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  52.         ObjectOutputStream out = new ObjectOutputStream(bout);
  53.         out.writeObject(stu);
  54.         ObjectInputStream in = 
  55.             new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));
  56.         Demo1 stu1 = (Demo1) in.readObject();
  57.         System.out.println(stu1);
  58.     }
  59. }
  60. Output：
  61. constructor 1
  62. constructor 2
  63. 年龄23  Ming
  64. constructor null
  65. 年龄0  Ming
  67. 可正常序列化与反序列化Demo1 子类。反序列化时，子类Demo1 的构造器不会被调用，
  68. 但父类Demo2 的无参构造器会被调用。
  70. class Demo2 {
  71.      String s="name";
  72.      public Demo2(int x) {     
  73.      }     
  74.  }
  75. Demo1 extends Demo2 implements Serializable{
  76.     private static final long serialVersionUID = 1L;
  77.     public transient int age = 23;
  78.     public String name ;
  79.     public Demo1(String name) {
  80.         super(45);
  81.         this.name = name;
  82.     }
  83.     public String toString() {
  84.         return "年龄" + age + "  " + name; 
  85.     }
  86. 可正常序列化子类，不能正常反序列化Demo1 子类，
  87. 会抛出java.io.InvalidClassException: no valid constructor

序列化方式二：实现Externalizable接口(显式序列化)

Externalizable接口继承自Serializable,。在实现该接口时，必须实现writeExternal()和readExternal()方法，这些方法将代替定制的 writeObject 和 readObject 方法。而且只能通过手动进行序列化，并且两个方法是自动调用的。因此，这个序列化过程是可控的，可以自己选择进行序列化的部分。

Serialization 对象可以使用 Serializable 或 Externalizable 接口。对象持久性机制也可以使用它们。要存储的每个对象都需要检测是否支持 Externalizable 接口。如果对象支持 Externalizable，则调用 writeExternal 方法。如果对象不支持 Externalizable 但实现了 Serializable，则使用 writeObject保存该对象。

在重构 Externalizable 对象时，先使用无参数的公共构造方法创建一个实例，（所以在使用Externalizable时相应的实现类必须提供一个public的无参构造器，否则会抛出java.io.InvalidClassException）然后调用 readExternal 方法。通过从 ObjectInputStream 中读取 Serializable 对象可以恢复这些对象。

如果没有定义无参公共构造方法，则序列化会正常，反序列化时产生InvalidClassException。

实现Externalizable 接口的类必须显式提供一个public的无参构造器，除public修饰外，其余访问修饰符都会产生InvalidClassException异常。

对象实现 readExternal 方法来恢复其内容，它通过调用 DataInput 的方法来恢复其基础类型，调用 readObject 来恢复对象、字符串和数组。readExternal 方法必须按照与 writeExternal 方法写入值时使用的相同顺序和类型来读取这些值。(多写少读也可以运行)。

  1. Externalizable 源码：
  2. package java.io;
  3. import java.io.ObjectOutput;
  4. import java.io.ObjectInput;
  5. public interface Externalizable extends java.io.Serializable{
  6.     void writeExternal(ObjectOutput out) throws IOException;
  7.     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
  8.  }
  10. 完整例子：
  11. import java.io.Externalizable;
  12. import java.io.FileInputStream;
  13. import java.io.FileNotFoundException;
  14. import java.io.FileOutputStream;
  15. import java.io.IOException;
  16. import java.io.ObjectInput;
  17. import java.io.ObjectInputStream;
  18. import java.io.ObjectOutput;
  19. import java.io.ObjectOutputStream;
  20. public class Demo implements Externalizable{
  21.     private int i ;
  22.     private String s;
  23.     public Demo() {}
  24.     public Demo(String x, int a) {
  25.         System.out.println("Demo对象已构造完成");
  26.         s = x;
  27.         i = a;
  28.     }
  29.     public String toString() {
  30.         return s+" "+i;
  31.     }
  32.     @Override
  33.     public void writeExternal(ObjectOutput out) throws IOException {
  34.         //规定了对象中哪些成员会进行序列化，同时添加一些进行序列化时的其他行为
  35.         System.out.println("Demo.writeExternal");
  36.         out.writeObject(s);
  37.         out.writeInt(i);    
  38.     }
  39.     @Override
  40.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  41.         System.out.println("Demo.readExternal");
  42.         s = (String)in.readObject();
  43.         i = in.readInt();
  44.     }
  45.     public static void main(String[] args)
  46.              throws FileNotFoundException, IOException, ClassNotFoundException {
  47.         System.out.println("Constructing objects");
  48.         Demo b = new Demo("A Stirng", 47);
  49.         System.out.println(b);
  50.         ObjectOutputStream o = 
  51.             new ObjectOutputStream(new FileOutputStream("D:\\45\\test.txt"));
  52.         System.out.println("保存对象");
  53.         o.writeObject(b);
  54.         o.close();
  55.         //获得对象
  56.         System.out.println("获取对象");
  57.         ObjectInputStream in = 
  58.             new ObjectInputStream(new FileInputStream("D:\\45\\test.txt"));
  59.         System.out.println("Recovering b");
  60.         b = (Demo)in.readObject();
  61.         in.close();
  62.         System.out.println(b);
  63.     }
  64. }
  65. Output：
  66. Constructing objects
  67. Demo对象已构造完成
  68. A Stirng 47
  69. 保存对象
  70. Demo.writeExternal
  71. 获取对象
  72. Recovering b
  73. Demo.readExternal
  74. A Stirng 47

序列化方式三：实现Serializable接口+添加writeObject()和readObject()方法。(显+隐序列化)

手动序列化时可以实现将被transient关键字修饰的字段序列化。要想实现手动序列化需要在实现了Serializable接口的类中添加两个私有的方法writeObject()和readObject()，在这两个方法中控制字段的序列化。注意这里是添加，不是重写或者覆盖。但是添加的这两个方法必须有相应的格式。

  1. 方法必须要被private修饰 ——->才能被调用
  2. 第一行调用默认的defaultRead/WriteObject(); ——->隐式序列化非static和transient

  3. 调用方法。与序列化方式二类似 —>显式序列化

    简单例子：
    private void writeObject(ObjectOutputStream oos)throws IOException{

    1. oos.defaultWriteObject();
    2. oos.writeObject(password); //transient password，实现transient变量的序列化

    }
    private void readObject(ObjectInputStream ois)throws IOException,ClassNotFoundException{

    1. ois.defaultReadObject();
    2. password = (String)ois.readObject();

    }

    完整例子：
    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 Demo1 implements Serializable{

    1. private static final long serialVersionUID = 1L;
    2. public transient int age = 23;
    3. public String name ;
    4. public Demo1(String name) {
    5.     this.name = name;
    6. }
    7. private void writeObject(ObjectOutputStream stream) throws IOException {
    8.     stream.defaultWriteObject();
    9.     stream.writeInt(age);
    10. }
    11. private void readObject(ObjectInputStream stream)
    12.              throws ClassNotFoundException, IOException {
    13.     stream.defaultReadObject();
    14.     age = stream.readInt();
    15. }
    16. public String toString() {
    17.     return "年龄" + age + "  " + name; 
    18. }
    19. public static void main(String[] args) throws IOException, ClassNotFoundException {
    20.     Demo1 stu = new Demo1("Ming");
    21.     ByteArrayOutputStream bout = new ByteArrayOutputStream();
    22.     ObjectOutputStream out = new ObjectOutputStream(bout);
    23.     out.writeObject(stu);
    24.     ObjectInputStream in = 
    25.         new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));
    26.     Demo1 stu1 = (Demo1) in.readObject();
    27.     System.out.println(stu1);
    28. }

    }
    Output：//可以把transient修饰的变量也序列化和反序列化了
    年龄23 Ming
    //注释掉stream.writeInt(age)和age= stream.readInt()后，输出：年龄0 Ming
    //由于age被trancient修饰，所以需要显式序列化。

static的序列化

当我们要读取对象中static变量的值时，它不可能在反序列化的文件里找到新的值，而是去全局数据区中取值。

**序列化静态变量可以在所在类实现public static void deserializeStaticState / serializeStaticState (ObjectOutputStream os) throws IOException两个方法。**之后在main函数里调用。

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7. import java.lang.reflect.Field;
  8. import java.util.ArrayList;
  9. import java.util.List;
  10. import java.util.Random;
  12. abstract class Shape implements Serializable {
  13.     private static final long serialVersionUID = 1L;
  14.     public static final int RED = 1, BLUE = 2, GREEN = 3;
  15.     private int xPos, yPos, dimension;
  16.     private static Random rand = new Random(47);
  17.     private static int counter = 0;
  18.     public abstract void setColor(int newColor);
  19.     public abstract int getColor();
  20.     public Shape(int xVal, int yVal, int dim) {
  21.         xPos = xVal;
  22.         yPos = yVal;
  23.         dimension = dim;
  24.       }
  25.     public String toString() {
  26.         return getClass() +
  27.           "color[" + getColor() + "] xPos[" + xPos +
  28.           "] yPos[" + yPos + "] dim[" + dimension + "]\n";
  29.       }
  30.       public static Shape randomFactory() {
  31.         int xVal = rand.nextInt(100);
  32.         int yVal = rand.nextInt(100);
  33.         int dim = rand.nextInt(100);
  34.         switch(counter++ % 3) {
  35.           default:
  36.           case 0: return new Circle(xVal, yVal, dim);
  37.           case 1: return new Square(xVal, yVal, dim);
  38.           case 2: return new Line(xVal, yVal, dim);
  39.         }
  40.       }
  41.     }
  42. class Circle extends Shape {
  43.     private static final long serialVersionUID = 1L;
  44.     private static int color = RED;
  45.       public Circle(int xVal, int yVal, int dim) {
  46.         super(xVal, yVal, dim);
  47.       }
  48.       public void setColor(int newColor) { color = newColor; }
  49.       public int getColor() { return color; }
  50.     }
  51. class Square extends Shape {
  52.     private static final long serialVersionUID = 1L;
  53.       private static int color;
  54.       public Square(int xVal, int yVal, int dim) {
  55.         super(xVal, yVal, dim);
  56.         color = RED;
  57.       }
  58.       public void setColor(int newColor) { color = newColor; }
  59.       public int getColor() { return color; }
  60.     }
  61. class Line extends Shape {
  62.     private static final long serialVersionUID = 1L;
  63.       private static int color = RED;
  64. ******************************************************************
  65. *      public static void serializeStaticState(ObjectOutputStream os) throws IOException {
  66. *          os.writeInt(color); 
  67. *      }
  68. *      public static void deserializeStaticState(ObjectInputStream os) throws IOException { 
  69. *          color = os.readInt(); 
  70. *      }
  71. *****************************************************************
  72.       public Line(int xVal, int yVal, int dim) {
  73.         super(xVal, yVal, dim);
  74.       }
  75.       public void setColor(int newColor) { color = newColor; }
  76.       public int getColor() { return color; }
  77.     }
  78. public class Test {
  79.       public static void main(String[] args) throws Exception {
  80.         List<Class<? extends Shape>> shapeTypes = new ArrayList<Class<? extends Shape>>();
  81.         // Add references to the class objects:
  82.         shapeTypes.add(Circle.class);
  83.         shapeTypes.add(Square.class);
  84.         shapeTypes.add(Line.class);
  85.         List<Shape> shapes = new ArrayList<Shape>();
  86.         // Make some shapes:
  87.         for(int i = 0; i < 10; i++)
  88.           shapes.add(Shape.randomFactory());
  89.         // Set all the static colors to GREEN:
  90.         for(int i = 0; i < 10; i++)
  91.           ((Shape)shapes.get(i)).setColor(Shape.GREEN);
  92.         // Save the state vector:
  93.     *******************************************************************
  94.     *    ObjectOutputStream out = 
  95.     *            new ObjectOutputStream(new FileOutputStream("CADState.out"));
  96.     *    out.writeObject(shapeTypes);
  97.     *    Line.serializeStaticState(out);
  98.     *    out.writeObject(shapes);
  99.     *******************************************************************
  100.         // Display the shapes:
  101.         System.out.println(shapes);
  102.         System.out.println("-------------------------------------");
  104.         ObjectInputStream in = new ObjectInputStream(new FileInputStream("CADState.out"));
  105.        // Read in the same order they were written:
  106.     **********************************************************************
  107.     *   List<Class<? extends Shape>> shapeTypes1 =
  108.     *            (List<Class<? extends Shape>>)in.readObject();
  109.     *   Line.deserializeStaticState(in);
  110.     *   List<Shape> shapes1 = (List<Shape>)in.readObject();
  111.     ********************************************************************
  112.        System.out.println(shapes1);
  113.     //以下是用序列化的Class对象，得到static变量
  114.          Field f =shapeTypes1.get(0).getDeclaredField("color");
  115.        System.out.println(f); //private static int Circle.color
  116.        Circle k= (Circle)shapes1.get(0);
  117.        f.setAccessible(true);
  118.        System.out.println( f.get(k));  //3
  119.       }
  120.     }

换言之，一个Class对象是由类定义决定的，与程序运行时的数值变化无关，所以，即使在源文件A中修改了static变量，之后又将Class对象序列化，但在源文件B中反序列化时，Class对象中还是没有保存static的修改值，仍是当初类定义时的那些东西。因此，反序列化时，会去全局数据区找static变量的值，如果B中没改过static变量，则找到的值一定是初始定义处的值。

两接口区别

实现复杂度：
Serializable 实现简单，Java对其有内建支持。（该保存啥都已经是早就确定好了的）。
Externalizable 实现复杂，由开发人员自己完成。

执行效率：
Serializable 所有成员变量由Java统一保存，性能较低。
Externalizable 开发人员决定哪个成员变量要保存，可能造成速度提升。

占用空间：
Serializable 保存全部成员变量信息，占用空间较大。
Externalizable 存储部分成员变量，可能造成空间减少。

发表评论

表情：
评论列表 （有 0 条评论，637人围观）

还没有评论，来说两句吧...

相关阅读

    相关 序列化与反序列化

    一、概念 1、序列化 将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。 2、反序列化 与序列化相反，是将二进制

    怼烎@怼烎@/ 0 赞/ 115 阅读

    相关 序列化与反序列化

    因为TCP/IP协议只支持字节数组的传输，不能直接传对象。对象序列化的结果一定是字节数组！当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二

    小鱼儿小鱼儿/ 0 赞/ 326 阅读

    相关 序列化与反序列化

    我们知道，和new创建对象，反射创建对象，序列化创建对象也是我们常用的一种对象创建方式，下面就详细的说一说序列化与反序列化。 一.序列化简述 为什么需要序列化与反序列

    叁歲伎倆叁歲伎倆/ 0 赞/ 821 阅读

    相关 序列化与反序列化

    序列化：将对象转化为字节序列 反序列化：将字节序列转化为对象 序列化与反序列化的好处： 1. 进行远程通信传输对象 我们知道数据是以二进制的方式在网络上传输的

    缺乏、安全感缺乏、安全感/ 0 赞/ 422 阅读

    相关 序列化与反序列化

    一、序列化的概念 序列化：首先，用日常生活中的例子来理解一下序列化。在我们日常生活中，运输一个整个的汽车总是不方便的，所以我们会把汽车拆开，当汽车变成一个个零件的时候，我们

    你的名字你的名字/ 0 赞/ 453 阅读

    相关 序列化与反序列化

    概念 -------------------- 把对象的状态信息转换为字节序列的过程称为对象的序列化。 把字节序列恢复为对象的过程称为对象的反序列化。 对象的序列

    朱雀朱雀/ 0 赞/ 638 阅读