备案控制台
探索云世界
开发者社区 安全 文章 正文

java序列化和反序列话总结

2017-12-28 1133
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

序列化：将java对象转换为字节序列的过程叫做序列化

反序列化：将字节对象转换为java对象的过程叫做反序列化

通常情况下，序列化有两种用途：、

1) 把对象的字节序列永久的保存在硬盘中

2）在网络上传输对象的字节序列

相应的ＡＰＩ

　　java.io.ObjectOutputStream

　　　　　　　　　　writeObject(Object obj)

　　java.io.ObjectInputStream

　　　　　　　　　　readObject()

只有实现了Serializable或者Externalizable接口的类的对象才能够被序列化。否则当调用writeObject方法的时候会出现IOException。

需要注意的是Externalizable接口继承自Serializable接口。两者的区别如下：

　　仅仅实现Serializable接口的类可应采用默认的序列化方式。比如String类。

　　　　假设有一个Customer类的对象需要序列化，如果这个类仅仅实现了这个接口，那么序列化和反序列化的方式如下：ObjectOutputStream采用默认的序列化方式，对于这个类的非static，非transient的实例变量进行序列化。ObjectInputStream采用默认的反序列化方式，对于这个类的非static，非transient的实例变量进行反序列化。

　　　　如果这个类不仅实现了Serializable接口，而且定义了readObject（ObjectInputStream in）和 writeObject(ObjectOutputStream out)方法，那么将按照如下的方式进行序列化和反序列化：ObjectOutputStream会调用这个类的writeObject方法进行序列化，ObjectInputStream会调用相应的readObject方法进行反序列化。

　　实现Externalizable接口的类完全由自身来控制序列化的行为。而且必须实现writeExternal（ObjectOutput out）和readExternal（ObjectInput in）。那么将按照如下的方式进行序列化和反序列化：ObjectOutputStream会调用这个类的writeExternal方法进行序列化，ObjectInputStream会调用相应的readExternal方法进行反序列化。

下面来看一个最简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package  com.java;
 
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
 
public  class  simpleSerializableTest {
     public  static  void  main(String[] args)  throws  Exception {
         ObjectOutputStream out= new  ObjectOutputStream( new  FileOutputStream( "d:\\objectFile.obj" ));
         
         String strObj= "name" ;
         Customer customer= new  Customer( "rollen" );
         //序列化,此处故意将同一对象序列化2次
         out.writeObject(strObj);
         out.writeObject(customer);
         out.writeObject(customer);
         out.close();
         //反序列化
         ObjectInputStream in= new  ObjectInputStream( new  FileInputStream( "d:\\objectFile.obj" ));
         String strobj1=(String)in.readObject();
         Customer cus1=(Customer)in.readObject();
         Customer cus2=(Customer)in.readObject();<br data-filtered= "filtered" >　　　　　       in.close();
         System.out.println(strobj1+ ": " +cus1);
         System.out.println(strObj==strobj1);
         System.out.println(cus1==customer);
         System.out.println(cus1==cus2);
     }
}
 
class  Customer  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  String name;
 
     public  Customer() {
         System.out.println( "无参构造方法" );
     }
 
     public  Customer(String name) {
         System.out.println( "有参构造方法" );
         this .name = name;
     }
 
     public  String toString() {
         return  "[ " +name+ " ]" ;
     }
     
}

输出结果为：

有参构造方法
name: [ rollen ]
false
false
true

可以看出，在进行反序列话的时候，并没有调用类的构造方法。而是直接根据他们的序列化数据在内存中创建新的对象。另外需要注意的是，如果由一个ObjectOutputStream对象多次序列化同一个对象，那么右一个objectInputStream对象反序列化后的也是同一个对象。（cus1==cus2结果为true可以看出）

看一段代码，证明static是不会被序列化的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package  com.java;
 
import  java.io.IOException;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
import  java.net.ServerSocket;
import  java.net.Socket;
 
