Java IO流 - 技术栈

一、流Stream的基本概念

IO 流

字符流
- reader
  - 文件流 FileReader
  - 转换流 inputStreamReader
  - 缓冲流 BufferedReader
- writer
  - 文件流 Writer
  - 转换流 OutputStreamWriter
  - 缓冲流 BufferedWriter
  - 打印流 PrinterWriter
字节流
- inputStream
  - 缓冲流 BufferedInputStream
  - 文件输入流 FileInputStream
  - 对象输入流 ObjectInputStream
  - 解压流 ZipInputStream
- outputStream
  - 缓冲流 BufferedOutputStream
  - 文件输出流 FileOutputStream
  - 对象输出流 ObjectOutputStream
  - 打印流 PrintOutputStream
  - 压缩流 ZipOutputStream

字符流:文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

字节流：二进制的数据，这种数据一般用文本打开我们读不懂。比如，图片文件，mp3文件，等等。

1.字符流

字符输入流（Reader）用于读取文本数据，常用类包括 FileReader 和 BufferedReader。

字符输出流（Writer）用于写入文本数据，常用类包括 FileWriter 和 BufferedWriter。

字符流适合处理文本文件，支持字符编码，能够高效地读写文本数据。

1.1字节输入流

字符输入流用于从数据源（如文件、字符串等）读取字符数据。Reader 是所有字符输入流的抽象基类。

FileReader 用于从文件中读取字符数据。

InputStreamReader 将字节流转换为字符流，可以指定字符编码。

BufferedReader 提供缓冲功能，提高读取效率，支持按行读取。

java 复制代码

