转载

java I/O流详解

当我们的程序需要从 硬盘，网络，或其他应用程序 中读取或写入数据时候，数据传输量可能很大，而我们的 内存或带宽有限 ，无法一次性读取获取写入大量数据。
而流（Stream）可以实现一点一点的逐步传输数据。
想想我们是怎样下载一个大文件的, 下载软件(例如x雷)并不会占用你内存很大的空间, 而只是在内存划分一个缓冲区, 一点一点地下载到自己的内存(缓冲区满了再写到硬盘),。

Stream

Stream是一个java类，这个类用于java程序和外部设备之前的输入输出操作。
所谓外部设备可以是硬盘上的文件，也可以是网络设备，或其他java程序。
在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源（source）到接收的（sink）的有序数据。

I/O流的分类

I/O流具体的分类
- 从流的方向划分：分为 输入流 ， 输出流
- 从流的传输单位划分：分为 字节流 （8位字节）， 字符流 （16位的字符）
- 从流的角色划分：分为 节点流 ， 处理流
```
数据源
```
Java将所有传统的流类型都放在Java.io包下，用于实现输入和输出功能。
该包下的流的类非常多，初学者非常容易混淆，但我们始终记住，java的I/0存在4大基类，而所有的IO流实现类，都是其子类。

I/O流架构体系

这个缺少一个继承自Writer基类的PrinterWriter

节点流--直接连接数据源的流

File 文件流。对文件进行读、写操作：FileReader、FileWriter、FileInputStream、FileOutputStream。
从/向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream。
Pipe管道流。实现管道的输入和输出（进程间通信）: PipedReader与PipedWriter、PipedInputStream与PipedOutputStream。

节点流执行流程

处理流--连接已存在的流

Buffering缓冲流：在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
Filtering 滤流：在数据进行读或写时进行过滤：FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
Converting between Bytes and Characters 转换流：按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader）：InputStreamReader、OutputStreamWriter。
Object Serialization 对象流：ObjectInputStream、ObjectOutputStream。
DataConversion数据流：按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream 。
Counting计数流：在读入数据时对行记数：LineNumberReader、LineNumberInputStream。
Peeking Ahead预读流：通过缓存机制，进行预读：PushbackReader、PushbackInputStream。 8 .Printing打印流：包含方便的打印方法：PrintWriter、PrintStream。

节点流执行图示

FileInputStrean & FileOutputStream

FileInputStrean & FileOutputStream 可以从文件系统中读取/写入诸如图像数据之类的原始字节流。
以下是使用 FileInputStrean & FileOutputStream 实现文件拷贝的案例

// 使用文件字节流 一次拷贝一个字节
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 使用文件字节流 一次拷贝一个字节数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
   }
复制代码

DataInputStream & DataOutputStream

DataInputStream & DataOutputStream，是处理流，改构造方法接收一个已存在的输入输出流，允许程序从读取方便快捷操作java的基本数据类型。

// 向文件中写入 java基本数据类型
    private static void write(String dest) throws IOException {
        //1. 创建流对象
        DataOutputStream os = new DataOutputStream(new FileOutputStream(dest));
        //2. 写入数据
        os.writeInt(10);
        os.writeChar('a');
        os.writeChar('b');
        os.writeDouble(12.83);
        //3. 关闭流
        os.close();
}

    // 从文件中读取 java基本数据类型，要和写入的顺序保持一致
    private static void read(String src) throws IOException {
        //1. 创建数据流对象
        DataInputStream in = new DataInputStream(new FileInputStream(src));
        //2. 读取数据
        int a = in.readInt();
        char b = in.readChar();
        char c = in.readChar();
        double d = in.readDouble();
        //3. 关闭流
        in.close();
    }
复制代码

BufferedInputStream & BufferedOutputStream

BufferedInputStream & BufferedOutputStream 为另一个输入输出流流添加一些功能，即缓冲区的作用。在创建 BufferedInputStream & BufferedOutputStream 时，会创建一个内部缓冲区数组。