public  class  SerializableServer {
     public  void  send(Object obj)  throws  IOException {
         ServerSocket serverSocket =  new  ServerSocket( 8000 );
         while  ( true ) {
             Socket socket = serverSocket.accept();
             ObjectOutputStream out =  new  ObjectOutputStream(
                     socket.getOutputStream());
             out.writeObject(obj);
             out.writeObject(obj);
             out.close();
             socket.close();
         }
     }
 
     public  static  void  main(String[] args)  throws  Exception {
 
         Customer customer =  new  Customer( "rollen" ,  "male" );
         new  SerializableServer().send(customer);
     }
}
 
class  Customer  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  String name;
     private  static  int  count;
     private  transient  String sex;
 
     static  {
         System.out.println( "调用静态代码块" );
     }
 
     public  Customer() {
         System.out.println( "无参构造方法" );
     }
 
     public  Customer(String name, String sex) {
         System.out.println( "有参构造方法" );
         this .name = name;
         this .sex = sex;
         count++;
 
     }
 
     public  String toString() {
         return  "[ "  + count +  " "  + name +  " "  + sex +  " ]" ;
     }
}

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package  com.java;
 
import  java.io.ObjectInputStream;
import  java.net.Socket;
 
public  class  SerializableClient {
     public  void  recive()  throws  Exception {
         Socket socket =  new  Socket( "localhost" ,  8000 );
         ObjectInputStream in =  new  ObjectInputStream(socket.getInputStream());
         Object obj1 = in.readObject();
         Object obj2 = in.readObject();
         System.out.println(obj1);
         System.out.println(obj1==obj2);
     }
 
     public  static  void  main(String[] args) {
         try  {
             new  SerializableClient().recive();
         }  catch  (Exception e) {
             e.printStackTrace();
         }
     }
}

　　运行结果中，count的值为0.

我们来看另外一种情况：

1
2
3
4
5
6
7
8
class  A  implements  Serializable{
     B b;
     //...
}
 
class  B  implements  Serializable{
     //...
}

　　当我们在序列化A的对象的时候，也会自动序列化和他相关联的B的对象。也就是说在默认的情况下，对象输出流会对整个对象图进行序列化。因此会导致出现下面的问题，看代码（例子中是使用双向列表作为内部结构的，只是给出了demo，并没有完整的实现，只是为了说明情况）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package  com.java;
 
import  java.io.ByteArrayInputStream;
import  java.io.ByteArrayOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
 
public  class  SeriListTest  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  int  size;
     private  Node head =  null ;
     private  Node end =  null ;
 
     private  static  class  Node  implements  Serializable {
         private  static  final  long  serialVersionUID = 1L;
         String data;
         Node next;
         Node previous;
     }
 
     // 列表末尾添加一个字符串
     public  void  add(String data) {
         Node node =  new  Node();
         node.data = data;
         node.next =  null ;
         node.previous = end;
         if  ( null  != end) {
             end.next = node;
         }
         size++;
         end = node;
         if  (size ==  1 ) {
             head = end;
         }
     }
 
     public  int  getSize() {
         return  size;
     }
 
     // other methods...
 
     public  static  void  main(String[] args)  throws  Exception {
         SeriListTest list =  new  SeriListTest();
         for  ( int  i =  0 ; i <  10000 ; ++i) {
             list.add( "rollen"  + i);
         }
 
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(list);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         list = (SeriListTest) in.readObject();
         System.out.println( "size is :"  + list.getSize());
     }
 
}

　　这段代码会出现如下错误：

Exception in thread "main" java.lang.StackOverflowError
　　at java.lang.ref.ReferenceQueue.poll(ReferenceQueue.java:82)
　　at java.io.ObjectStreamClass.processQueue(ObjectStreamClass.java:2234)
      ....

