Java IO 流概述与基础应用

文件输入流应用

java.io.FileInputStream 文件输入流对象用于从文件中读取数据，常用构造方法有：

FileInputStream(String path)
基于给定的路径对应的文件创建文件输入流

FileInputStream(File file)
基于给定的 File 对象所表示的文件创建文件输入流

案例

package io;
import java.io.FileInputStream;
import java.io.IOException;

public class FISDemo01 {
    public static void main(String[] args) throws IOException {
        // 1. 构建文件输入流对象
        FileInputStream fis = new FileInputStream("jsd/2406/fos.dat");
        // 2. 读取数据
        int n = 0;
        while ((n = fis.read()) != -1) {
            System.out.println(n);
        }
        // 3. 关闭流对象 (水龙头有打开是不是也会有关闭，否则浪费资源)
        fis.close(); // 流对象关闭后会释放内存
    }
}

文件的复制实践

复制文件的原理就是使用文件输入流从原文件中陆续读取出每一个字节，然后再使用文件输出流将字节陆续写入到另一个文件中完成的。

案例 1

package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyDemo01 {
    public static void main(String[] args) throws IOException {
        // 一、实现思路
        // 1. 读文件内容 (a.png)
        // 2. 将读取的内容写到 b.png 中
        // 二、代码实现
        // 1. 构建文件输入流、输出流对象
        FileInputStream fis = new FileInputStream("a.png"); // 这个文件需要存在
        FileOutputStream fos = new FileOutputStream("b.png"); // 这个文件不存在会自动创建
        // 2. 读写数据 (复制)
        int n = -1;
        while ((n = fis.read()) != -1) { // 读取数据，n 为读到的数据，-1 表示读取到文件尾
            fos.write(n); // 将读取的数据写入到 b.png 文件中
        }
        // 3. 关闭流对象
        fis.close();
        fos.close();
    }
}

块读写操作实践

• 块读：一次性读取一组字节的方式 InputStream 中定义了块读的方法

int read(byte[] data)
一次性读取给定字节数组总长度的字节量并存入到该数组中。
返回值为实际读取到的字节数。如果返回值为 -1 表示本次没有读取到任何字节已经是流的末尾了

• 块写：一次性写出一组字节的方式 OutputStream 中定义了块写的方法

void write(byte[] data)
一次性将给定数组中所有字节写出 void write(byte[] data, int offset, int len)
一次性将 data 数组中从下标 offset 处开始的连续 len 个字节一次性写出

案例实现：文件复制

package io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyDemo02 {
    public static void main(String[] args) throws IOException {
        // 一、实现思路
        // 1. 读文件内容 (a.png)
        // 2. 将读取的内容写到 b.png 中
        // 二、代码实现
        // 1. 构建文件输入流、输出流对象
        FileInputStream fis = new FileInputStream("a.png"); // 这个文件需要存在
        FileOutputStream fos = new FileOutputStream("b.png"); // 这个文件不存在会自动创建
        // 2. 读写数据 (复制)
        // 2.1 定义数组用于临时存储读取到数据
        byte[] data = new byte[1024]; // 这里数组的大小是自定义
        // 2.2 循环读取数据
        int length = -1;
        while ((length = fis.read(data)) != -1) { // 这里数组大小是 1024，所以最多一次读取 1024 个字节，length 表示读取的字节数
            fos.write(data, 0, length); // 读了多少写多少，0 表示起始位置，length 表示写入的字节数
        }
        // 3. 关闭流对象
        fis.close();
        fos.close();
    }
}

文本数据操作

对于 FileInputStream 和 FileOutputStream 提供的方法只能读写字节数据，对于文本数据如何操作呢？

案例 1：写文本数据

package io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class WriteStringDemo01 {
    public static void main(String[] args) throws IOException {
        String str = "我爱 Java";
        // 构建文件输出流对象
        FileOutputStream fos = new FileOutputStream("./f1.txt");
        // 写字符数据
        byte[] data = str.getBytes(StandardCharsets.UTF_8);
        fos.write(data);
        str = "Hello Tedu";
        fos.write(str.getBytes(StandardCharsets.UTF_8));
        // 释放资源
        fos.close();
    }
}

