java持久化 seri_Java 的序列化 (Serialization) 教程
Java提供一种机制叫做序列化，通过有序的格式或者字节序列持久化java对象，其中包含对象的数据，还有对象的类型，和保存在对象中的数据类型。
所以，如果我们已经序列化了一个对象，那么它可以被读取并通过对象的类型和其他信息进行反序列化，并最终获取对象的原型。
ObjectInputStream 和 ObjectOutputStream对象是高级别的流对象，包含序列化和反序列化的方法。
ObjectOutputStream 拥有很多序列化对象的方法，最常用的是：
1
private void
writeObject(ObjectOutputStream os)throws
IOException
2
{
3
4
}
类似的 ObjectInputStream 提供如下方法：
1
private
void readObject(ObjectInputStream is)throws IOException, ClassNotFoundException
2
{
3
4
}
那么哪里会需要序列化呢？序列化通常在需要通过网络传输数据，或者保存对象到文件的场合使用。这里说的数据是对象而不是文本。
现在的问题是，我们的网络架构和硬盘都只能识别二进制和字节，而不能识别Java对象。
序列化就是把Java对象中的value/states翻译为字节，以便通过网络传输或者保存。另外，反序列化就是通过读取字节码，并把它翻译回java对象。
serialVersionUID概念
serialVersionUID 是用于保证同一个对象(在序列化中会被用到)可以在Deserialization过程中被载入。serialVersionUID 是用于对象的版本控制。你可以参考serialVersionUID
in java serialization获取更多信息。
对于序列化：
步骤如下：
让我们看一个列子：
在 src->org.arpit.javapostsforlearning 创建Employee.java
1.Employee.java
01
package org.arpit.javapostsforlearning;
02
import java.io.Serializable;
03
public class
Employeeimplements Serializable{
04
05
int
employeeId;
06
String employeeName;
07
String department;
08
09
public
int getEmployeeId() {
10
return
employeeId;
11
}
12
public
void setEmployeeId(int
employeeId) {
13
this.employeeId = employeeId;
14
}
15
public
String getEmployeeName() {
16
return
employeeName;
17
}
18
public
void setEmployeeName(String employeeName) {
19
this.employeeName = employeeName;
20
}
21
public
String getDepartment() {
22
return
department;
23
}
24
public
void setDepartment(String department) {
25
this.department = department;
26
}
27
}
就如你所见的，如果你需要序列化任何类，那么你 必须实现 Serializable 接口 ，这个接口是标记接口(marker interface)。
Java中的标记接口(marker interface)就是一个没有任何字段或者方法的接口，简单的来说，java中把空接口叫做标记接口(marker interface)
2.SerializeMain.java
01
package org.arpit.javapostsforlearning;
02
import java.io.FileOutputStream;
03
import java.io.IOException;
04
import java.io.ObjectOutputStream;
05
public
class SerializeMain {
06
07
/**
08
* @author Arpit Mandliya
09
*/
10
public
static void main(String[] args) {
11
12
Employee emp =new Employee();
13
emp.setEmployeeId(101);
14
emp.setEmployeeName("Arpit");
15
emp.setDepartment("CS");
16
try
17
{
18
FileOutputStream fileOut =new FileOutputStream("employee.ser");
19
ObjectOutputStream outStream =new ObjectOutputStream(fileOut);
20
outStream.writeObject(emp);
21
outStream.close();
22
fileOut.close();
23
}catch(IOException i)
24
{
25
i.printStackTrace();
26
}
27
}
28
}
对于反序列化:
步骤是
在包src->org.arpit.javapostsforlearning中，创建 DeserializeMain.java
3.DeserializeMain.java
01
package org.arpit.javapostsforlearning;
02
import java.io.IOException;
03
import java.io.ObjectInputStream;
04
05
public class
DeserializeMain {
06
/**
07
* @author Arpit Mandliya
08
*/
09
public
static void main(String[] args) {
10
11
Employee emp =null;
12
try
13
{
14
FileInputStream fileIn =new
FileInputStream("employee.ser");
15
ObjectInputStream in =new ObjectInputStream(fileIn);
16
emp = (Employee) in.readObject();
17
in.close();
18
fileIn.close();
19
}catch(IOException i)
20
{
21
i.printStackTrace();
22
return;
23
}catch(ClassNotFoundException c)
24
{
25
System.out.println("Employee class not found");
26
c.printStackTrace();
27
return;
28
}
29
System.out.println("Deserialized Employee...");
30
System.out.println("Emp id: "
+ emp.getEmployeeId());
31
System.out.println("Name: "
+ emp.getEmployeeName());
32
System.out.println("Department: "
+ emp.getDepartment());
33
}
34
}
4.运行:
首先运行SerializeMain.java，然后运行 DeserializeMain.java，你会得到如下的结果:
1
Deserialized Employee...
2
Emp id:101
3
Name: Arpit
4
Department: CS
就这样，我们序列化了一个employee对象，并对它进行反序列化。这看起来和简单，但是如果其中包含对象引用，继承，那么情况就会变得复杂。接下来让我们一个接一个的看一下例子，看看如何在各种场合中实现序列化。
案例1 - 如果对象引用了其他对象，那该如何
我们已经看过最简单的序列化例子，现在看看，如何处理对象中引用了其他对象的场合。我们该如何序列化？引用对象也会被序列化吗？对的，你不需要显式的序列化引用对象。当你序列化任何对象，如果它包含引用对象，那么Java序列化会自动序列化该对象的整个对象图。例如，Employee现在引用了一个address对象，并且Address也引用了其他对象(例如，Home)，那么当你序列化Employee对象的时候，所有其他引用对象，例如address和home将会被自动地被序列化。让我们来创建Address类，并它Address的对象作为引用，添加到employee类中。
Employee.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.Serializable;
03
04
public class
Employeeimplements Serializable{
05
06
int
employeeId;
07
String employeeName;
08
String department;
09
Address address;
10
11
public
int getEmployeeId() {
12
return
employeeId;
13
}
14
public
void setEmployeeId(int
employeeId) {
15
this.employeeId = employeeId;
16
}
17
public
String getEmployeeName() {
18
return
employeeName;
19
}
20
public
void setEmployeeName(String employeeName) {
21
this.employeeName = employeeName;
22
}
23
public
String getDepartment() {
24
return
department;
25
}
26
public
void setDepartment(String department) {
27
this.department = department;
28
}
29
public
Address getAddress() {
30
return
address;
31
}
32
public
void setAddress(Address address) {
33
this.address = address;
34
}
35
}
在 org.arpit.javapostsforlearning 包中，创建Address.java
Address.java:
01
package org.arpit.javapostsforlearning;
02
public class
Address {
03
04
int
homeNo;
05
String street;
06
String city;
07
public
Address(int homeNo, String street, String city) {
08
super();
09
this.homeNo = homeNo;
10
this.street = street;
11
this.city = city;
12
}
13
public
int getHomeNo() {
14
return
homeNo;
15
}
16
public
void setHomeNo(int
homeNo) {
17
this.homeNo = homeNo;
18
}
19
public
String getStreet() {
20
return
street;
21
}
22
public
void setStreet(String street) {
23
this.street = street;
24
}
25
public
String getCity() {
26
return
city;
27
}
28
public
void setCity(String city) {
29
this.city = city;
30
}
31
}
在包 org.arpit.javapostsforlearning中，创建SerializeDeserializeMain.java
SerializeDeserializeMain.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.FileInputStream;
03
import java.io.FileOutputStream;
04
import java.io.IOException;
05
import java.io.ObjectInputStream;
06
import java.io.ObjectOutputStream;
07
08
public class
SerializeDeserializeMain {
09
/**
10
* @author Arpit Mandliya
11
*/
12
public
static void main(String[] args) {
13
14
Employee emp =new Employee();
15
emp.setEmployeeId(101);
16
emp.setEmployeeName("Arpit");
17
emp.setDepartment("CS");
18
Address address=new
Address(88,"MG road","Pune");
19
emp.setAddress(address);
20
//Serialize
21
try
22
{
23
FileOutputStream fileOut =new FileOutputStream("employee.ser");
24
ObjectOutputStream outStream =new ObjectOutputStream(fileOut);
25
outStream.writeObject(emp);
26
outStream.close();
27
fileOut.close();
28
}catch(IOException i)
29
{
30
i.printStackTrace();
31
}
32
33
//Deserialize
34
emp =
null;
35
try
36
{
37
FileInputStream fileIn =new
FileInputStream("employee.ser");
38
ObjectInputStream in =new ObjectInputStream(fileIn);
39
emp = (Employee) in.readObject();
40
in.close();
41
fileIn.close();
42
}catch(IOException i)
43
{
44
i.printStackTrace();
45
return;
46
}catch(ClassNotFoundException c)
47
{
48
System.out.println("Employee class not found");
49
c.printStackTrace();
50
return;
51
}
52
System.out.println("Deserialized Employee...");
53
System.out.println("Emp id: "
+ emp.getEmployeeId());
54
System.out.println("Name: "
+ emp.getEmployeeName());
55
System.out.println("Department: "
+ emp.getDepartment());
56
address=emp.getAddress();
57
System.out.println("City :"+address.getCity());
58
}
59
}
运行它:
当你运行SerializeDeserializeMain.java。你会得到这样的结果：
1
java.io.NotSerializableException: org.arpit.javapostsforlearning.Address
2
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
3
at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)
4
at java.io.ObjectOutputStream.writeSerialData(Unknown Source)
5
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
6
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
7
at java.io.ObjectOutputStream.writeObject(Unknown Source)
我们将解释哪里出错了。我忘记了说，Address 类也必须是serializable。那么Address类必须继承serialzable接口。
Address.java:
01
import java.io.Serializable;
02
03
public class
Addressimplements Serializable{
04
05
int
homeNo;
06
String street;
07
String city;
08
public
Address(int homeNo, String street, String city) {
09
super();
10
this.homeNo = homeNo;
11
this.street = street;
12
this.city = city;
13
}
14
public
int getHomeNo() {
15
return
homeNo;
16
}
17
public
void setHomeNo(int
homeNo) {
18
this.homeNo = homeNo;
19
}
20
public
String getStreet() {
21
return
street;
22
}
23
public
void setStreet(String street) {
24
this.street = street;
25
}
26
public
String getCity() {
27
return
city;
28
}
29
public
void setCity(String city) {
30
this.city = city;
31
}
32
}
再次运行:
当你再次运行SerializeDeserializeMain.java。你可以得到如下的结果
1
Deserialized Employee...
2
Emp id:101
3
Name: Arpit
4
Department: CS
5
City :Pune
案例2：如果我们不能访问引用对象的源代码(例如，你不能访问上面的Address类的源码)
如果我们不能访问到address类，那么我们该如何在Address类中实现serializable 接口？是否有另外的途径来实现呢？对的，你可以创建另外一个类，并继承Address，然后让它继承serializable 接口，但是对于下面的情况，这个方案会失败：
如果引用类被定义为final
如果引用类引用了另外一个非可序列化的对象
那么，我们该如何序列化Employee对象？解决的办法是，标记transient。如果你不需要序列化任何字段，只需把它标记为transient。
1
transient Address address
在Employee类中，标记了address为transient之后，运行程序。你会得到nullPointerException，因为在反序列化过程中，Address引用将会是null。
案例3 - 如果我仍然需要保存引用对象的状态呢？(例如address对象)
如果你在反序列化过程中，标记了address为transient，它将会返回null结果。但是如果你仍然需要保存它的状态，你就需要序列化address对象。 Java序列化提供一个机制，如果你有特定签名的private方法，那么它们就会在序列化和反序列化过程中被调用，所以我们将重写Employee类的writeObject和readObject方法，然后它们就会在Employee对象序列化/反序列化过程中被调用。
Employee.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.IOException;
03
import java.io.ObjectInputStream;
04
import java.io.ObjectOutputStream;
05
import java.io.Serializable;
06
07
public class
Employeeimplements Serializable{
08
09
int
employeeId;
10
String employeeName;
11
String department;
12
transient
Address address;
13
14
public
int getEmployeeId() {
15
return
employeeId;
16
}
17
public
void setEmployeeId(int
employeeId) {
18
this.employeeId = employeeId;
19
}
20
public
String getEmployeeName() {
21
return
employeeName;
22
}
23
public
void setEmployeeName(String employeeName) {
24
this.employeeName = employeeName;
25
}
26
public
String getDepartment() {
27
return
department;
28
}
29
public
void setDepartment(String department) {
30
this.department = department;
31
}
32
public
Address getAddress() {
33
return
address;
34
}
35
public
void setAddress(Address address) {
36
this.address = address;
37
}
38
39
private
void writeObject(ObjectOutputStream os)throws IOException, ClassNotFoundException
40
{
41
try
{
42
os.defaultWriteObject();
43
os.writeInt(address.getHomeNo());
44
os.writeObject(address.getStreet());
45
os.writeObject(address.getCity());
46
}
47
catch
(Exception e)
48
{ e.printStackTrace(); }
49
}
50
51
private
void readObject(ObjectInputStream is)throws IOException, ClassNotFoundException
52
{
53
try
{
54
is.defaultReadObject();
55
int
homeNo=is.readInt();
56
String street=(String) is.readObject();
57
String city=(String) is.readObject();
58
address=new
Address(homeNo,street,city);
59
60
}catch
(Exception e) { e.printStackTrace(); }
61
}
62
}
另外有一点需要牢记的，ObjectInputStream读取数据的顺序和ObjectOutputStream写入数据的顺序是一致的.
在包org.arpit.javapostsforlearning 中创建Address.java
Address.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.Serializable;
03
04
public class
Address {
05
06
int
homeNo;
07
String street;
08
String city;
09
10
11
public
Address(int homeNo, String street, String city) {
12
super();
13
this.homeNo = homeNo;
14
this.street = street;
15
this.city = city;
16
}
17
public
int getHomeNo() {
18
return
homeNo;
19
}
20
public
void setHomeNo(int
homeNo) {
21
this.homeNo = homeNo;
22
}
23
public
String getStreet() {
24
return
street;
25
}
26
public
void setStreet(String street) {
27
this.street = street;
28
}
29
public
String getCity() {
30
return
city;
31
}
32
public
void setCity(String city) {
33
this.city = city;
34
}
35
}
在包org.arpit.javapostsforlearning中创建SerializeDeserializeMain.java
SerializeDeserializeMain.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.FileInputStream;
03
import java.io.FileOutputStream;
04
import java.io.IOException;
05
import java.io.ObjectInputStream;
06
import java.io.ObjectOutputStream;
07
08
public class
SerializeDeserializeMain {
09
/**
10
* @author Arpit Mandliya
11
*/
12
public
static void main(String[] args) {
13
14
Employee emp =new Employee();
15
emp.setEmployeeId(101);
16
emp.setEmployeeName("Arpit");
17
emp.setDepartment("CS");
18
Address address=new
Address(88,"MG road","Pune");
19
emp.setAddress(address);
20
//Serialize
21
try
22
{
23
FileOutputStream fileOut =new FileOutputStream("employee.ser");
24
ObjectOutputStream outStream =new ObjectOutputStream(fileOut);
25
outStream.writeObject(emp);
26
outStream.close();
27
fileOut.close();
28
}catch(IOException i)
29
{
30
i.printStackTrace();
31
}
32
33
//Deserialize
34
emp =
null;
35
try
36
{
37
FileInputStream fileIn =new
FileInputStream("employee.ser");
38
ObjectInputStream in =new ObjectInputStream(fileIn);
39
emp = (Employee) in.readObject();
40
in.close();
41
fileIn.close();
42
}catch(IOException i)
43
{
44
i.printStackTrace();
45
return;
46
}catch(ClassNotFoundException c)
47
{
48
System.out.println("Employee class not found");
49
c.printStackTrace();
50
return;
51
}
52
System.out.println("Deserialized Employee...");
53
System.out.println("Emp id: "
+ emp.getEmployeeId());
54
System.out.println("Name: "
+ emp.getEmployeeName());
55
System.out.println("Department: "
+ emp.getDepartment());
56
address=emp.getAddress();
57
System.out.println("City :"+address.getCity());
58
}
59
}
运行 :
当你运行SerializeDeserializeMain.java.你会得到如下的结果：
1
Deserialized Employee...
2
Emp id:101
3
Name: Arpit
4
Department: CS
5
City :Pune
现在我们就得到了address对象的状态，就如它被序列化前的一样。
序列化中的继承：
现在我们看看继承是如何影响序列化的。不管父类是不是可序列化，这将引出很多个例子。如果父类是非可序列化的，我们将如何处理，并且它是如何工作的。让我们看看例子。
我们将创建一个Person.java，作为 Employee的父类。
案例4： 如果父类是可序列化的
如果父类可序列化，那么所有的继承类将是可序列化的。
案例5： 如果父类为非可序列化呢？
如果父类为非可序列化的 ，那么我们的处理办法会很不一样。
如果父类为非可序列化的，那么它必然不会有参数构造函数。
Person.java
01
package org.arpit.javapostsforlearning;
02
public class
Person {
03
04
String name="default";
05
String nationality;
06
07
public
Person()
08
{
09
System.out.println("Person:Constructor");
10
}
11
12
public
Person(String name, String nationality) {
13
super();
14
this.name = name;
15
this.nationality = nationality;
16
}
17
18
public
String getName() {
19
return
name;
20
}
21
22
public
void setName(String name) {
23
this.name = name;
24
}
25
26
public
String getNationality() {
27
return
nationality;
28
}
29
30
public
void setNationality(String nationality) {
31
this.nationality = nationality;
32
}
33
34
}
在包org.arpit.javapostsforlearning 中创建Employee.java
Employee.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.Serializable;
03
04
public class
Employeeextends Personimplements Serializable{
05
06
int
employeeId;
07
String department;
08
09
public
Employee(int employeeId,String name,String department,String nationality)
10
{
11
super(name,nationality);
12
this.employeeId=employeeId;
13
this.department=department;
14
System.out.println("Employee:Constructor");
15
}
16
17
public
int getEmployeeId() {
18
return
employeeId;
19
}
20
public
void setEmployeeId(int
employeeId) {
21
this.employeeId = employeeId;
22
}
23
24
public
String getDepartment() {
25
return
department;
26
}
27
public
void setDepartment(String department) {
28
this.department = department;
29
}
30
}
在org.arpit.javapostsforlearning包中创建SerializeDeserializeMain.java
SerializeDeserializeMain.java:
01
package org.arpit.javapostsforlearning;
02
import java.io.FileInputStream;
03
import java.io.FileOutputStream;
04
import java.io.IOException;
05
import java.io.ObjectInputStream;
06
import java.io.ObjectOutputStream;
07
08
public class
SerializeDeserializeMain {
09
10
/**
11
* @author Arpit Mandliya
12
*/
13
public
static void main(String[] args) {
14
15
//Serialize
16
Employee emp =new Employee(101,"Arpit","CS","Indian");
17
System.out.println("Before serializing");
18
System.out.println("Emp id: "
+ emp.getEmployeeId());
19
System.out.println("Name: "
+ emp.getName());
20
System.out.println("Department: "
+ emp.getDepartment());
21
System.out.println("Nationality: "
+ emp.getNationality());
22
System.out.println("************");
23
System.out.println("Serializing");
24
try
25
{
26
FileOutputStream fileOut =new FileOutputStream("employee.ser");
27
ObjectOutputStream outStream =new ObjectOutputStream(fileOut);
28
outStream.writeObject(emp);
29
outStream.close();
30
fileOut.close();
31
}catch(IOException i)
32
{
33
i.printStackTrace();
34
}
35
36
//Deserialize
37
System.out.println("************");
38
System.out.println("Deserializing");
39
emp =
null;
40
try
41
{
42
FileInputStream fileIn =new
FileInputStream("employee.ser");
43
ObjectInputStream in =new ObjectInputStream(fileIn);
44
emp = (Employee) in.readObject();
45
in.close();
46
fileIn.close();
47
}catch(IOException i)
48
{
49
i.printStackTrace();
50
return;
51
}catch(ClassNotFoundException c)
52
{
53
System.out.println("Employee class not found");
54
c.printStackTrace();
55
return;
56
}
57
System.out.println("After serializing");
58
System.out.println("Emp id: "
+ emp.getEmployeeId());
59
System.out.println("Name: "
+ emp.getName());
60
System.out.println("Department: "
+ emp.getDepartment());
61
System.out.println("Nationality: "
+ emp.getNationality());
62
}
63
}
运行：
当你运行SerializeDeserializeMain.java后，你会得到如下的输出，如果父类是非可序列化的，那么在反序列化过程中，所有继承于父类的实例变量值，将会通过调用非序列化构造函数来初始化。 这里 name继承于person，所以在反序列化过程中，name将会被初始化为默认值。
案例6 - 如果父类是可序列化，但你不需要继承类为可序列化
如果你不希望继承类为可序列化，那么你需要实现 writeObject() 和readObject() 方法，并且需要抛出NotSerializableException 异常。
案例7 - 可否序列化静态变量？
不能。因为静态变量是类级别的，不是对象级别的，当你序列化一个对象的时候，是不能序列化静态变量。
总结：
序列化是java对象的values/states转化为字节并在网络中传输或者保存它的过程。另外反序列化是把字节码翻译为对应的对象的过程。
序列化的好处是，JVM的独立性，也就是说，一个对象可以在一个平台中被序列化，然后在另外一个不同的平台反序列化。
如果你需要序列化任何对象，你必须实现标记接口Serializable。
Java中的标记接口(Marker interface)就是没有字段或者方法的接口，或者更简单的说，空接口
serialVersionUID 是用于保证同一个对象(在序列化中会被用到)可以在Deserialization过程中被载入。serialVersionUID 是用于对象的版本控制。
当你需要序列化任何包含引用对象的对象，那么Java会自动序列化该对象的整个对象图。
如果你不希望序列化某个字段，你可以标记它为trasient
如果父类为可序列化，那么它的继承类也将是可序列化的。
如果父类为非可序列化，那么在反序列化过程中，所有继承于父类的实例变量值将会通过调用非可序列化的构造器来初始化。
如果你需希望子类为可序列化的，那么你需要实现writeObject() 和 readObject() 方法，并在这两个方法中抛出NotSerializableException异常
你不能序列化静态变量。
java持久化 seri_Java 的序列化 (Serialization) 教程相关推荐
- Java之什么是序列化以及为什么要序列化
http://blog.csdn.net/tlycherry/article/details/8986720 序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,将数据分解成字 ...
- Java基础之对象序列化
概述 Java中的对象的内部状态只保存在内存中,其生命周期最长与JVM的生命周期一样,即JVM停止之后,所有对象都会被销毁.但有时候,Java对象是需要持久化的,因此Java提供了一种对象持久化方式- ...
- java Serializable和Externalizable序列化反序列化详解--转
一.什么是序列化? "对象序列化"(Object Serialization)是 Java1.1就开始有的特性. 简单地说,就是可以将一个对象(标志对象的类型)及其状态转换为字 ...
- 【译】Java中的对象序列化
前言 好久没翻译simple java了,睡前来一篇. 译文链接: http://www.programcreek.com/2014/01/java-serialization/ 什么是对象序列化 在 ...
- Java 结构体之 JavaStruct 使用教程一 初识 JavaStruct
Javastruct 是什么 简而言之,Javastruct 是一个第三方库,用于像处理 C 或者 C++ 结构体那样处理 java 对象.也即利用 Javastruct 可以在 java 上实现类似 ...
- Java kryo/protobuf/protostuff序列化 or Json 性能对比
Java kryo/protobuf/protostuff序列化 or Json 性能对比 - 腾飞的鹰 - 博客园 对于一个java object的序列化,想测一下使用json和使用一般序列化工具, ...
- 李兴华java视频在线观看_李兴华Java开发实战经典视频教程_IT教程网
资源名称:李兴华Java开发实战经典视频教程 资源目录: [IT教程网]010201_[第2章:简单Java程序]_简单Java程序 [IT教程网]010301_[第3章:Java基础程序设计]_Ja ...
- Java中的对象序列化操作
文章目录 1 Java中的对象序列化操作 1 Java中的对象序列化操作 首先看一下对象序列化的操作步骤: 创建一个类,继承Serializable接口 创建对象 将对象写入文件 从文件读取对象信息 ...
- Java中 byte[]数组序列化和fastjson序列化区别
Java中 byte[]数组序列化和fastjson序列化区别 Java中,对于对象可以通过序列化成byte数组或者序列化成json形式,这里做下两者的对比. 首先看下实现方式: 1 byte数组序列 ...
- Java 结构体之 JavaStruct 使用教程三 JavaStruct 数组进阶
经过前面两篇博客的介绍,相信对于 JavaStruct 的认识以及编程使用,读者已经有一定的基础了.只要理解和实践结合起来,掌握还是很容易的.下面进行一些数组使用方面的实例说明及演示. 在结构体类中使 ...
最新文章
- 工作中InnoDB引擎数据库主从复制同步心得
- 6种java垃圾回收算法_被说烂了的Java垃圾回收算法，我带来了最“清新脱俗”的详细图解...
- mvn install java版本,maven的打包命令--assemblyinstall和maven update之后jdk版本变回1.5的问题...
- 论__AlertDialog自定义布局回调修改的正确方式
- prd移动端通用产品需求文档+Axure高保真app社交订餐通用prd文档+产品业务说明+PRD功能性需求+移动端公工通用模板说明+需求分析+竞品分析+产品结构图+产品业务流程图+产品信息图+餐饮系统
- jQuery包裹节点用法完整示例
- ufs3.0和ufs2.1的区别体现在哪些方面？
- 并行 并发 多线程 区别
- SAP案例教程FIAA固定资产后台配置
- jquery提交表单错误
- java jpg转换tif_JAVA 实现jpg/tif/bmp 等图片之间格式得互相转换
- docker搭建searx_『颜值即正义』看小睿“自建搜索引擎”
- linux dot命令,linux绘图工具之dot
- qt轻松实现不规则按钮
- 困难时拉你一把的图片_在你遇到的困难时，总会有人拉你一把、你命中有这样的贵人吗？...
- 每个初学JAVA者都应该搞懂的问题
- 浙里办APP对接常见问题
- 我手写了个SLAM算法！
- 【樽海鞘算法】基于樽海鞘算法求解单目标问题附matlab代码(Salp Swarm Algorithm,SSA)
- 今日IBM ( IBM china / IGSC / ISSC / ETC )