一、序列化

 
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在以后重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。
 

1、序列化

 
序列化就是将对象的整体状态信息保存到流中的操作。除了对象之外，枚举、字符串、数组等类型也是可以完成序列化操作的。

使用Java对象序列化保存对象时，会把对象的完整状态保存为一组字节，可以以后再将这些字节组装成对象。对象序列化保存的是对象的状态，即它的成员变量。而对象序列化不会关注类中的静态变量。
 

1.1、实现 java.io.Serializable 接口

 
在Java中，只要一个类想要被序列化，那么它就必须实现java.io.Serializable接口，否则就会报java.io.NotSerializableException异常。
只有支持java.io.Serializable接口的对象才能写入序列化的流中。

class Apple implements Serializable{private static final long serialVersionUID = 618121670541285584L;private String name;private int price;	public Apple(String name, int price) {super();this.name = name;this.price = price;}	public Apple() {super();}@Overridepublic String toString() {return "Apple [name=" + name + ", price=" + price + "]";}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}	
}

java.io.Serializable是一个标识接口，即意味着它仅仅是为了说明类的可序列化属性，接口没有包含任何需要子类实现的抽象方法。

public interface Serializable {
}

对象序列化过程不仅仅保存单个对象，还能追踪并保存对象中所包含的所有引用的对象（引用的对象必须实现Serializable接口）。

如果仅仅只是让某个类实现Serializable接口，而没有其它任何处理的话，则就是使用默认序列化机制。使用默认机制，在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其它对象也进行序列化，同样地，这些其它对象引用的另外对象也将被序列化，以此类推。所以，如果一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

在实际应用中，可能有些时候不能使用默认序列化机制，如：希望在序列化过程中忽略掉敏感数据 或者 简化序列化过程。

在ObjectOutputStream的源码中是通过instanceof运算符来判定操作的目标是否Serializable接口的实现类的对象。如果是就进行序列化处理。

 

2、反序列化

 
从流中读取对象整体状态信息的操作称为反序列化。

只能从流中读取实现java.io.Serializable或java.io.Externalizable接口的对象。

对于Serializable反序列化后的对象，不需要调用构造方法重新构造，对象完全以它存储的二进制位作为基础来构造，而不调用构造方法。

可以使用Java提供的工具ObjectInputStream的readObject()来完成反序列化。readObject()方法负责读取通过相应的writeObject方法写入流的数据，并恢复其特定类的对象的状态。

public final Object readObject() throws IOException,ClassNotFoundException：从ObjectInputStream读取一个对象。

• 实现反序列化过程的代码

public class TestReverseApple {public static void main(String[] args) throws IOException, ClassNotFoundException {FileInputStream fis = new FileInputStream("E://apple.ini");ObjectInputStream ois = new ObjectInputStream(fis);Object obj = ois.readObject();System.out.println(obj);if (obj instanceof Apple) {		Apple a = (Apple)obj;System.out.println("反序列化成功");}}
}

 

3、serialVersionUID

 
serialVersionUID是串行化版本统一标识符（serial version universal identifier），简称UID。JAVA序列化的机制是通过判断类的serialVersionUID来验证的版本一致的。

private static final long serialVersionUID = 6181216710541285584L;

序列化操作时会把系统当前类的serialVersionUID写入到序列化文件中，当反序列化时系统会自动检测文件中的serialVersionUID，判断它是否与当前本地相应实体类的serialVersionUID一致。如果一致说明序列化文件的版本与当前类的版本是一样的，可以进行反序列化，否则会出现java.io.InvalidClassException异常。

serialVersionUID有两种显示的生成方式：
（1）默认的UID是1L，如：private static final long serialVersionUID = 1L; 。

（2）UID可以是根据包名、类名、继承关系、非私有的方法和属性、参数、返回值等诸多因子计算得出的一个极度复杂的64位哈希字段，如：private static final long serialVersionUID = xxxxL;。基本上计算出来的这个值是唯一的，改动上述任意一项内容（无论是增加或删除），都会引起编码值变化，从而引起类似的异常警报。

注意：显示声明serialVersionUID可以避免对象不一致。如果我们不显式提供serialVersionUID的值，则Java会进行自动计算生成serialVersionUID，只要改动类中的任意一项内容，都会引起编码值变化，从而引起类似的异常警报。解决这个问题的办法是在类中显示声明serialVersionUID，强制类仍旧使用原来的UID。

可以使用Java提供的工具ObjectOutputStream的方法 writeObject(Serializable obj)来完成序列化。

