IO 流

概述

流是一组有序的，有起点和终点的字节集合，是对数据传输的总称和抽象。即数据在两设备之间的传输称为流，流的本质是数据传输，根据数据传输的特性将流抽象为各种类，方便进行更直观的数据操作。

Java 中 IO 流概览：

流的分类：

• 根据处理数据的不同分类：字节流和字符流
• 根据数据流向的不同分类：输入流和输出流

  一切文件数据（文本、图片、视频等）在存储时，都是以二进制的形式保存；同样，文件数据在传输时也是按照二进制的形式，一个字节一个字节的传输。因此，字节流可以传输任何文件，同样，字符流，本质其实就是基于字节流读取时，去查了指定的码表

根据上面的分类产生的四个顶级父类：

OutputStream

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地，其定义了字节输出流的基本共性功能方法：

字节输出流的子类：

1. 介质流：
   • ByteArrayOutputStream：Byte 数组中写入数据；
   • FileOutputStream ：本地文件中写入数据；
   • PipedOutputStream：是向与其它线程共用的管道中写入数据；
2. 装饰流：ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。
   

InputStream

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中，它定义了输入流的基本功能方法：

字节输入流的子类：

1. 介质流：
   • ByteArrayInputStream：Byte 数组中读取数据；
   • StringBufferInputStream：StringBuffer中读取数据；
   • FileInputStream：本地文件中读取数据；
   • PipedInputStream：管道字节输入流，它和PipedOutputStream一起使用，能实现多线程间的管道通信；
2. 装饰流：ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）
   • FilterInputStream：装饰者模式中处于装饰者，具体的装饰者都要继承它，所以在该类的子类下都是用来装饰别的流的，也就是处理类
   • DataInputStream：数据输入流，它是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”
   • ObjectInputStream：对象输入流，用来提供对“基本数据或对象”的持久存储。通俗点讲，也就是能直接传输对象（反序列化中使用）

Reader

public abstract class Reader implements Readable, Closeable：Reader 是所有的输入字符流的父类，它是一个抽象类
常用方法：

子类：

1. 介质流：
   • CharReader：从Char数组读取数据
   • StringReader ：从String中读取数据
   • PipedReader：是从与其它线程共用的管道中读取数据
2. 装饰流：
   • BufferedReader：装饰器，它和其子类负责装饰其它Reader 对象
   • FilterReader：是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号
   • InputStreamReader ：一个连接字节流和字符流的桥梁，它将字节流转变为字符流
   • FileReader：可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream中的类使用一致。后面会有Reader 与InputStream 的对应关系

Writer

public abstract class Writer implements Appendable, Closeable, Flushable：Writer 是所有的输出字符流的父类，它是一个抽象类
常用方法：

子类：

1. 介质流：
   • CharArrayWriter：向Char数组写入数据；
   • StringWriter：向String中写入数据；
   • PipedWriter：是向与其它线程共用的管道中写入数据；
2. 装饰流：
   • BufferedWriter：是一个装饰器为Writer 提供缓冲功能；
   • PrintWriter 和PrintStream：极其类似，功能和使用也非常相似；
   • OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter是实现此功能的具体类；

文件流

1、java.io.FileOutputStream extends OutputStream：文件字节输出流，把内存中的数据写入到硬盘的文件中
构造方法：

构造方法的作用：

1. 创建一个FileOutputStream对象
2. 会根据构造方法中传递的文件/文件路径，创建一个空的文件
3. 会把FileOutputStream对象指向创建好的文件

写入数据的步骤（内存 -> 硬盘）：java程序 -> JVM(java虚拟机) -> OS(操作系统) -> OS调用写数据的方法 -> 把数据写入到文件中文件写入步骤：

FileOutputStream实现了Closable接口的close()方法，所以建议使用 try-resource-catch 语法

1. 创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
2. 调用FileOutputStream对象中的方法write，把数据写入到文件中
3. 释放资源(流使用会占用一定的内存，使用完毕要把内存清空，提升程序的效率)

一次写多个字节：

• 如果写的第一个字节是正数（0-127），那么显示的会查询ASCII表
• 如果写的第一个字节是负数，那么第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）

2、java.io.FileInputStream extends InputStream：文件字节输入流

1. 构造方法：
   • public FileInputStream(String name) throws FileNotFoundException
   • public FileInputStream(File file) throws FileNotFoundException
2. 读取文件的数据源，支持从 name（文件路径）和 file（文件）获取
   
3. 读取数据的方法：
   • int read()：读取文件中的一个字节并返回，读取到文件的末尾返回 -1**

3、java.io.FileReader：继承 InputStreamReader 类，按字符读取流中数据
构造方法：

4、FileWriter：继承 OutputStreamWriter 类，按字符向流中写入数据
构造方法：

缓冲流

缓冲流：也叫高效流、装饰流，是对 4 个基本流的增强，使用了装饰器模式，因此可以分为如下类别：

缓冲流的基本原理：是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统 IO 的次数，从而提高读写效率。