整个就是因为序列化的时候，对整个对象图进行序列化引起的问题。在这种情况下啊，我们需要自定义序列化的过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package  com.java;
 
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  SeriListTest  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     transient  private  int  size;
     transient  private  Node head =  null ;
     transient  private  Node end =  null ;
 
     private  static  class  Node  implements  Serializable {
         private  static  final  long  serialVersionUID = 1L;
         String data;
         Node next;
         Node previous;
     }
 
     // 列表末尾添加一个字符串
     public  void  add(String data) {
         Node node =  new  Node();
         node.data = data;
         node.next =  null ;
         node.previous = end;
         if  ( null  != end) {
             end.next = node;
         }
         size++;
         end = node;
         if  (size ==  1 ) {
             head = end;
         }
     }
 
     public  int  getSize() {
         return  size;
     }
 
     // other methods...
 
     private  void  writeObject(ObjectOutputStream outStream)  throws  IOException {
         outStream.defaultWriteObject();
         outStream.writeInt(size);
         for  (Node node = head; node !=  null ; node = node.next) {
             outStream.writeObject(node.data);
         }
     }
 
     private  void  readObject(ObjectInputStream inStream)  throws  IOException,
             ClassNotFoundException {
         inStream.defaultReadObject();
         int  count = inStream.readInt();
         for  ( int  i =  0 ; i < count; ++i) {
             add((String) inStream.readObject());
         }
     }
 
     public  static  void  main(String[] args)  throws  Exception {
         SeriListTest list =  new  SeriListTest();
         for  ( int  i =  0 ; i <  10000 ; ++i) {
             list.add( "rollen"  + i);
         }
 
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(list);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         list = (SeriListTest) in.readObject();
         System.out.println( "size is :"  + list.getSize());
     }
 
}

　　运行结果为：10000

现在我们总结一下，在什么情况下我们需要自定义序列化的方式：

　　1）为了确保序列化的安全性，对于一些敏感信息加密

　　2）确保对象的成员变量符合正确的约束条件

　　3）优化序列化的性能（之前的那个例子已经解释了这种情况）

下面我们来用例子解释一下这些：

先来看看：为了确保序列化的安全性，对于一些敏感信息加密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package  com.java;
 
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  SeriDemo1  implements  Serializable {
     private  String name;
     transient  private  String password;  // 注意此处的transient
 
     public  SeriDemo1() {
     }
 
     public  SeriDemo1(String name, String password) {
         this .name = name;
         this .password = password;
     }
 
     // 此处模拟对密码进行加密,进行了简化
     private  String change(String password) {
         return  password +  "rollen" ;
     }
 
     private  void  writeObject(ObjectOutputStream outStream)  throws  IOException {
         outStream.defaultWriteObject();
         outStream.writeObject(change(password));
     }
 
     private  void  readObject(ObjectInputStream inStream)  throws  IOException,
             ClassNotFoundException {
         inStream.defaultReadObject();
         String strPassowrd = (String) inStream.readObject();
         //此处模拟对密码解密
         password = strPassowrd.substring( 0 , strPassowrd.length() -  6 );
     }
 
     @Override
     public  String toString() {
         return  "SeriDemo1 [name="  + name +  ", password="  + password +  "]" ;
     }
 
     public  static  void  main(String[] args)  throws  Exception {
         SeriDemo1 demo =  new  SeriDemo1( "hello" ,  "1234" );
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(demo);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         demo = (SeriDemo1) in.readObject();
         System.out.println(demo);
     }
}

　　然后我们看看：确保对象的成员变量符合正确的约束条件。比如一般情况下我们会在构造函数中对于参数进行合法性检查，但是默认的序列化并不会调用类的构造函数，直接由对象的序列化数据来构造出一个对象，这个我们就有可能提供遗传非法的序列化数据，来构造一个不满足约束条件的对象。

为了避免这种情况，我们可以自定义反序列话的方式。比如在readObject方法中，进行检查。当数据不满足约束的时候（比如年龄小于0等等不满足约束的情况），可以抛出异常之类的。

