之前给大家讲过java为什么需要序列化，这点相信大家都了解了，那么下面要继续给大家介绍的就是java序列化的作用方面的内容，一起来了解一下吧。
1、java序列化有什么用?
首先的话，java序列化会更有利于传输，它的速度会更快，并且也会更安全，被调用方序列化，调用方反序列化即能够得到传输之前的最原始的java对象，常常用来做不同进程之间的对象传输。
其次的话呢，就是能够更加便于储存，不论是存储成文件又或者是存储成数据库都是可以的，存储成文件，下回要用可以直接反序列拿到对象。
延伸阅读：
2、序列化是什么?
下面给大家简单的介绍一下序列化，通俗的来说的话，序列化就是处理对象流的一种机制，能够非常方便的保存内存当中，java对象的状态，同时也为了方便传输。
3、如何进行序列化和反序列化?
实现序列化接口就可以了(里面什么方法都没有，可以不用管，只是一个标记接口而已)Serializable。
4、注意事项介绍
在进行序列化的时候一定要注意一下几个方面的内容：
为了避免完全没有必要的报错麻烦，序列化的时候，最好是定义序列化版本id，也就是public static final Long
seriaVersionUID = 1L (默认)或者是 xxxxx L(自定义64位都可以)。
由于，反序列化会判断序列化中的id和类中的id是不是一致，假如，不定义虽然会自动生成，但是，假如后面改了东西列，所以说，还是自觉点定义一个id要好一些，可以省去非常多的麻烦。
与此同时要记住了，静态变量不会被序列化，它不在堆内存，序列化只会序列化堆内存。
以上的内容你都了解了吗?你还想了解更多和序列化相关的知识吗?更多和序列化相关的java基础知识，可以继续通过奇Q工具网来进行了解哦。
推荐阅读：

学习了这么久的java了，序列化这个概念好象感觉懂了，但总又感觉有点模糊，查阅了许多资料，觉得有必要总结并记录下来，使自己巩固一下。

序列化是什么：

　　序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。

　　序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例

　　序列化的什么特点：

　　如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。

　　什么时候使用序列化：

　　一：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

　　二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

　

　　可以看看接口java.io.serializable的中文解释：

　　Serializable

　　public interface Serializable

　　类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

　　要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。

　　在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。

　　当遍历一个图形时，可能会遇到不支持可序列化接口的对象。在此情况下，将抛出 NotSerializableException，并将标识不可序列化对象的类。

　　在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

　　private void writeObject(java.io.ObjectOutputStream out)

　　throws IOException

　　private void readObject(java.io.ObjectInputStream in)

　　throws IOException, ClassNotFoundException;

　　writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：

　　ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

　　此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。

　　在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。

　　ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

　　此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

　　序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的
 serialVersionUID：

　　ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

　　如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM)
 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类
 -- serialVersionUID 字段作为继承成员没有用处。

　　java.io.Serializable引发的问题——什么是序列化？在什么情况下将类序列化？

　　序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object
 obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

　　序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。

　　是对象永久化的一种机制。

　　确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。

　　只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。

　　对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面，另外就是在本机的存储。

　　对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口 。

　　*

　　Quote:

　　比较java.io.Externalizable和java.io.Serializable

　　[URL]http://www.zdnet.com.cn/developer/code/story/0,3800066897,39304080,00.htm[/URL]

　　即使你没有用过对象序列化（serialization），你可能也知道它。但你是否知道 Java 还支持另外一种形式的对象持久化，外部化（externalization）？

　　下面是序列化和外部化在代码级的关联方式：

　　public interface Serializable {}

　　public interface Externalizable extends Serializable {

　　void readExternal(ObjectInput in);

　　void writeExternal(ObjectOutput out);

　　}

　　序列化和外部化的主要区别

　　外部化和序列化是实现同一目标的两种不同方法。下面让我们分析一下序列化和外部化之间的主要区别。

　　通过Serializable接口对对象序列化的支持是内建于核心 API 的，但是java.io.Externalizable的所有实现者必须提供读取和写出的实现。Java 已经具有了对序列化的内建支持，也就是说只要制作自己的类java.io.Serializable，Java 就会试图存储和重组你的对象。如果使用外部化，你就可以选择完全由自己完成读取和写出的工作，Java 对外部化所提供的唯一支持是接口：

　　voidreadExternal(ObjectInput in)

　　void writeExternal(ObjectOutput out)

　　现在如何实现readExternal() 和writeExternal() 就完全看你自己了。

　　序列化会自动存储必要的信息，用以反序列化被存储的实例，而外部化则只保存被存储的类的标识。当你通过java.io.Serializable接口序列化一个对象时，有关类的信息，比如它的属性和这些属性的类型，都与实例数据一起被存储起来。在选择走Externalizable这条路时，Java 只存储有关每个被存储类型的非常少的信息。

　　每个接口的优点和缺点

　　Serializable接口

　　· 优点：内建支持

　　· 优点：易于实现

　　· 缺点：占用空间过大

　　· 缺点：由于额外的开销导致速度变比较慢