public final void writeObject(Object obj) throws IOException：将指定的对象写入ObjectOutputStream。

• 实现序列化过程的代码（通过抛出异常的方式来处理异常）

public class TestApple {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("E://apple.ini");ObjectOutputStream oos = new ObjectOutputStream(fos);Apple apple1 = new Apple("iphone12", 20000);oos.writeObject(apple1);oos.close();fos.close();}
}

• 实现序列化过程的代码（使用try/catch语句处理异常）

public class TestApple {public static void main(String[] args) {FileOutputStream fos = null;ObjectOutputStream oos = null;try {fos = new FileOutputStream("E://apple.ini");oos = new ObjectOutputStream(fos);Apple apple1 = new Apple("iphone12",20000);oos.writeObject(apple1);System.out.println("序列化成功");} catch (IOException e) {e.printStackTrace();} finally {try {if(oos != null) {oos.close();}} catch (IOException e) {e.printStackTrace();}try {if(fos != null) {fos.close();}} catch (IOException e) {e.printStackTrace();}}}
}

 

4、transient关键字

 
当某个字段使用 transient 关键字修饰后，默认序列化机制就会忽略该字段。

	private transient String name;

反序列出来的结果为：Apple [name=null, price=20000]
 
 
使用transient修饰的字段能被序列化的方法：

（1）将 transient 关键字去掉。

（2）在当前的实体类中添加两个方法让 使用transient修饰的字段 能被序列化：
writeObject()与readObject()。

	private void writeObject(ObjectOutputStream out) throws IOException {out.defaultWriteObject();//调用该方法将执行标准序列化过程out.writeUTF(name);}private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {in.defaultReadObject();//调用该方法将执行标准反序列化过程name = in.readUTF();}

 

二、Java NIO

 
Java NIO的缓冲导向方法是将数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，增加了处理过程中的灵活性。

Buffer（缓冲区）：缓冲区本质上是一块可以写入数据，也可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的进行访问。

Channel（通道）：通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。通道可以异步地读写。

Java NIO中的Buffer（缓冲区）用于和Channel（通道）进行交互。数据是从通道读入缓冲区，再从缓冲区写入到通道中的。

• 利用NIO进行文件拷贝（通过抛出异常来处理异常）

public class TestNio {public static void main(String[] args) throws IOException {copyFile("D://a.txt", "E://b.txt");}public static void copyFile(String srcPath,String destPath) throws IOException {//创建输入流的对象FileInputStream fis = new FileInputStream(srcPath);//创建输出流的对象FileOutputStream fos = new FileOutputStream(destPath);//输入流对象的getChannel方法，获取FileChannel对象FileChannel inchannel = fis.getChannel();//输出流对象的getChannel方法，获取FileChannel对象FileChannel outchannel = fos.getChannel();//transferTo：将该通道文件的字节传输到给定的可写字节通道。inchannel.transferTo(0, inchannel.size(), outchannel);//关闭流与通道inchannel.close();outchannel.close();fis.close();fos.close();	System.out.println("文件复制成功");}
}

• 利用NIO进行文件拷贝（使用try/catch语句处理异常）

public class TestNio {public static void main(String[] args) throws IOException {copyFile("D://a.txt", "E://b.txt");}public static void copyFile(String srcPath,String destPath) {//创建输入流的对象FileInputStream fis = null;FileOutputStream fos = null;FileChannel inchannel = null;FileChannel outchannel = null;try {fis = new FileInputStream(srcPath);//创建输出流的对象fos = new FileOutputStream(destPath);//输入流对象的getChannel方法，获取FileChannel对象inchannel = fis.getChannel();//输出流对象的getChannel方法，获取FileChannel对象outchannel = fos.getChannel();//transferTo：将该通道文件的字节传输到给定的可写字节通道。 inchannel.transferTo(0, inchannel.size(), outchannel);} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {//关闭流与通道try {if(inchannel != null)inchannel.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(outchannel != null)outchannel.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(fis != null)fis.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {if(fos != null)fos.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}	System.out.println("文件复制成功");}
}

 

三、NIO和IO之间的区别

 
NIO和IO之间最大的区别是：IO是面向流的，NIO是面向块（缓冲区）的。

IO面向流，每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方，它不能前后移动流中的数据。

NIO面向块，会将数据读取到一个缓冲区，需要时可在缓冲区中前后移动，增加了处理过程中的灵活性。

NIO既可以从通道中读取数据，又可以写数据到通道。但IO的读写通常是单向的。

NIO 通道可以异步地读写。

NIO 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。