1、字节缓冲输入流：java.io.BufferedInputStream extends InputStream

2、字节缓冲输出流：java.io.BufferedOutputStream extends OutputStream

3、字符缓冲输入流：public class BufferedReader extends Reader

注意特殊方法：

• String readline()：读取一个文本行，返回值为不包含终止符（\r、\n、\r\n）的字符串，如果已经到达流末尾，返回 null

4、字符缓冲输出流：public class BufferedWriter extends Writer

注意特殊方法：

• public void newLine() throws IOException：创建新行，会根据系统类型自动选择，而无需自己手动指定
• flush()：在写入后记得使用 flush 方法把缓冲区的数据冲刷到硬盘上

转换流

在字节流与字符流转换时，涉及字符的编码与解码问题，因此需要转换流，java中的转换流有两种：

• 字节流转换为字符流（解码）：InputStreamReader类
  
• 字符流转换为字节流（编码）：OutputStreamWriter类

  java中的 FileReader 和 FileWriter 会自动查询系统的字符集进行编解码

在JVM中使用的是双字节的UTF-8，因此在读取、写入文件中的中文字符时，有可能出现乱码问题

对象的序列化

Java 的序列化和反序列化：

• 序列化：将保存在内存中的对象数据转化为二进制数据流进行传输，任何对象都可以序列化
• 反序列化：将二进制数据转换为对象

注意：

• 序列化和反序列化只能序列化对象的属性，且不包括被 transient 标记的属性
• static 修饰的静态变量为 Class 对象持有，不属于对象的属性，也不能被序列化和反序列化

1、序列化：实现 java.io.Serializable 接口

• serialVersionUID：序列号，用于唯一标识一个类
• 编译器 javac.exe 会为每个实现了 Serializable 接口的类添加一个序列号 serialVersionUID，反序列化的时候会根据该序列号唯一标识一个类，然而如果修改了原类，在重新编译的时候会生成一个新的 serializableUID，导致反序列化错误，因此在实现 Serializable 接口的同时，应该定义一个 private static final long serialVersionUID

2、反序列化：

• 构造方法：ObjectInputStream（InputStream in）
• 常用方法：Object readObject() 从 ObjectInputStream 读取对象

序列化和反序列化：