案例 2：读文本数据

package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ReadStringDemo01 {
    public static void main(String[] args) throws IOException {
        // 1. 构建文件输入流对象
        // 方式 1：
        // File file = new File("./f1.txt");
        // long size = file.length();
        // FileInputStream fis = new FileInputStream(file);
        // 方式 2：
        FileInputStream fis = new FileInputStream("./f1.txt");
        // 2. 读取文件内容 (将数据读取到字节数组中)
        // byte[] data = new byte[(int)size];
        byte[] data = new byte[fis.available()]; // fis.available() 获取流中有效字节数
        int len = fis.read(data);
        // 3. 将字节数组内容转换为字符串并输出
        String str = new String(data, 0, len);
        System.out.println(str);
        // 4. 关闭流
        fis.close();
    }
}

字节缓冲流应用

处理流

概述
处理流是 Java IO 流体系中的一类重要的流，它们是在已经存在的流（称为基础流或节点流）之上构建的，为这些流添加额外的功能，而不改变原流本身。处理流的主要目的是为了增强或改变流的行为，比如提供缓冲、转换数据类型、序列化等等。

应用特征
处理流的典型特征是它们自身并不直接连接到物理的输入/输出设备，而是'装饰'在其他流之上，利用这些流进行数据的读写，并在此基础上提供附加服务。处理流的实例通常会把读写操作委托给底层的流，同时可能对数据进行一些预处理或后处理。

处理流可以串联使用，即一个处理流的输出可以作为另一个处理流的输入，形成流的链式结构。例如，可以先使用 BufferedInputStream 对 FileInputStream 进行包装，然后再用其它处理流包装这个缓冲流。

字节缓冲流

Java 中的缓冲流是一种处理流，有 java.io.BufferedInputStream 和 BufferedOutputStream，其作用就是加快读写效率，通常缓冲流的应用最终要链接在低级流上。

• 缓冲字节输出流
  BufferedOutputStream(OutputStream out)
  实例化一个缓冲字节输出流并链接在指定的字节输出流上。默认缓冲区大小 8kb(内部维护的 byte[] buf 数组长度 8192)
  BufferedOutputStream(OutputStream out, int size)
  实例化一个指定缓冲区大小的缓冲字节输出流并链接在指定的字节输出流上。
• 缓冲字节输入流
  BufferedInputStream(InputStream in)
  实例化一个缓冲字节输入流并链接在指定的字节输入流上。默认缓冲区大小 8kb(内部维护的 byte[] buf 数组长度 8192)
  BufferedInputStream(InputStream in, int size)
  实例化一个指定缓冲区大小的缓冲字节输入流并链接在指定的字节输入流上。

应用案例分析

package io;
import java.io.*;

public class FileCopyDemo03 {
    public static void main(String[] args) throws IOException {
        // 1. 构建输入输出流对象 (缓冲流增强文件流)
        BufferedInputStream bis = new BufferedInputStream(
            // 处理流 (这个流对象内置一个缓冲区 -byte[])
            new FileInputStream("./a.png")
        ); // 节点流
        BufferedOutputStream bos = new BufferedOutputStream(
            // 处理流
            new FileOutputStream("./c.png")
        ); // 节点流
        // 2. 读写数据 (拷贝)
        byte[] data = new byte[16];
        int len;
        while ((len = bis.read(data)) != -1) {
            bos.write(data, 0, len);
        }
        bos.flush(); // 这里表示刷新缓冲区内容到文件
        // 3. 关闭流对象 (关闭外层流时，内层流会自动关闭)
        bis.close();
        bos.close();
    }
}

对象流应用实践

简介

Java 中的对象流也是一种处理流，有 java.io.ObjectInputStream 和 java.io.ObjectOutputStream 两个类型，用于实现对象的读写。也就是对象的序列化（把对象转化为字节）和反序列化（把字节转换为对象）。

• ObjectOutputStream：用于将 Java 对象序列化为字节流，以便可以将对象写入文件、网络或其他任何形式的持久存储中。
• ObjectInputStream：用于从字节流中反序列化 Java 对象，即将字节流重新转换为 Java 对象。