接下来我们看看readResolve()方法在单例模式中的使用：

单例模式大家应该都清楚，我就不多说了，看看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package  com.java;
 
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  ReadResolveDemo  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
 
     private  ReadResolveDemo() {
     }
 
     public  static  ReadResolveDemo getInstance() {
         return  new  ReadResolveDemo();
     }
     public  static  void  main(String[] args)  throws  Exception {
         ReadResolveDemo demo=ReadResolveDemo.getInstance();
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(demo);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         ReadResolveDemo demo1 = (ReadResolveDemo) in.readObject();
         System.out.println(demo==demo1);  //false
     }
}

　　本来单例模式中，只有一个实例，但是在序列化的时候，无论采用默认的方式，还是自定义的方式，在反序列化的时候都会产生一个新的对象，所以上面的程序运行输出false。

因此可以看出反序列化打破了单例模式只有一个实例的约定，为了避免这种情况，我们可以使用readReslove：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package  com.java;
 
import  java.io.ByteArrayInputStream;
import  java.io.ByteArrayOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
 
public  class  ReadResolveDemo  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  static  final  ReadResolveDemo INSTANCE =  new  ReadResolveDemo();
 
     private  ReadResolveDemo() {
     }
 
     public  static  ReadResolveDemo getInstance() {
         return  INSTANCE;
     }
 
     private  Object readResolve() {
         return  INSTANCE;
     }
 
     public  static  void  main(String[] args)  throws  Exception {
         ReadResolveDemo demo = ReadResolveDemo.getInstance();
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(demo);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         ReadResolveDemo demo1 = (ReadResolveDemo) in.readObject();
         System.out.println(demo == demo1);  // true
     }
}

　　最后我们简单的说一下实现Externalizable接口。　实现Externalizable接口的类完全由自身来控制序列化的行为。而且必须实现writeExternal（ObjectOutput out）和readExternal（ObjectInput in）。

注意在对实现了这个接口的对象进行反序列化的时候，会先调用类的不带参数的构造函数，这个和之前的默认反序列化方式是不一样的。

例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package  com.java;
 
import  java.io.ByteArrayInputStream;
import  java.io.ByteArrayOutputStream;
import  java.io.Externalizable;
import  java.io.IOException;
import  java.io.ObjectInput;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutput;
import  java.io.ObjectOutputStream;
 
public  class  ExternalizableDemo  implements  Externalizable {
     private  String name;
     static  {
         System.out.println( "调用静态代码块" );
     }
 
     public  ExternalizableDemo() {
         System.out.println( "调用默认无参构造函数" );
     }
 
     public  ExternalizableDemo(String name) {
         this .name = name;
         System.out.println( "调用有参构造函数" );
     }
 
     @Override
     public  void  writeExternal(ObjectOutput out)  throws  IOException {
         out.writeObject(name);
     }
 
     @Override
     public  void  readExternal(ObjectInput in)  throws  IOException,
             ClassNotFoundException {
         name = (String) in.readObject();
     }
 
     @Override
     public  String toString() {
         return  "["  + name +  "]" ;
     }
 
     public  static  void  main(String[] args)  throws  Exception {
         ExternalizableDemo demo =  new  ExternalizableDemo( "rollen" );
         ByteArrayOutputStream buf =  new  ByteArrayOutputStream();
         ObjectOutputStream out =  new  ObjectOutputStream(buf);
         out.writeObject(demo);
 
         ObjectInputStream in =  new  ObjectInputStream( new  ByteArrayInputStream(
                 buf.toByteArray()));
         demo = (ExternalizableDemo) in.readObject();
         System.out.println(demo);
     }
}

　　输出：

调用静态代码块
调用有参构造函数
调用默认无参构造函数
[rollen]

 参考资料：

1.java序列化高级认识