// 为文件字节流 添加缓冲区功能， 一次读写一个字节数据，但内部缓冲区数组已经填满
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        int data = in.read();
        while (data != -1) {
            os.write(data);
            data = in.read();
        }

        //3. 关闭流
        in.close();
        os.close();
    }

    // 为文件字节流 添加缓冲区功能， 一次读写一个字节数组数据，但内部缓冲区数组已经填满
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建流
        InputStream in = new BufferedInputStream(new FileInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

        //2. 读写数据
        byte[] buffer = new byte[2048];
        int len = in.read(buffer);
        while (len != -1) {
            os.write(buffer, 0, len);
            len = in.read(buffer);
        }
        //3. 关闭流
        in.close();
        os.close();
    }
复制代码

PrintStream

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

public static void main(String[] args) throws FileNotFoundException {

        PrintStream ps = new PrintStream("test.txt");
        ps.println(5);
        ps.print("Aaaa");
        ps.print(false);
        ps.println("hahah");

        ps.flush();
        ps.close();
    }
复制代码

ByteArrayInputStream & ByteArrayInputStream

ByteArrayInputStream & ByteArrayInputStream 包含一个内部缓冲区(实际上就是把数据写入内存，然后再读取)，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节,.

public static void main(String[] args) throws IOException {

        //1. 写入数据
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        os.write("hello".getBytes());
        os.close(); // 没有写任何实现

        //2. 读取输出
        byte[] bytes = os.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);

        byte[] data = new byte[1014];
        int len = in.read(data);
        System.out.println(new String(data, 0 ,len));

    }
复制代码

InputStreamReader & OutputStreamWriter

java 在jdk1.1种提供了，针对字符处理的方便类,字符流，将原来的字节流，增加了字符编码表编码处理功能
字节流到字符流的转换流，read（）和writer（）方法会一次输入输出多个字节，以包装字符转换有效，
字节流 + 编码表 = InputStreamReader & OutputStreamWriter

// 使用 字符转换流， 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new InputStreamReader(new FileInputStream(src));
        Writer writer = new OutputStreamWriter(new FileOutputStream(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

FileReader & FileWriter

在只针对将字符写入文件的时候，因为每次使用转换流，对字节流进行包装，写法太麻烦，所以jdk 提供了字节转换流子类FileReader & FileWriter，方便的进行字符文件的IO操作

// 使用 字符转换流， 实现文本文件的 拷贝
    // 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new FileReader(src);
        Writer writer = new FileWriter(dest);

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

BufferedReader & BufferedWriter

// 一次拷贝一个 字符
    private static void copyFile1(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        int data = reader.read();
        while (data != -1) {
            writer.write(data);
            data = reader.read();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个 字符数组
    private static void copyFile2(String src, String dest) throws IOException {
        //1. 创建转换流
        Reader reader = new BufferedReader(new FileReader(src));
        Writer writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        char[] buffer = new char[2048];
        int len = reader.read(buffer);
        while (len != -1) {
            writer.write(buffer, 0 , len);
            len = reader.read(buffer);
        }
        //3.关闭流
        reader.close();
        writer.close();
    }

    // 一次拷贝一个一整行的 字符串
    private static void copyFile3(String src, String dest) throws IOException {
        //1. 创建转换流
        BufferedReader reader = new BufferedReader(new FileReader(src));
        BufferedWriter writer = new BufferedWriter(new FileWriter(dest));

        //2. 拷贝数据
        String data = reader.readLine();
        while (data != null) {
            writer.write(data);
            writer.newLine();
            data = reader.readLine();
        }
        //3.关闭流
        reader.close();
        writer.close();
    }
复制代码

StringReader & StringWriter

方便快捷的将字符串写入内存，或从内存读取

public static void main(String[] args) throws IOException, NoSuchFieldException {
        //1. 向内存写入数据，其内部提供了一个缓冲区
        StringWriter writer = new StringWriter();
        writer.write("hello world");

        //2. 读取数据
        StringReader reader = new StringReader(writer.toString());

        char[] data = new char[1024];
        int len =  reader.read(data);

        System.out.println(new String(data,0,len));
    }
复制代码

原文 https://juejin.im/post/5d4ee73ae51d4561c94b0f9d

正文到此结束