　　Externalizable接口

　　· 优点：开销较少（程序员决定存储什么）

　　· 优点：可能的速度提升

　　· 缺点：虚拟机不提供任何帮助，也就是说所有的工作都落到了开发人员的肩上。

　　在两者之间如何选择要根据应用程序的需求来定。Serializable通常是最简单的解决方案，但是它可能会导致出现不可接受的性能问题或空间问题；在出现这些问题的情况下，Externalizable可能是一条可行之路。

　　要记住一点，如果一个类是可外部化的（Externalizable），那么Externalizable方法将被用于序列化类的实例，即使这个类型提供了Serializable方法：

　　private void writeObject()

　　private void readObject()

Java序列化又称为“持久化”。指将某个特定的对象写入到磁盘中。序列化后的对象是以二进制字节码的形式存在的。

序列化的作用：
1、对象是生存在JVM进程中的，对象的生命周期一定比JVM生命周期短，当有些对象需要长久保存时，需要用到序列化，将对象存储起来。
2、进行网络传输时，数据只能按照二进制形式进行传输，所以需要先序列化为字节码，再进行传输。

什么对象能进行序列化操作：
1、String类、数组类型、Enum类型可以进行序列化
2、实现了Serializable接口的类可以进行序列化

基本序列化操作：
public class Alin implements Serializable{

	private static final long serialVersionUID = 1L;
	private int num;
	private String name;
	Alin(){
		num = 0;
		name = "a";
	}
	Alin(int num,String name){
		this.num = num;
		this.name = name;
	}
	@Override
	public String toString() {
		return "num: "+num+"name: "+name;
	}
}
public class SerTest {

	public static void main(String[] args) {
		try {
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
			Alin testA = new Alin(2,"b");
			oos.writeObject(testA);
			oos.close();
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
			Alin testB = (Alin)ois.readObject();
			System.out.println(testB);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

输出：num: 2name: b
可见，通过oos.writeObject(testA);可以进行序列化操作，通过Alin testB = (Alin)ois.readObject();可以实现反序列化操作。

序列化的控制：
1、被static transient 关键字修饰的成员不能被序列化。当反序列化时，会对这些成员赋默认值。
2、可以通过实现Externalizable方法而非Serializable来实现序列化的控制。Externalizable中多了两个方法的声明：
private void writeObject(ObjectOutputStream stream) throws IOException;
private void readObject(ObjectInputStream stream) throws IOException,ClassNotFoundException;
在我们进行序列化和反序列化时，在调用ObjectOutputStream.writeObject()或者ObjectInputStream.readObject()时，会发现该目标类已经写了两个对应方法，所以便会执行类中的这两个方法，从而实现只序列化自己想进行序列化的内容。
3、当要序列化的对象里包含另一个对象的引用时，序列化该对象，对象内的引用对应的对象也会被序列化，即序列化的是整个“对象网”，当然，如果该引用对应的对象类型没有继承Serializable接口的话，会报异常。即要序列化的对象内的所有引用都应该是继承了Serializable接口的。

简要叙述下java中串行第(序列化)的概念和作用，要让一个类能够序列化，应该怎么做？如要我想让谋此字段不被序列化又该怎么处理？
1.序列化是干什么的？
简单说就是为了保存内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种方法来保存Object States,但是java给你提供了一种应该更好的保存对象状态的机制，那就是序列化。
2.什么情况下需要序列化
a) 想要把内存中的对象保存到一个文件中或者数据库中时候
b)想用套接字在网络上传送对象的时候
c)想通过RMI传输对象的时候
要让一个类能够序列化，则必须要让这个类实现Serializable 接口,
如：
class User implements Serializable {
private String name;
private transient int age;
public User(String name,int age){
this.name=name;
this.age= age;
}
public void setName(String name){
this.name=name;
System.out.println(name);
}
public void setAge(){
this.age=age;
}
public int getAge(){
return age;
}
之后就可以保存内存中的对象了
如：
public class Test {
public static void main(String[] args) {
User user1=new User("zhangsan",33);
User user2 = new User("lisi",22);
User user3 = new User("wangwu",55);
try{
FileOutputStream fs = new FileOutputStream("C:/Users/bandly_li/Desktop/aa.txt");
ObjectOutputStream out= new ObjectOutputStream(fs);
out.writeObject(user1);
out.writeObject(user2);
out.writeObject(user3);
}catch(Exception e){
e.printStackTrace();
}
}
}
那如何读取文件中保存的对象呢？
如：
public class Test {
public static void main(String[] args) {
FileInputStream fis;
try {
fis = new FileInputStream("C:/Users/bandly_li/Desktop/aa.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
User user11 = (User) ois.readObject();
user11.setName("xxxxxxxxxxxxxxxxxxx");
System.out.println(user11.getAge());
} catch (Exception e) {
e.printStackTrace();
}
}
}
那如何对象中的某个字段不被序列化呢？
上面的User类中有age 属性就不能被序列化，因为它被transient 关键字修饰，
因此上面的输出结果：age 等于0;