/* User 类 */
public class User implements Serializable {
    private static final long serialVersionUID = 8749345376788010604L;
    static int y = 0;
    private String name;
    private Integer age;
    private transient String sex;
    public User(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "User{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", sex='" + sex + '\'' +
            '}';
    }
}
/* 测试 */
// 写对象
try (ObjectOutputStream oos =
     new ObjectOutputStream(
         new FileOutputStream("/user"))) {
    User user = new User("漳卅",18,"男");
    oos.writeObject(user);
} catch (IOException e) {
    e.printStackTrace();
}
// 读对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/user"))) {
    User user = (User) ois.readObject();
    System.out.println(user);
    // 输出：User{name='漳卅', age=18, sex='null'}
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}
/* 写入对象集合 */
String target = "/users";
try (FileOutputStream fos = new FileOutputStream(target);
     ObjectOutputStream oos = new ObjectOutputStream(fos);) {
    // 创建对象集合
    ArrayList<User> users = new ArrayList<>();
    users.add(new User("Bob", 12, "man"));
    users.add(new User("Tom", 20, "woman"));
    users.add(new User("Dave", 32, "man"));
    // 写入对象
    oos.writeObject(users);
} catch (IOException e) {
    e.printStackTrace();
}
/* 读取集合并打印 */
try (FileInputStream fis = new FileInputStream(target);
     ObjectInputStream ois = new ObjectInputStream(fis)) {
    ArrayList<User> users = (ArrayList<User>) ois.readObject();
    for (User user : users) {
        System.out.println(user);
    }
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

PrintStream 和 Scanner

1、java.io.PrintStream extends OutputStream：打印流，为其他输出流添加了功能，使它们能够方便的打印出各种数据值表示形式
PrintStream特点：

1. 只负责数据的输出，不负责数据的读取
2. 与其他输出流不同，PrintStream永远不会抛出 IOException
3. 有其特有的方法：
   • void print(任意类型的值)
   • void println(任意类型的值并换行)
4. 构造方法：
   • PrintStream(File file)
   • PrintStream(OutputStream out)
   • PrintStream(String fileName)
5. 注意事项：PrintStream 继承了 OutputStream ，然而重写了父类的 write() 方法，查看数据的时候会查询编码表；而其自身特有的 print/println 方法写数据，写的时候会原样输出

2、System类对IO的支持：针对一些频繁的设备交互，Java语言系统预定了3个可以直接使用的流对象，分别是：

• System.in（标准输入），通常代表键盘输入；
  

• System.out（标准输出，为PrintStream）：通常写往显示器；

  可以使用System.setOut(PrintStream out)方法通过传入打印流改变输出的目的地

• System.err（标准错误输出）：通常写往显示器；

  可以使用System.setErr(PrintStream err)方法通过传入打印流改变错误输出的目的地

Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

3、Scanner
Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。它是以前的StringTokenizer和Matcher类之间的某种结合。由于任何数据都必须通过同一模式的捕获组检索或通过使用一个索引来检索文本的各个部分。于是可以结合使用正则表达式和从输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，Scanner类还可以任意地对字符串和基本类型(如int和double)的数据进行分析。借助于Scanner，可以针对任何要处理的文本内容编写自定义的语法分析器。
Scanner套接字节流或字符流：

• 字节流的套接：在Scanner的构造方法中Scanner(InputStream source)，InputStream只要经过适当的套接，总能获得你想要的流接口。
• 字符流的套接：Scanner(Readable source)，你需要使用Java SE5中新加入的一个接口Readable，该接口表示“具有read()方法的某种东西”，查看Readable接口的API你可以发现你想要的带有Reader的类基本都在其中。

小案例

1、使用文件输入、输出字节流进行文件复制：

public void fileCopyWithStream(File source, File target) {
    try (FileInputStream fis = new FileInputStream(source); // 获取文件输入流
         // 获取文件输出流
         FileOutputStream fos = new FileOutputStream(target);) {
        // 缓冲数组
        byte[] bytes = new byte[1024];
        // 每次读取的字节数
        int read = 0;
        while ((read = fis.read(bytes)) != -1) {
            // 将读取的数据写入文件
            fos.write(bytes, 0, read);
        }
        // 冲刷缓冲区
        fos.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2、使用字符流进行文件复制：

public void fileCopyWithReaderWriter(File source, File target) {
    try (FileWriter fw = new FileWriter(target); // 获取写文件字符流
         // 获取读文件字符流
         FileReader fr = new FileReader(source)) {
        // 字符数组
        char[] cs = new char[1024];
        // 每次读取的字符数
        int read = 0;
        while ((read = fr.read(cs)) != -1) {
            // 将读取的字符写入文件
            fw.write(cs, 0, read);
        }
        // 将字符输出流的数据清空确保完全写入
        fw.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3、BufferedReader 与 BufferedWriter 使用：从控制台获取字符并写入到文件中

public static void consoleToFile(File file) {
    BufferedReader reader = null;
    BufferedWriter writer = null;
    try {
        // 将控制台的字节输入流转换成字符缓冲流
        // InputStreamReader为中间流，用于将字节输入流转换成字符输入流
        reader = new BufferedReader(new InputStreamReader(System.in));
        // 将字符输出流转换成字节输出流写入文件
        // OutputStreamWriter为中间流，用于将字符输出流转换成字节输出流
        // 此处也可以使用文件字符输出流的包装类：FileWriter
        // 等效写法：writer = new BufferedWriter(new FileWriter(file));
        writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));
        // 用于接受从字符缓冲区的数据
        String msg = null;
        // BufferedReader.readLine()方法会一直等待输入，直到碰到输入字符中存在\t\n等换行符才会完成读取
        while ((msg = reader.readLine()) != null) {
            // 使用exit终止写入
            if ("exit".equalsIgnoreCase(msg)) break;
            // 将数据写入文件
            writer.write(msg);
            // 写入换行符
            writer.newLine();
        }
        // 冲刷写缓冲
        writer.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        close(reader);
        close(writer);
    }
}
private static void close(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、文件编码转换：

public static void utf8ToGbk(File source, File target) {
    BufferedWriter bw = null;
    BufferedReader br = null;
    try {
        // 1.以UTF-8读取文件
        InputStreamReader inputStreamReader = new InputStreamReader(
            new FileInputStream(source), StandardCharsets.UTF_8);
        br = new BufferedReader(inputStreamReader);
        // 2.以GBK写入文件
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
            new FileOutputStream(target), Charset.forName("GBK"));
        bw = new BufferedWriter(outputStreamWriter);
        String str = null;
        //  追行读取
        while ((str = br.readLine()) != null) {
            bw.write(str);
            bw.newLine();
        }
        bw.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        close(br);
        close(bw);
    }
}
private static void close(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节输入流与字节输出流

字节流输入与输出的对应：蓝色的为主要的对应部分，红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。

• LineNumberInputStream：主要完成从流中读取数据时，会得到相应的行号，至于什么时候分行、在哪里分行是由该类主动确定的，并不是在原始中有这样一个行号。在输出部分没有对应的部分，我们完全可以自己建立一个LineNumberOutputStream，在最初写入时会有一个基准的行号，以后每次遇到换行时会在下一行添加一个行号，看起来也是可以的。
• PushbackInputStream：查看最后一个字节，不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream几乎实现相近的功能。
• StringBufferInputStream 已经被Deprecated，本身就不应该出现在InputStream部分，主要因为String 应该属于字符流的范围。已经被废弃了，当然输出部分也没有必要需要它了！还允许它存在只是为了保持版本的向下兼容而已。
• SequenceInputStream 可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除，还完全不影响IO 包的结构，却让其更“纯洁”――纯洁的Decorator 模式。
• PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流，或者FileInputStream写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。System.out 和System.out 就是PrintStream 的实例。