对象的序列化
对象序列化就是把一个对象变为二进制数据流的一种方法。
一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。
先让我们实现一个具有序列化能力的类吧：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import java.io.*;
/** * 实现具有序列化能力的类
* */
public class SerializableDemo implements Serializable{
public SerializableDemo(){
}
public SerializableDemo(String name, int age){
this.name=name;
this.age=age;
}
@Override
public String toString(){
return "姓名："+name+" 年龄："+age;
}
private String name;
private int age;
} |
这个类就具有实现序列化能力，
在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类
先给一个ObjectOutputStream的例子吧：
|
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
|
import java.io.Serializable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/** * 实现具有序列化能力的类
* */
public class Person implements Serializable{
public Person(){
}
public Person(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "姓名：" + name + " 年龄：" + age;
}
private String name;
private int age;
}/** * 示范ObjectOutputStream
* */
public class ObjectOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File("d:" + File.separator + "hello.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
file));
oos.writeObject(new Person("rollen", 20));
oos.close();
}
} |
【运行结果】：
当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。
虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/** * ObjectInputStream示范
* */
public class ObjectInputStreamDemo{
public static void main(String[] args) throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectInputStream input = new ObjectInputStream(new FileInputStream(
file));
Object obj = input.readObject();
input.close();
System.out.println(obj);
}
} |
【运行结果】
姓名：rollen 年龄：20
到底序列化什么内容呢？
其实只有属性会被序列化。
Externalizable接口
被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。
当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。
现在我们来演示一下序列化和反序列话：
|
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
|
package IO;
import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
/** * 序列化和反序列化的操作
* */
public class ExternalizableDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
}
public static void ser() throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
file));
out.writeObject(new Person("rollen", 20));
out.close();
}
public static void dser() throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectInputStream input = new ObjectInputStream(new FileInputStream(
file));
Object obj = input.readObject();
input.close();
System.out.println(obj);
}
}class Person implements Externalizable{
public Person(){
}
public Person(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "姓名：" + name + " 年龄：" + age;
}
// 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
@Override
public void writeExternal(ObjectOutput out) throws IOException{
out.writeObject(this.name);
out.writeInt(age);
}
// 复写这个方法，根据需要读取内容 反序列话的时候需要
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException{
this.name = (String) in.readObject();
this.age = in.readInt();
}
private String name;
private int age;
} |
【运行结果】：
姓名：rollen 年龄：20
本例中，我们将全部的属性都保留了下来，
Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，
当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：
下面举一个例子：
|
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 IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/** * 序列化和反序列化的操作
* */
public class serDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
}
public static void ser() throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
file));
out.writeObject(new Person1("rollen", 20));
out.close();
}
public static void dser() throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectInputStream input = new ObjectInputStream(new FileInputStream(
file));
Object obj = input.readObject();
input.close();
System.out.println(obj);
}
}class Person1 implements Serializable{
public Person1(){
}
public Person1(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "姓名：" + name + " 年龄：" + age;
}
// 注意这里
private transient String name;
private int age;
} |
【运行结果】：
姓名：null 年龄：20
最后在给一个序列化一组对象的例子吧：
|
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
|
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/** * 序列化一组对象
* */
public class SerDemo1{
public static void main(String[] args) throws Exception{
Student[] stu = { new Student("hello", 20), new Student("world", 30),
new Student("rollen", 40) };
ser(stu);
Object[] obj = dser();
for(int i = 0; i < obj.length; ++i){
Student s = (Student) obj[i];
System.out.println(s);
}
}
// 序列化
public static void ser(Object[] obj) throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
file));
out.writeObject(obj);
out.close();
}
// 反序列化
public static Object[] dser() throws Exception{
File file = new File("d:" + File.separator + "hello.txt");
ObjectInputStream input = new ObjectInputStream(new FileInputStream(
file));
Object[] obj = (Object[]) input.readObject();
input.close();
return obj;
}
}class Student implements Serializable{
public Student(){
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return "姓名： " + name + " 年龄：" + age;
}
private String name;
private int age;
} |
【运行结果】：
姓名： hello 年龄：20
姓名： world 年龄：30
姓名： rollen 年龄：40
写在最后：本文章没有涉及java.nio，等我有时间，我自会补上的，欢迎大家关注我的博客，大家一起交流学习。
转自：http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html
相关推荐
以下是对Java IO的详细整理： 首先，Java中的`File`类是操作文件和目录的基础，它提供了许多方法来创建、删除、重命名文件以及检查文件属性。在案例1中，通过`new File("D:\\hello.txt")`创建了一个`File`对象，...
Java中IO系统总结[整理].pdf
Java中的IO流是Java平台核心特性之一，它用于在各种数据源之间传输数据，包括文件、设备、网络连接等。IO流分为输入流（Input Stream）和输出流（Output Stream），按照处理的数据类型又可以分为字节流和字符流。本...
JAVA_IO流整理思维导图.
在这个完整的Java IO整理版中，我们将深入探讨一些基本的IO概念和用法，主要包括文件操作、路径分隔符、文件删除、文件夹创建以及列出目录下的所有文件。 首先，创建新文件是Java IO中最基础的操作之一。在案例1中...
在Java中，IO复用允许一个线程同时处理多个连接的读写事件，从而避免了线程频繁地在睡眠和唤醒状态之间切换，提高了系统性能。 传统的并发编程模型通常与线程绑定，每个连接由一个独立的线程处理。虽然这种方法简单...
javaIO流整理.txt
### Java IO流分析、IO整理与IO优化 #### 一、IO流概念解析 Java中的文件操作主要通过**流**的方式进行。所谓流，是指在Java内存中的一组有序数据序列，它允许开发者以一种线性的方式处理数据，无论是从源（如文件...
Java io系统的设计初衷，就是为了实现“文件、控制台、网络设备”这些io设置的通信。例如，对于一个文件，我们...而到了java 1.1，为了与国际化进行接轨，在java io中添加了许多以字符(Unicode)为单位进行操作的类。
这个"j0601IO_chicken_Java-IO_prettyjtt_"标题可能指的是一个关于Java IO的学习资源，其中"chicken"可能是一个比喻，表示初学者或者新手，"prettyjtt"可能是创建或整理这个学习资料的人的昵称。"javax小菜鸡io"描述...
自己整理了一下javaIO流的相关知识点 用xmind软件做了一下
Java IO流思维导图，主要摘录整理的是java.io.*包下的所有IO对象，其中对应备注里包含各个IO对象的构造方法
Java多线程.drawio
在"Java常用代码整理"这个主题中，我们可以探讨多个Java编程中的关键知识点，包括基础语法、面向对象特性、异常处理、集合框架、IO流、多线程、网络编程以及实用工具类等。 1. **基础语法**：Java的基础语法包括...
Java NIO是Java语言中用于高性能I/O操作的API，理解IO模型是学习Java NIO的基础。本文将从同步和异步的概念开始，然后介绍阻塞和非阻塞的区别，接着介绍阻塞IO和非阻塞IO的区别，最后介绍五种IO模型和两种高性能IO...
Java的IO流体系是Java平台的核心特性之一，用于处理数据的输入和输出。这个体系结构设计得相当丰富和灵活，可以适应多种不同的场景。我们主要从两个方面来理解这个体系：对称性质和处理器模式。 首先，IO流的对称...
Java核心面试知识整理包括了对JVM内存区域、垃圾回收机制、GC算法、JVM类加载机制、Java集合框架以及Java IO/NIO等多个方面的深入讲解。以下是对这些知识点的详细介绍： JVM内存区域：JVM内存区域包括了程序计数器...
6. **java.io.File**：文件操作类，可以创建、删除、重命名文件，获取文件属性等。 7. **java.nio.file.***（Java 7及以上）：非阻塞I/O框架，包括`Path`、`Files`、`FileSystem`等，提供了更高效的文件操作。 8. ...
Java IO流是Java编程语言中一个非常重要的概念，它提供了数据传输的能力，使得程序能够读取和写入数据到各种输入/输出设备，如硬盘、内存、网络等。本资源包含的是Java-IO流的基础例题、源码及PPT教学文档，适合初学...