Java中对IO流的简单介绍

一.IO流的类别

IO流分为字符流和字节流两种：

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

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

---

二.字符流

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

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

1.字符输入流

字符输入流用于从数据源（如文件、字符串等）读取字符数据。Reader 是所有字符输入流的抽象基类。
FileReader ：用于从文件中读取字符数据。
InputStreamReader：将字节流转换为字符流，可以指定字符编码。
BufferedReader：提供缓冲功能，提高读取效率，支持按行读取。

import java.io.*;

public class Main {
    public static void main(String[] args) {
        // 使用 FileReader 读取文件
        try (FileReader reader = new FileReader("D:\\a.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data); // 逐个字符读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 使用 InputStreamReader 读取文件 
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream("D:\\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:\\a.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line); // 逐行读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.字符输出流

字符输出流用于将字符数据写入目标（如文件、控制台等）。Writer 是所有字符输出流的抽象基类。
FileWriter：用于将字符数据写入文件。
OutputStreamWriter：将字符流转换为字节流，可以指定字符编码。
BufferedWriter：提供缓冲功能，提高写入效率，支持按行写入。

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();
        }
    }
}

一定要注意写上writer.close()；

3.Writer常用的五种写入方法

（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：要写入的字符数。

// 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"

---

三.字节流

1.字节输入流

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

FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

常用方法：（1）int read()：从输入流中读取一个字节的数据，返回值为读取的字节（范围是 0 - 255），如果到达流的末尾则返回 -1。
（2）int read(byte[] b)：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中，返回实际读取的字节数，如果到达流的末尾则返回 -1。
（3）int read(byte[] b, int off, int len)：从输入流中读取最多 len 个字节的数据，并将其存储在数组 b 中，从偏移量 off 开始存储，返回实际读取的字节数，如果到达流的末尾则返回 -1。
（4）void close()：关闭此输入流并释放与之关联的所有系统资源。

import java.io.*;

public class FileInputStreamTest {

    public static void main(String[] args)  {
        //定义输入流
        FileInputStream fis =null;
        try {
            //1、创建文件对象
            File file = new File("D:\\IO\\hello.txt");
            //2、创建输入流对象
            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();
            }
        }
    }
}

2.字节输出流

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

FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。
FileOutputStream(String name,boolean append)： 创建文件输出流以指定的名称写入文件，每次输出文件是否继续拼接。

常用方法：（1）void write(byte b)：把一个字节写入到文件中。
（2）void write(byte[] b)：把数组b 中的所有字节写入到文件中。
（3）void write(byte[] b,int off,int len)：把数组b中的字节从 off 索引开始的 len 个字节写入到文件中。

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("D:\\IO\\hello.txt");
            //2、创建输出流对象
            fos = new FileOutputStream(file);
            
            fos.write(97);
            //后面的 \r\n表示回车换行
            fos.write("中国人!\r\n".getBytes());
            //从索引2开始输出4个字节
            fos.write("ABCDEFGH".getBytes(),2,4);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}