流的分类
- 按照流向分为输入流与输出流。
- 按照传输单位分为字符流与字节流。
- 按照功能分为节点流（低级流）和过滤流（高级流）。
下图为Java文件流按照传输单位的分类图：
其中BufferedInputStream是带缓冲区的输入流，默认缓冲区大小为8M，可以提高文件读取的性能；BufferedOutputStream是带缓冲区的输出流，能够提高文件的写入效率。BufferedInputStream与BufferedOutputStream分别继承于FilterInputStream与FilterOutputStream。
流的操作流程
- 确定操作资源
- 确定具体的操作流
- 进行流的读/写操作
- 关闭流资源
字节流读写文件代码如下：
public static void controlFileByByte(String filePath) {
//1. 确定操作资源
File file = new File(filePath);
//2. 确定具体的操作流
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(file);
fos = new FileOutputStream("d:/work/readFileByCharacter.txt");
int temp = 0;
//3. 进行流的读/写操作
while ((temp = fis.read()) != -1) {
fos.write((char) temp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {//4. 关闭流资源
try {
if (fis != null) {
fis.close();
}
if (fos != null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流读写文件的操作代码与字节流一致，区别在于读写流的不同。
字节缓冲流的操作代码如下：
public static void controlFileByBufferChar(String filePath) {
File file = new File(filePath);
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(file));
bos = new BufferedOutputStream(new FileOutputStream("d:/work/readFileByCharacter.txt"));
byte[] b = new byte[1024];
int temp = 0;
while ((temp = bis.read(b)) != -1) {
bos.write(b, 0, temp);
bos.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bis != null) {
bis.close();
}
if (bos != null) {
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流的缓冲流操作代码与字节流缓冲流代码基本一致，只是字符流读取时可以使用按行读取，代码如下：
public static void controlFileByBufferByte(String filePath) {
File file = new File(filePath);
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader(file));
bw = new BufferedWriter(new FileWriter("d:/work/readFileByCharacter.txt"));
String temp;
while ((temp = br.readLine()) != null) {
bw.write(temp + "\n");
bw.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
随机访问文件
RandomAccessFile类对象可以进行随机文件访问，可以在文件中的任意位置读取或写入。RandomAccessFile类不在InputStream和OutputStream的类层次结构中。
模式
可以在四种不同的访问模式中创建随机访问文件。访问模式是一个字符串。列出如下：
| 模式 | 含义 |
|---|---|
| “r” | 文件以只读模式打开 |
| “rw” | 文件以读写模式打开。如果文件不存在，则创建该文件。 |
| “rws” | 文件以读写模式打开。对文件的内容及其元数据的任何修改立即被写入存储设备。 |
| “rwd” | 文件以读写模式打开。对文件内容的任何修改立即写入存储设备。 |
随机访问文件读写代码如下：
public static void main(String[] args) {
String fileName = "randomFile";
File file = new File(fileName);
if (!file.exists()) {
initWrite(fileName);
}
readFile(fileName);
readFile(fileName);
}
public static void readFile(String fileName) {
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(fileName, "rw");
int i = raf.readInt();
String s = raf.readUTF();
System.out.println(i);
System.out.println(s);
incrementReadCounter(raf);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (raf != null)
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void incrementReadCounter(RandomAccessFile raf) {
long currentPosition = 0;
try {
currentPosition = raf.getFilePointer();
raf.seek(0);
int counter = raf.readInt();
counter++;
raf.seek(0);
raf.writeInt(counter);
raf.seek(currentPosition);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void initWrite(String fileName) {
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(fileName, "rw");
raf.writeInt(0);
raf.writeUTF("Hello World!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf != null) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
以上代码输出结果为：
0
Hello World!
1
Hello World!
Java序列化相关知识
将Java对象序列化为二进制文件的Java序列化技术是Java系列技术中一个较为重要的技术点，在大部分情况下，开发人员只需要了解被序列化的类需要实现Serializable接口，使用ObjectInputStream和ObjectOutputStream进行对象的读写。然而在有些情况下，光知道这些是不够的，以下情景介绍了Java序列化中的一些高级认识。
序列化Id问题
虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化ID是否一致。序列化ID有两种生成策略，一个是有人为指定为固定的数值（如1L），一个是随机生成一个不重复的long类型数据（实际由JDK工具生成）。在此建议，如果没有特殊需求，则人为指定一个固定值为序列化ID，这样可以确保代码一致时反序列化的成功。
静态变量序列化
public class Test implements Serializable {
private static final long serialVersionUID = 1L;
public static int staticVar = 5;
public static void main(String[] args) {
try {
//初始时staticVar为5
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("result.obj"));
out.writeObject(new Test());
out.close();
//序列化后修改为10
Test.staticVar = 10;
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
Test t = (Test) oin.readObject();
oin.close();
//再读取，通过t.staticVar打印新的值
System.out.println(t.staticVar);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
如上代码，最终打印的值是多少呢？答案是10。为什么呢？因为对象在序列化时并不保存静态变量，序列化保存的是对象的状态，静态变量属于类的状态，因此序列化并不保存静态变量。
父类的序列化与Transient关键字
想要将父类对象也序列化，就需要让父类也实现Serializable接口。如果父类不实现的话，就要有无参的构造方法。在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。
Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
对敏感字段进行加密
服务端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码等字段，希望对密码字段在序列化时进行加密，而客户端如果有解密的密钥，在客户端反序列化时进行解密，这样可以一定程度保证序列化对象的数据安全。
在序列化过程中，虚拟机会试图调用对象类里的writeObject和readObject方法，进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用ObjectOutputStream的defaultWriteObject方法及ObjectInputStream的defaultReadObject方法。用户自定义的writeObject和readObject方法可以允许用户控制序列化的过程。代码如下所示：
private static final long serialVersionUID = 1L;
private String password = "pass";
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
private void writeObject(ObjectOutputStream out) {
try {
PutField putFields = out.putFields();
System.out.println("原密码:" + password);
password = "encryption";//模拟加密
putFields.put("password", password);
System.out.println("加密后的密码" + password);
out.writeFields();
} catch (IOException e) {
e.printStackTrace();
}
}
private void readObject(ObjectInputStream in) {
try {
GetField readFields = in.readFields();
Object object = readFields.get("password", "");
System.out.println("要解密的字符串:" + object.toString());
password = "pass";//模拟解密,需要获得本地的密钥
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("result.obj"));
out.writeObject(new Test());
out.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
Test t = (Test) oin.readObject();
System.out.println("解密后的字符串:" + t.getPassword());
oin.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
序列化存储规则
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("result.obj"));
Test test = new Test();
//试图将对象两次写入文件
out.writeObject(test);
out.flush();
System.out.println(new File("result.obj").length());
out.writeObject(test);
out.close();
System.out.println(new File("result.obj").length());
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
//从文件依次读出两个文件
Test t1 = (Test) oin.readObject();
Test t2 = (Test) oin.readObject();
oin.close();
//判断两个引用是否指向同一个对象
System.out.println(t1 == t2);
如上述代码所示，对同一个对象两次写入文件，打印出写入1次与写入2次的存储大小，然后从从文件中反序列化出两个对象，比较两个对象是否一致。一般的思维是，两次写入对象，文件大小会变为两倍的大小，反序列化时，由于从文件读取，生成了两个对象，判断相等时应该是输入 false 才对。但是最后的输出结果是：
31
36
true
这是为什么呢？这是因为Java序列化为了节省磁盘空间，具有特定的存储规则，当写入同一个对象时，并不会将对象的内容进行存储，而是再次存储一份引用。反序列化时，恢复引用关系，使t1和t2指向唯一对象，二者相等，输出true。该存储规则极大的节省了存储空间。
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
Test test = new Test();
test.i = 1;
out.writeObject(test);
out.flush();
test.i = 2;
out.writeObject(test);
out.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
Test t1 = (Test) oin.readObject();
Test t2 = (Test) oin.readObject();
System.out.println(t1.i);
System.out.println(t2.i);
以上代码的目的是希望将 test 对象两次保存到 result.obj 文件中，写入一次以后修改对象属性值再次保存第二次，然后从 result.obj 中再依次读出两个对象，输出这两个对象的 i 属性值。案例代码的目的原本是希望一次性传输对象修改前后的状态。
结果两个输出的都是 1， 原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。读者在使用一个文件多次 writeObject 需要特别注意这个问题。
参考资料
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
