标准序列化机制
简单来说，序列化就是将对象转化为字节流，反序列化就是将字节流转化为对象。
基本用法
要让一个类支持序列化，只需要让这个类实现接口java.io.Serializable。Serializable没有定义任何方法，只是一个标记接口。比如，对于前面章节提到的Student类，为支持序列化，可改为：
public class Student implements Serializable {
//省略主体代码
}
声明实现了Serializable接口后，保存/读取Student对象就可以使用ObjectOutputStream/ObjectInputStream流了。ObjectOutputStream是OutputStream的子类，但实现了ObjectOutput接口。ObjectOutput是DataOutput的子接口，增加了一个方法：
public void writeObject(Object obj) throws IOException
这个方法能够将对象obj转化为字节，写到流中。ObjectInputStream是InputStream的子类，它实现了ObjectInput接口。ObjectInput是DataInput的子接口，增加了一个方法：
public Object readObject() throws ClassNotFoundException, IOException
这个方法能够从流中读取字节，转化为一个对象。
使用这两个流，保存学生列表的代码就可以变为：
public static void writeStudents(List<Student> students) throws IOException {
ObjectOutputStream out = new ObjectOutputStream(
new BufferedOutputStream(new FileOutputStream("students.dat")));
try {
out.writeInt(students.size());
for(Student s : students) {
out.writeObject(s);
}
} finally {
out.close();
}
}
而从文件中读入学生列表的代码可以变为：
public static List<Student> readStudents() throws IOException,
ClassNotFoundException {
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
new FileInputStream("students.dat")));
try {
int size = in.readInt();
List<Student> list = new ArrayList<>(size);
for(int i = 0; i < size; i++) {
list.add((Student) in.readObject());
}
return list;
} finally {
in.close();
}
}
实际上，只要List对象也实现了Serializable（ArrayList/LinkedList都实现了），上面代码可以进一步简化，读写只需要一行代码，如下所示：
public static void writeStudents(List<Student> students) throws IOException {
ObjectOutputStream out = new ObjectOutputStream(
new BufferedOutputStream(new FileOutputStream("students.dat")));
try {
out.writeObject(students);
} finally {
out.close();
}
}
public static List<Student> readStudents() throws IOException, ClassNotFoundException {
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream("students.dat")));
try {
return (List<Student>) in.readObject();
} finally {
in.close();
}
}
只要将类声明实现Serializable接口，然后就可以使用ObjectOutput-Stream/ObjectInputStream直接读写对象了。我们之前介绍的各种类，如String、Date、Double、ArrayList、LinkedList、HashMap、TreeMap等，都实现了Serializable。
复杂对象
上面例子中的Student对象时非常简单的，如果对象比较复杂呢？比如：
- 如果a、b两个对象都引用同一个对象c，序列化后c是保存两份还是一份？在徐丽丽恶化后还能让a、b指向同一个对象吗？答案是，c只会保存一份，反序列化后指向相同对象。
- 如果a、b两个对象有循环引用呢？即a引用了b，而b也引用了a。这种情况Java也没问题，可以保持引用关系。
这就是Java序列化机制的神奇之处，它能自动处理引用同一个对象的情况，也能自动处理循环引用的情况。
定制序列化
默认的序列化机制已经很强大了，它可以自动将对象中的所有字段自动保存和恢复，但这种默认行为有时候不是我们想要的。
对于有些字段，它的值可能与内存位置有关，比如默认的hashCode()方法的返回值，当恢复对象后，内存位置肯定变了，基于原内存位置的值也就没有了意义。还有一些字段，可能与当前时间有关，比如表示对象创建时的时间，保存和恢复这个字段就是不正确的。
还有一些情况，如果类中的字段表示的是类的实现细节，而非逻辑信息，那默认序列化也是不适合的。为什么不适合呢？因为序列化格式表示一种契约，应该描述类的逻辑结构，而非与实现细节相绑定，绑定实现细节将使得难以修改，破坏封装。
比如，我们在容器类中介绍的LinkedList，它的默认序列化就是不适合的。为什么呢？因为LinkedList表示一个List，它的逻辑信息是列表的长度，以及列表中的每个对象，但LinkedList类中的字段表示的是链表的实现细节，如头尾节点指针，对每个节点，还有前驱和后继节点指针等。
那怎么办呢？Java提供了多种定制序列化的机制，主要的有两种：一种是transient关键字，另外一种是实现writeObject和readObject方法。
将字段声明为transient，默认序列化机制将忽略该字段，不会进行保存和恢复。比如，类LinkedList中，它的字段都声明为了transient，如下所示：
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
声明为了transient，不是说就不保存该字段了，而是告诉Java默认序列化机制，不要自动保存该字段了，可以实现writeObject/readObject方法来自己保存该字段。
类可以实现writeObject方法，以自定义改了对象的序列化过程，其声明必须为：
private void writeObject(java.io.ObjectOutputStream s) throws IOException
可以在这个方法中，调用ObjectOutputStream的方法向流中写入对象的数据。比如，LinkedList使用如下代码序列化列表的逻辑数据：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
//写元素个数
s.writeInt(size);
//循环写每个元素
for(Node<E> x = first; x ! = null; x = x.next)
s.writeObject(x.item);
}
需要注意的是代码：
s.defaultWriteObject();
这一行是必须的，它会调用默认的序列化机制，默认机制会保存所有没声明为transient的字段，即使类中的所有字段都是transient，也应该写这一行，因为Java的序列化机制不仅会保存纯粹的数据信息，还会保存一些元数据描述等隐藏信息，这些隐藏的信息是序列化之所以能够神奇的重要原因。
与writeObject对应的是readObject方法，通常它自定义反序列化过程，其声明必须为：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException
在这个方法中，调用ObjectInputStream的方法从流中读入数据，然后初始化类中的成员变量。比如，LinkedList的反序列化代码为：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
//读元素个数
int size = s.readInt();
//循环读入每个元素
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
注意代码：
s.defaultReadObject();
这一行代码也是必需的。
除了自定义writeObject/readObject方法，还有一些自定义序列化过程的机制：Exter-nalizable接口、readResolve方法和writeReplace()方法，这些机制用的相对较少，我们就不介绍了。
序列化的基本原理
稍微总结一下。
- 如果类的字段表示的就是类的逻辑信息，如上面的Student类，那就可以使用默认序列化机制，只要声明实现Serializable接口即可。
- 否则的话，如LinkedList，那就可以使用transient关键字，实现writeObject和read-Object自定义序列化过程。
- Java的序列化机制可以自动处理如引用同一个对象、循环引用等情况。
序列化到底是如何发生的呢？关键在ObjectOutputStream的writeObject和ObjectInput-Stream的readObject方法内。它们的实现都非常复杂，正因为这些复杂的实现才使得序列化看上去很神奇，我们简单介绍其基本逻辑。
writeObject的基本逻辑是：
- 如果对象没有实现Serializable，抛出异常NotSerializableException。
- 每个对象都有一个编号，如果之前已经写过该对象了，则本次只会写该对象的引用，这可以解决对象引用和循环引用的问题。
- 如果对象实现了writeObject方法，调用它的自定义方法。
- 默认是利用反射机制（反射在第21章介绍），遍历对象结构图，对每个没有标记为transient的字段，根据其类型，分别进行处理，写出到流，流中的信息包括字段的类型，即完整类名、字段名、字段值等。
readObject的基本逻辑是：
- 不调用任何构造方法；
- 它自己就相当于是一个独立的构造方法，根据字节流初始化对象，利用的也是反射机制；
- 在解析字节流时，对于引用到的类型信息，会动态加载，如果找不到类，会抛出ClassNotFoundException。
序列化特点分析
序列化的主要用途有两个：一个是对象持久化；另一个是跨网络的数据交换、远程过程调用。Java标准的序列化机制有很多优点，使用简单，可自动处理对象引用和循环引用，也可以方便地进行定制，处理版本问题等，但它也有一些局限性。
- Java序列化格式是一种私有格式，是一种Java特有的技术，不能被其他语言识别，不能实现跨语言的数据交换。
- Java在序列化字节中保存了很多描述信息，使得序列化格式比较大。
- Java的默认序列化使用反射分析遍历对象结构，性能比较低。
- Java的序列化格式是二进制的，不方便查看和修改。
由于这些局限性，实践中往往会使用一些替代方案。在跨语言的数据交换格式中，ⅩML/JSON是被广泛采用的文本格式，各种语言都有对它们的支持，文件格式清晰易读。有很多查看和编辑工具，它们的不足之处是性能和序列化大小，在性能和大小敏感的领域，往往会采用更为精简高效的二进制方式，如ProtoBuf、Thrift、MessagePack等。
Java编程练习
使用I/O流生成Word文件
在日常生活中，我们使用最多的就是Word文件，很多我们日常的文稿都需要使用Word文件来进行编辑和保存。那么我们能不能使用Java程序来实现Word文件的生成操作呢？答案是肯定的。本实例就是一个使用Java程序生成Word文件的例子。
1.
新建项目GenerateWord，并在其中创建一个GenerateWord.java文件。在该类中引入iText包来生成Word文件，并在该文件中生成文字和表格：
package GenerateWord;
import com.lowagie.text.*;
import com.lowagie.text.Font;
import com.lowagie.text.pdf.BaseFont;
import com.lowagie.text.rtf.RtfWriter2;
import java.awt.*;
import java.io.FileOutputStream;
import java.io.IOException;
public class GenerateWord { // 用iText生成word文件
public void createDocFile(String file) throws DocumentException,
IOException {
Document document = new Document(PageSize.A4); // 设置纸张大小
// 建立一个书写器(writer)与document对象关联，通过书写器(writer)可以将文档写入到磁盘中
RtfWriter2.getInstance(document, new FileOutputStream(file));
document.open();
BaseFont macintosh = BaseFont.createFont ("C:\\wINDOwS\\Fonts\\STFANGSO.TTF",
BaseFont.IDENTITY_H, BaseFont.EMBEDDED); // 设置中文字体
Font ThemeFont = new Font(macintosh, 18, Font.BOLD);// 标题字体风格
ThemeFont.setColor(Color.RED); // 设置标题字体的颜色
Font bodyFont = new Font(macintosh, 14, Font.NORMAL);// 正文字体风格
bodyFont.setColor(56, 94, 15); // 设置正文字体的颜色
Paragraph theme = new Paragraph("主标题"); // 创建主题的Phrases对象
theme.setAlignment(Element.ALIGN_CENTER);// 将设置好的字体添加到主题的短句上
document.add(theme); // 将Phrases添加到document文档中
String bodyText = "这是一个word文档"; // 设置word正文中的内容
Paragraph context = new Paragraph(bodyText); // 创建正文的Phrases对象
context.setAlignment(Element.ALIGN_LEFT); // 正文格式左对齐
context.setSpacingBefore(3); // 离上一段落（标题）空的行数
context.setFirstLineIndent(20); // 设置第一行空的列数
document.add(context); // 将Phrases添加到document文档中
// 利用类FontFactory结合Font和Color可以设置各种各样字体样式
Paragraph line = new Paragraph("下画线的实现", FontFactory.getFont(
FontFactory.HELVETICA_BOLDOBLIQUE, 18, Font.UNDERLINE,
new Color(0, 0, 255)));
document.add(line);
// 创建Table表格
Table table = new Table(5); // 创建该表格的列数，在本程序中设为5列
int width[] = { 25, 25, 25, 25, 25 }; // 每列的单元格的宽度;
table.setWidths(width); // 设置每列所占比例
table.setWidth(90); // 占页面宽度90%
table.setAlignment(Element.ALIGN_CENTER);
// 设置该表格中的元素水平方向居中显示
table.setAlignment(Element.ALIGN_MIDDLE);// 设置表格中的元素垂直方向纵向居中显示
table.setAutoFillEmptyCells(true); // 自动填满
table.setBorderWidth(1); // 边框宽度
table.setBorderColor(new Color(160, 32, 240)); // 边框颜色
table.setPadding(2); // 单元格内部的空白距离，相当于html中的cellpadding属性
table.setSpacing(3); //单元格之间的间距，相当于html中的cellspacing
table.setBorder(2); // 边框的宽度
// 设置表头
Cell haderCell = new Cell("用iText创建的表格-表头"); // 创建单元格
haderCell.setBackgroundColor(Color.pink); // 设置此单元格的背景色
haderCell.setHeader(true); // 设置为表头
haderCell.setColspan(5); // 合并列的列数
haderCell.setHorizontalAlignment(haderCell.ALIGN_CENTER);// 水平显示的位置
table.addCell(haderCell); // 将单元格添加到表格中
table.endHeaders(); // 结束表头的设置
Font fontChinese = new Font(macintosh, 15, Font.NORMAL, Color.blue);
// 设置字体风格
Cell cell = new Cell(new Phrase("这是一个3行1列合并的表格", fontChinese));
// 创建单元格
cell.setVerticalAlignment(Element.ALIGN_TOP);
cell.setBorderColor(new Color(255, 215, 0));
cell.setRowspan(3); // 设置合并的行数
// 添加单元格
table.addCell(cell);
for (int i = 0; i < 12; i++) {
table.addCell(new Cell(i+""));
}
// 创建一个合并5列的单元格
Cell cell3 = new Cell(new Phrase("一行5列合并的表格", fontChinese));
cell3.setColspan(5);
cell3.setVerticalAlignment(Element.ALIGN_CENTER);
table.addCell(cell3);
document.add(table);
document.close();
}
public static void main(String[] args) {
GenerateWord word = new GenerateWord();
String file = "D:/word.doc";
try {
word.createDocFile(file);
} catch (DocumentException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行程序，生成文件如下：
使用I/O流生成Excel文件
Excel文件在我们的生活中也起到了非常广泛的作用，比如财务报表、工资清单等。本实例我们将为大家展示如何使用Java的输入/输出实现Excel文件的生成操作。
1.
新建项目GenerateExcel，并在其中创建一个GenerateExcel.java文件。在该类中首先引入org.apache.poi包，然后通过其中的hssf类来实现Excel文件的生成：
package GenerateExcel;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.util.CellRangeAddress;
import java.io.*;
public class GenerateExcel { //创建Excel文件
// 新建一个Excel文件，里面添加5行5列的内容，另外添加两个合并大单元格
public void createExcel(String fileName) {
File file = new File(fileName); // 创建excel文件对象
FileOutputStream fOut = null;
try {
HSSFWorkbook workbook = new HSSFWorkbook();
// 创建一个新的HSSFworkbook对象
HSSFSheet sheet = workbook.createSheet("myFirstExcel");
// 创建一个Excel的工作表
HSSFFont font = workbook.createFont(); // 创建字体，红色、粗体
font.setColor(HSSFFont.COLOR_RED);
font.setBold(true);
HSSFFont font1 = workbook.createFont();
font1.setColor(HSSFFont.COLOR_NORMAL); // 创建字体，黑色、非粗体
font1.setBold(false);
HSSFCellStyle cellStyle = workbook.createCellStyle();
// 创建单元格的格式，如居中、左对齐等
cellStyle.setAlignment(HorizontalAlignment.CENTER);// 水平方向上居中对齐
// 垂直方向上居中对齐
cellStyle.setFont(font); // 设置字体
HSSFCellStyle cellStyle1 = workbook.createCellStyle();
cellStyle1.setAlignment(HorizontalAlignment.LEFT);
cellStyle1.setFont(font1);
// 下面将建立一个4行3列的表。第一行为表头
int rowNum = 0; // 行标
int colNum = 0; // 列标
// 建立表头信息
HSSFRow row = sheet.createRow((short) rowNum); // 在索引0的位置创建行
HSSFCell cell = null; // 单元格
for (colNum = 0; colNum < 5; colNum++) {
cell = row.createCell((short) colNum);
// 在当前行的colNum列上创建单元格
cell.setCellType(Cell.CELL_TYPE_STRING);
// 定义编码方式，为了支持中文，这里使用了ENCODING_UTF_16
cell.setCellStyle(cellStyle); // 为单元格设置格式
cell.setCellValue("表头-第" + (colNum + 1) + "列");
// 添加内容至单元格
}
rowNum++;
for (; rowNum < 5; rowNum++) {
row = sheet.createRow((short) rowNum); // 新建第rowNum行
for (colNum = 0; colNum < 5; colNum++) {
cell = row.createCell((short) colNum);
// 在当前行的colNum位置创建单元格
cell.setCellStyle(cellStyle1);
cell.setCellValue("表体-第" + rowNum + "行第" + (colNum + 1)
+ "列");
}
}
rowNum = 5; // 合并单元格
for (; rowNum < 9; rowNum++) {
row = sheet.createRow((short) rowNum);
for (colNum = 0; colNum < 5; colNum++) {
cell = row.createCell((short) colNum); // 在当前行的colNum位置创建单元格
}
}
rowNum = 5; // 建立第一个大单元格，高度为2，宽度为2
colNum = 0;
CellRangeAddress region = new CellRangeAddress(rowNum, (rowNum + 1), (short) colNum,
(short) (colNum + 4));
sheet.addMergedRegion(region);
cell = sheet.getRow(rowNum).getCell((short) colNum);// 获得第一个大单元格
cell.setCellStyle(cellStyle);
cell.setCellValue("合并行单元格");
rowNum = 7; // 建立第二个大单元格，高度为2，宽度为3
for (colNum = 0; colNum < 5; colNum++) {
region = new CellRangeAddress(rowNum, (rowNum + 1), (short) colNum,
(short) (colNum));
sheet.addMergedRegion(region);
cell = sheet.getRow(rowNum).getCell((short) colNum);
// 获得第二个大单元格
cell.setCellStyle(cellStyle);
cell.setCellValue("合并列单元格");
}
fOut = new FileOutputStream(file); // 新建一输出文件流
workbook.write(fOut);// 将创建的内容写到指定的Excel文件中
fOut.flush();
fOut.close(); // 操作结束，关闭文件
System.out.println("Excel文件创建成功！\nExcel文件的存放路径为："
+ file.getAbsolutePath());
} catch (Exception e) {
System.out.println("Excel文件" + file.getAbsolutePath()
+ "创建失败\n其原因为：" + e);
} finally {
if (fOut != null) {
try {
fOut.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String[] args) throws Exception {
GenerateExcel excel = new GenerateExcel();
String fileName = "D://Excel.xls"; // 指定生成Excel文件名称
excel.createExcel(fileName);
}
}
运行程序，生成文件内容如下：