Serializable 接口
为了能够被序列化，一个对象所属的类必须实现 Serializable 接口。Serializable 是一个标记接口，不包含任何方法，它的存在仅仅是为了标识一个类是可序列化的。如果尝试序列化一个没有实现 Serializable 接口的类的对象，将会抛出 NotSerializableException 异常。

应用案例分析

设计一个 Message 对象类型

package io;
import java.io.Serializable;

public class Message implements Serializable {
    // Serializable 只起到一个标识性作用
    // 添加序列化 id(序列化时类中没有写序列化 id，系统也会基于类中的属性和方法自动生成)
    private static final long serialVersionUID = 8725255648785219540L;

    /*消息 id*/
    private Integer id;
    /**消息标题，
     * 假如这个属性不希望系列化，
     * 可以使用 transient 关键字修饰*/
    private transient String title;
    /**消息内容*/
    private String content;

    public Message() {}

    public Message(Integer id, String title, String content) {
        this.id = id;
        this.title = title;
        this.content = content;
    }

    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getContent() { return content; }
    public void setContent(String content) { this.content = content; }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

对象序列化案例实现

package io;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        Message m1 = new Message(1, "传奇老师病了", "做了个小手术");
        // 1. 构建流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("message.txt"));
        // 2. 写对象 (序列化)
        oos.writeObject(m1);
        System.out.println("序列化 OK");
        // 3. 关闭流对象
        oos.close();
    }
}

对象反序列化案例实现

package io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamDemo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("message.txt"));
        // 2. 读取对象 (反序列化 - 先读出来的是字节，然后将字节转换对象)
        Message msg = (Message) ois.readObject();
        System.out.println(msg);
        // 3. 关闭资源
        ois.close();
    }
}

字符转换流应用

字符流

在 Java 中，字符流（Character Streams）是用于处理文本数据的一种流类型，其基类是 java.io.Reader 和 java.io.Writer 两个抽象类。

应用场景？
字符流广泛应用于读写文本文件，处理字符串，以及在网络通信中传输文本数据。由于文本文件通常包含人类可读的内容，字符流可以确保正确处理各种字符集和编码，从而避免乱码问题。

为什么使用字符流？

• 编码透明性：字符流允许你指定字符编码，因此你可以读写使用不同编码的文本文件，而不需要了解具体的编码细节。
• 字符边界处理：当处理多字节编码（如 UTF-8）的字符时，字符流能确保每次读写的都是一个完整的字符，避免字节流中可能出现的字符截断问题（这里其实是乱码）

字符流超类

• java.io.Writer 所有字符输入流的超类
  常用方法

  void write(int c): 写出一个字符，写出给定 int 值'低 16'位表示的字符。
  void write(char[] chs): 将给定字符数组中所有字符写出。
  void write(String str): 将给定的字符串写出
  void write(char[] chs, int offset, int len): 将给定的字符数组从 offset 处开始连续的 len 个字符写出

• java.io.Reader 所有字符输出流的超类
  常用方法

  int read(): 读取一个字符，返回的 int 值'低 16'位有效。当返回值为 -1 时表达流读取到了末尾。
  int read(char[] chs): 从该流中读取一个字符数组的 length 个字符并存入该数组，返回值为实际读取到的字符量。当返回值为 -1 时表达流读取到了

字符转换流应用

在 Java 中，字符转换流是 Java I/O 体系中的一类流，它们实现了字节流和字符流之间的转换。这类流包括 InputStreamReader 和 OutputStreamWriter 两个核心类。

InputStreamReader 是一个读取字节并使用指定的字符集将其解码为字符的 Reader；OutputStreamWriter 则是一个接收字符并使用指定的字符集将其编码为字节的 Writer。

应用场景

• 当你需要从字节流中读取文本数据，并且想要控制使用的字符编码时。
• 当你需要将字符数据写入到字节流中，并指定字符编码时。
• 在网络通信中，当你发送或接收的数据是以字节形式存在，但你希望以字符形式处理时。

为什么用它？