==============================================================================
本文转自被遗忘的博客园博客，原文链接：http://www.cnblogs.com/rollenholt/archive/2012/11/26/2789445.html，如需转载请自行联系原作者
文章标签：
Java
数据安全/隐私保护
关键词：
序列化java
Java序列化
Java序列
序列化序列
Java总结
泳泳啊泳泳
目录
相关文章
wljslmz
|
1月前
|
存储 Java 数据库
详细介绍Java中的序列化和反序列化机制，以及如何使用它们
【2月更文挑战第12天】
wljslmz
38 0
wljslmz
|
1月前
|
存储 Java 数据处理
如何使用 Java 对时间序列数据进行每 x 秒的分组操作？
【2月更文挑战第9天】
wljslmz
20 0
如何使用 Java 对时间序列数据进行每 x 秒的分组操作？
失重外太空.
|
3月前
|
存储 算法 Java
从零开始学习 Java：简单易懂的入门指南之IO序列化、打印流、压缩流（三十三）
从零开始学习 Java：简单易懂的入门指南之IO序列化、打印流、压缩流（三十三）
失重外太空.
38 0
东方睿赢
|
12天前
|
存储 Java
Java输入输出：解释一下序列化和反序列化。
Java中的序列化和反序列化是将对象转换为字节流和反之的过程。ObjectOutputStream用于序列化，ObjectInputStream则用于反序列化。示例展示了如何创建一个实现Serializable接口的Person类，并将其序列化到文件，然后从文件反序列化回Person对象。
东方睿赢
19 5
达芬奇要当程序员
|
1月前
|
存储 缓存 JSON
什么是Java序列化，它有哪些重要性
什么是Java序列化，它有哪些重要性
达芬奇要当程序员
25 3
1932836719192345
|
2月前
|
存储 自然语言处理 Java
java缓冲流、转换流、序列化流、打印流
java缓冲流、转换流、序列化流、打印流介绍
1932836719192345
59 1
云水闲
|
2月前
|
Java
Java栈的压入、弹出序列（详解）
Java栈的压入、弹出序列（详解）
云水闲
24 0
HannYang
|
3月前
|
Java Go C++
Golang每日一练(leetDay0112) 2、3、4的幂
Golang每日一练(leetDay0112) 2、3、4的幂
HannYang
30 0
Golang每日一练(leetDay0112) 2、3、4的幂
HannYang
|
3月前
|
Java Go C++
Golang每日一练(leetDay0085) 2的幂、数字 1 的个数
Golang每日一练(leetDay0085) 2的幂、数字 1 的个数
HannYang
24 0
Golang每日一练(leetDay0085) 2的幂、数字 1 的个数
HannYang
|
3月前
|
Java Go C++
Java每日一练(20230420) 罗马数字转整数、电话号码的字母组合、排列序列
Java每日一练(20230420) 罗马数字转整数、电话号码的字母组合、排列序列
HannYang
24 0
Java每日一练(20230420) 罗马数字转整数、电话号码的字母组合、排列序列

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Kafka【付诸实践 01】生产者发送消息的过程描述及设计+创建生产者并发送消息（同步、异步）+自定义分区器+自定义序列化器+生产者其他属性说明（实例源码粘贴可用）【一篇学会使用Kafka生产者】
    161
  • 2
    [Redis]——RedisTemplate的两种序列化方式
    20
  • 3
    使用Jackson进行 JSON 序列化和反序列化
    25
  • 4
    GSON 泛型对象反序列化解决方案
    23
  • 5
    android 使用GSON 序列化对象出现字段被优化问题解决方案
    16
  • 6
    序列化模块pickle和json有什么区别
    18
  • 7
    硬核！Apache Hudi中自定义序列化和数据写入逻辑
    33
  • 8
    如何把一个 ABAP 类的实例，序列化成 XML 字符串试读版
    13
  • 9
    java缓冲流、转换流、序列化流、打印流
    59
  • 10
    331. 验证二叉树的前序序列化
    16

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）