IO异常--缓冲流--转换流--序列化流（ IO流2 ）

1、IO异常的处理#

JDK7前处理：使用try...catch...finally 代码块，处理异常部分

Copy
// 声明变量
FileWriter fw = null;
try {
    //创建流对象
    fw = new FileWriter("fw.txt");
    // 写出数据
    fw.write("莫逸风"); //莫逸风
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fw != null) {
            fw.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。

Copy
try (创建流对象语句，如果多个,使用';'隔开) {
    // 读写数据
} catch (IOException e) {
    e.printStackTrace();
}

// 创建流对象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
    // 写出数据
    fw.write("莫逸风"); //莫逸风
} catch (IOException e) {
    e.printStackTrace();
}

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁

Copy
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
    // 定义变量
    int b;
    // 读取数据
    while ((b = fr.read())!=‐1) {
        // 写出数据
        fw.write(b);
    }
} catch (IOException e) {
    e.printStackTrace();
}

2、缓冲流#

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强
字节缓冲流： BufferedInputStream ， BufferedOutputStream
字符缓冲流： BufferedReader ， BufferedWriter
缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

2.1、字节缓冲流#

构造方法

Copy
public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。

实例demo

Copy
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

常用方法
缓冲流读写方法与基本的流是一致的

Copy
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 读写数据
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != ‐1) {
    bos.write(bytes, 0 , len);
}
} catch (IOException e) {
    e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");

2.2、字符缓冲流#

构造方法

Copy
public BufferedReader(Reader in) ：创建一个新的缓冲输入流。
public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。

实例demo

Copy
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法
字符缓冲流的基本方法与普通字符流调用方式一致，我们来看它们具备的特有方法。

Copy
BufferedReader： public String readLine() : 读一行文字。
BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。

实例demo

Copy
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
    System.out.print(line);
    System.out.println("‐‐‐‐‐‐");
}
// 释放资源
br.close();


// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("莫逸");
// 写出换行
bw.newLine();
bw.write("风");
bw.newLine();
bw.write("莫逸");
bw.newLine();
bw.write("雪");
bw.newLine();
// 释放资源
bw.close();

3、转换流#

3.1、字符编码和字符集#

字符编码
计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

字符集
计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

字符集 Charset ：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

编码引出的问题

在编辑器中，使用FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8 编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

3.2、InputStreamReader类#

转换流java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
构造方法

Copy
InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

实例demo

Copy
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取demo

Copy
// 定义文件路径,文件为gbk编码
String FileName = "E:\\file_gbk.txt";
// 创建流对象,默认UTF8编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
// 创建流对象,指定GBK编码
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
int read;
// 使用默认编码字符流读取,乱码
while ((read = isr.read()) != ‐1) {
    System.out.print((char)read); // 􀳦􀳦Һ􀳦
}
isr.close();
// 使用指定编码字符流读取,正常解析
while ((read = isr2.read()) != ‐1) {
    System.out.print((char)read);// 大家好
}
isr2.close();

3.3、OutputStreamWriter类#

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
构造方法

Copy
OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

实例demo

Copy
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

Copy
// 定义文件路径
String FileName = "E:\\out.txt";
// 创建流对象,默认UTF8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
// 写出数据
osw.write("你好"); // 保存为6个字节
osw.close();
// 定义文件路径
String FileName2 = "E:\\out2.txt";
// 创建流对象,指定GBK编码
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
// 写出数据
osw2.write("你好");// 保存为4个字节
osw2.close();

序列化#

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。
什么情况下需要序列化

• 当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
• 当你想用套接字在网络上传送对象的时候；
• 当你想通过RMI传输对象的时候；

ObjectOutputStream类#

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
构造方法

Copy
public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。

实例demo

Copy
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

写出对象方法

Copy
public final void writeObject (Object obj) : 将指定的对象写出。

实例demo

Copy
Employee e = new Employee();
e.name = "zhangsan";
e.address = "beiqinglu";
e.age = 20;
try {
    // 创建序列化流对象
    ObjectOutputStream out = new ObjectOutputStream(new         0FileOutputStream("employee.txt"));
    // 写出对象
    out.writeObject(e);
    // 释放资源
    out.close();
    fileOut.close();
    System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
} catch(IOException i) {
i.printStackTrace();
}

ObjectInputStream类#

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

Copy
public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。

读取对象方法

Copy
public final Object readObject () : 读取一个对象。

实例demo

Copy
Employee e = null;
try {
    // 创建反序列化流
    FileInputStream fileIn = new FileInputStream("employee.txt");
    ObjectInputStream in = new ObjectInputStream(fileIn);
    // 读取一个对象
    e = (Employee) in.readObject();
    // 释放资源
    in.close();
    fileIn.close();
    }catch(IOException i) {
    // 捕获其他异常
    i.printStackTrace();
    return;
}catch(ClassNotFoundException c) {
    // 捕获类找不到异常
    System.out.println("Employee class not found");
    c.printStackTrace();
    return;
}
// 无异常,直接打印输出
System.out.println("Name: " + e.name); // zhangsan
System.out.println("Address: " + e.address); // beiqinglu
System.out.println("age: " + e.age); // 0

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个ClassNotFoundException 异常。
另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException 异常

打印流#

平时我们在控制台打印输出，是调用print 方法和println 方法完成的，这两个方法都来自于java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

PrintStream类#

构造方法

Copy
public PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流。

实例demo

Copy
PrintStream ps = new PrintStream("ps.txt")；

改变打印流向
System.out 就是PrintStream 类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以改变它的流向。
实例demo~~~~

Copy
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);