public class Main {
import java.io.*;

public class Main {
    public static void main(String[] args) {
        // 使用 FileReader 读取文件
        try (FileReader reader = new FileReader("D:\\IdeaProjects\\JavaTest\\src\\com\\qcby\\a.txt")) {
            int data;
            //当流中还有数据时，返回值是一个非负整数（0 到 buffer.length 之间），
            // 表示本次读取到的字节数量（可能小于缓冲区长度）
            //当流已经读取到末尾（没有更多数据可读取）时，返回 -1，表示读取结束
            while ((data = reader.read()) != -1) {
                System.out.print((char) data); // 逐个字符读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 使用 InputStreamReader 读取文件 
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream("D:\\IdeaProjects\\JavaTest\\src\\com\\qcby\\a.txt"), "UTF-8")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 使用 BufferedReader 按行读取文件
        try (BufferedReader br = new BufferedReader(new FileReader("D:\\IdeaProjects\\JavaTest\\src\\com\\qcby\\a.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line); // 逐行读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2字节输出流

字符输出流用于将字符数据写入目标（如文件、控制台等）。Writer 是所有字符输出流的抽象基类。

FileWriter用于将字符数据写入文件。

OutputStreamWriter将字符流转换为字节流，可以指定字符编码。

BufferedWriter提供缓冲功能，提高写入效率，支持按行写入。

java 复制代码

import java.io.*;

public class Main {
    public static void main(String[] args) {
        // 使用 FileWriter 写入文件
        try{
            FileWriter writer = new FileWriter("output.txt");
            writer.write("Hello, World!"); // 写入字符串
            writer.write("\nThis is a new line."); // 写入换行符
            writer.close();  //这个很重要没有这个数据写入不进去
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("output.txt"));
            writer.write("Hello, World!"); // 写入字符串
            writer.write("\nThis is a new line."); // 写入换行符
            writer.close();  //这个很重要没有这个数据写入不进去
        }catch (IOException e){
            e.printStackTrace();
        }

        // 使用 BufferedWriter 按行写入文件
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, World!"); // 写入字符串
            bw.newLine(); // 写入换行符
            bw.write("This is a new line."); // 写入另一行
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.3Writer的五种写入的方法

1.write(int c)

功能：写入单个字符。
参数：c 是要写入的字符（以 int 形式表示，低 16 位有效）。
2.write(char[] cbuf)
功能：写入字符数组中的所有字符
参数：cbuf 是要写入的字符数组。
3.write(char[] cbuf, int off, int len)
功能：写入字符数组的一部分。
参数：
cbuf：字符数组。
off：起始偏移量（从数组的哪个位置开始写入）。
len：要写入的字符数。
4.write(String str)
功能：写入字符串。
参数：str 是要写入的字符串。
5.write(String str, int off, int len)
功能：写入字符串的一部分。
参数：
- str：字符串。
- off：起始偏移量（从字符串的哪个位置开始写入）。
- len：要写入的字符数。

java 复制代码

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class WriterExample {
    public static void main(String[] args) {
        try (Writer writer = new FileWriter("output.txt")) {
            // 1. 写入单个字符
            writer.write('H');

            // 2. 写入字符数组
            char[] array = {'e', 'l', 'l', 'o'};
            writer.write(array);

            // 3. 写入字符数组的一部分
            writer.write(array, 1, 2); // 写入 "ll"

            // 4. 写入字符串
            writer.write(", World!");

            // 5. 写入字符串的一部分
            String str = "\nThis is Java IO.";
            writer.write(str, 0, 11); // 写入 "This is Java"

            System.out.println("数据已写入文件！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2 字节流

1.1字节输入流（InputStream）

InputStream 是所有字节输入流的抽象基类，它定义了读取字节数据的基本方法。

int read()： 从输入流中读取一个字节的数据，返回值为读取的字节（范围是 0 - 255），如果到达流的末尾则返回 -1。随机
int read(byte[] b)： 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中，返回实际读取的字节数，如果到达流的末尾则返回 -1。
int read(byte[] b, int off, int len)： 从输入流中读取最多 len 个字节的数据，并将其存储在数组 b 中，从偏移量 off 开始存储，返回实际读取的字节数，如果到达流的末尾则返回 -1。
void close()： 关闭此输入流并释放与之关联的所有系统资源。
其中InputStream的实现类FileInputStream 是专门用于读取文件中的数据，通过它将目标设备上的数据读入到程序。
FileInputStream(File file)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

java 复制代码

package com.qcby;

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

public class FileInputStreamTest {
    public static void main(String[] args) {
        //定义输入流
        FileInputStream fis = null;
        try {
            //创建输入流对象
            File file = new File("C:\\Users\\27860\\IdeaProjects\\jiekou\\src\\com\\qcby\\a.txt");
            //创建输入流对象
            fis = new FileInputStream(file);
            //用定义字节数组，作为装字节数据的容器
            byte[] buffer = new byte[5];
            int len;//记录每次读取的字节个数
            //System.out.println(fis.read(buffer));
            while ((len = fis.read(buffer)) != -1) {
                //转成String型，否则输出ASCII码
                String str = new String(buffer, 0, len);
                System.out.println(str);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //释放资源
            try {
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

1.2字节输出流OutputStream

OutputStream是所有字节输出流的父类，定义了所有字节输出流都具有的共同特征。

void write(byte b)：把一个字节写入到文件中。
void write(byte[] b)：把数组b 中的所有字节写入到文件中。
void write(byte[] b,int off,int len)：把数组b 中的字节从 off 索引开始的 len 个字节写入到文件中。
其中OutputStream的实现类FileOutputStream 是门用于读出文件中的数据，通过它将数据从程序输出到目标设备
FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。
FileOutputStream(String name,boolean append)：创建文件输出流以指定的名称写入文件，每次输出文件是否继续拼接。

java 复制代码

package com.qcby;

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

public class FileOutputStreamTest {
    public static void main(String[] args) {
        //定义字节输出流
        FileOutputStream fos = null;
        try {
            //1.创建文件对象
            File file = new File("C:\\Users\\27860\\IdeaProjects\\jiekou\\src\\com\\qcby\\output.txt");
            //2.创建字节输出流对象
            fos = new FileOutputStream(file);

            fos.write(97);//ASCII码97对应的字符是a
            //后面的\r\n表示回车换行
            fos.write("中国人！\r\n".getBytes());
            //从索引2开始输出4个字节
            fos.write("ABCDEFGH".getBytes(),2,4);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //释放资源
            try {
                fos.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}