• 编码兼容性：不同的系统和文件可能使用不同的字符编码，字符转换流可以让你指定编码，从而正确解析或生成文本。
• 国际化支持：为了支持多种语言和字符集，字符转换流提供了灵活的编码选择，这对于开发国际化应用非常重要。
• 数据完整性：在处理多字节编码的字符时，字节流可能会导致字符被错误地分割，而字符转换流保证了字符的完整性和正确性。

应用案例分析和实践

• OutputStreamWriter 应用案例 (字符输出转化流应用)
  两个构造方法：

  OutputStreamWriter(OutputStream out, Charset cs)
  基于给定的字节输出流以及字符编码创建 OSW

  OutputStreamWriter(OutputStream out)
  该构造方法会根据系统默认字符集创建 OSW

具体应用：通过字符转换流将一些字符串写入到指定文件

package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;

public class OutputStreamWriterDemo01 {
    public static void main(String[] args) throws IOException {
        // 1. 构建字符转换输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./osw.txt"), StandardCharsets.UTF_8);
        // 2. 写数据 (字符串)
        osw.write("你好"); // 这里不会自动换行
        osw.write("子千老师");
        System.out.println("数据写出完毕");
        // 3. 关闭流对象
        osw.close();
    }
}

• InputStreamReader 应用案例 (字符输入转化流应用)
  构造方法：

  InputStreamReader(InputStream in, Charset cs)
  基于给定的字节输入流以及字符编码创建当前转换流

  InputStreamReader(InputStream in)
  该构造方法会根据系统默认字符集创建当前转换流

具体应用案例：基于字符转换流从文件读取字符数据

package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws IOException {
        // 1. 创建字符输入转换流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("./osw.txt"), StandardCharsets.UTF_8);
        // 2. 读数据
        int data = 0;
        while ((data = isr.read()) != -1) {
            System.out.print((char) data);
        }
        // 3. 关闭流对象
        isr.close();
    }
}

字符缓冲流应用

简介

在 Java 中，字符缓冲流是用于提高读写性能的一对流，它们包括 BufferedReader 和 BufferedWriter。这些流通过内部缓存机制减少了对底层 I/O 设备的访问频率，从而提高了读写操作的效率。
在字符输出缓冲流应用时，通常会结合 PrintWriter 一起使用。这个对象可以一次写一行，并且可以自带刷新机制。

快速入门实现

案例 1：PrintWriter 不同构造方法应用

package io;
import java.io.*;

public class PrintWriterDemo01 {
    public static void main(String[] args) throws FileNotFoundException {
        // 1. 构建 PrintWriter 对象
        // 方式 1：需要手动刷新缓冲区或者关闭流
        PrintWriter pw = new PrintWriter("./pw.txt");
        // 方式 2：自动刷新，构造方法中的 true 表示自动刷新
        // PrintWriter pw = new PrintWriter(
        //     new FileOutputStream("./pw.txt"), true
        // );
        // 2. 写入数据
        pw.println("hello");
        pw.println("world");
        pw.println("Java");
        // 3. 关闭流对象
        pw.close();
    }
}

案例 2：自己指定缓冲流

package io;
import java.io.*;

public class PrintWriterDemo02 {
    public static void main(String[] args) throws FileNotFoundException {
        // 1. 构建打印流对象 (装饰模式)
        PrintWriter printWriter = new PrintWriter(
            new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream("./pw.txt"))
            ), true
        );
        // 2. 写数据
        printWriter.println("hello");
        printWriter.println("Java");
        // 3. 关闭流对象
        printWriter.close();
    }
}

案例 3：字符输入缓冲流应用

package io;
import java.io.*;
import java.nio.charset.StandardCharsets;

public class BufferedReaderDemo01 {
    public static void main(String[] args) throws IOException {
        // 1. 构建 BufferedReader 对象
        BufferedReader br = new BufferedReader(
            new InputStreamReader(
                new FileInputStream("./src/main/java/io/FISDemo01.java"),
                StandardCharsets.UTF_8
            )
        );
        // 2. 循环读取文件中数据，读一行，输出一行
        String line = null;
        while ((line = br.readLine()) != null) {
            // readLine 用于读取一行
            System.out.println(line);
        }
        // 3. 关闭流对象
        br.close();
    }
}