Java中 IO 流分为几种，什么时候用，怎么用

Java中 IO 流分为几种，什么时候用，怎么用

亲爱的朋友，
在这美好的时刻，愿你收获满满的幸福与喜悦。愿生活的每一天都充满温馨和笑声，愿你在每一个梦想的追逐中都能找到成就和满足。
愿你的心中充满爱和宽容，与亲朋好友分享快乐，携手度过生命中的点点滴滴。无论前方的路有多曲折，都相信阳光终将洒向你的心田。
愿你的梦想翱翔于蔚蓝的天空，如同一朵灿烂的彩云，散发着希望和勇气。在每个日出的时刻，都能感受到生命的美好和奇迹。
愿你的岁月如诗，平淡而又美好。在每一个日落的瞬间，都能沐浴在幸福的余晖中，感受到生活的宁静与淡然。
祝福你，生活幸福美满，一切安好如你所愿。
最诚挚的祝愿，

前言

Java 中的 I/O（输入/输出）流可以分为四类：字节流、字符流、字节缓冲流和字符缓冲流。每一类都有其特定的用途和适用场景。

1. 字节流（Byte Streams）：
   • FileInputStream 和 FileOutputStream 用于文件的字节读取和写入。
   • ByteArrayInputStream 和 ByteArrayOutputStream 用于处理字节数组。
2. 字符流（Character Streams）：
   • FileReader 和 FileWriter 用于文件的字符读取和写入。
   • StringReader 和 StringWriter 用于处理字符串。
   • BufferedReader 和 BufferedWriter 提供了缓冲功能，可以提高读写性能。
3. 字节缓冲流（Byte Buffered Streams）：
   • BufferedInputStream 和 BufferedOutputStream 提供了缓冲功能，可以提高字节流的读写性能。
4. 字符缓冲流（Character Buffered Streams）：
   • BufferedReader 和 BufferedWriter 提供了缓冲功能，可以提高字符流的读写性能。

在这里，我们开篇明义，首先介绍了几种IO流，现在，我们大概就有一个提纲，我们接下来进行详细解释每一种流的用法，并且使用代码进行详细演示

字节流

1. FileInputStream 和 FileOutputStream:
   • FileInputStream 用于从文件中读取字节流。
   • FileOutputStream 用于向文件写入字节流。

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

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream input = new FileInputStream("input.txt")) {
            int data;
            while ((data = input.read()) != -1) {
                // 处理字节数据
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream output = new FileOutputStream("output.txt")) {
            String data = "Hello, Byte Streams!";
            output.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. ByteArrayInputStream 和 ByteArrayOutputStream:
   • ByteArrayInputStream 允许从字节数组中读取数据。
   • ByteArrayOutputStream 允许将数据写入到字节数组中。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayInputStreamExample {
    public static void main(String[] args) {
        byte[] data = { 65, 66, 67, 68 }; // ASCII codes for A, B, C, D

        try (ByteArrayInputStream input = new ByteArrayInputStream(data)) {
            int value;
            while ((value = input.read()) != -1) {
                System.out.print((char) value);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ByteArrayOutputStreamExample {
    public static void main(String[] args) {
        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            String data = "Hello, ByteArray Streams!";
            output.write(data.getBytes());

            byte[] result = output.toByteArray();
            // 处理 result 数组中的字节数据
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

1. FileReader 和 FileWriter:
   • FileReader 用于从文件中读取字符流。
   • FileWriter 用于向文件写入字符流。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderWriterExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("input.txt");
             FileWriter writer = new FileWriter("output.txt")) {

            int data;
            while ((data = reader.read()) != -1) {
                // 处理字符数据
                writer.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. StringReader 和 StringWriter:
   • StringReader 允许从字符串中读取字符数据。
   • StringWriter 允许将字符数据写入到字符串中。

import java.io.StringReader;
import java.io.StringWriter;
import java.io.IOException;

public class StringReaderWriterExample {
    public static void main(String[] args) {
        String data = "ABCDEF";

        try (StringReader reader = new StringReader(data);
             StringWriter writer = new StringWriter()) {

            int value;
            while ((value = reader.read()) != -1) {
                // 处理字符数据
                writer.write(value);
            }

            String result = writer.toString();
            // 处理 result 字符串
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. BufferedReader 和 BufferedWriter:
   • BufferedReader 提供了缓冲功能，以便高效读取字符流。
   • BufferedWriter 提供了缓冲功能，以便高效写入字符流。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReaderWriterExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {

            String line;
            while ((line = reader.readLine()) != null) {
                // 处理每行字符数据
                writer.write(line);
                writer.newLine(); // 添加换行符
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节缓冲流

1. BufferedInputStream:
   • BufferedInputStream 继承自 FilterInputStream，它提供了带缓冲的输入流功能。
   • 主要用于包装其他的输入流，以提高读取性能。
   • 具备 read() 方法，但相比原始的 InputStream，它会从缓冲区读取，而不是每次都直接从底层流读取。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                // 处理字节数据
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. BufferedOutputStream:
   • BufferedOutputStream 继承自 FilterOutputStream，它提供了带缓冲的输出流功能。
   • 主要用于包装其他的输出流，以提高写入性能。
   • 具备 write() 方法，但相比原始的 OutputStream，它会将数据先写入缓冲区，而不是每次都直接写入底层流。

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

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            String data = "Hello, Buffered Streams!";
            bos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符缓冲流

字符缓冲流是用于提高字符流读写性能的装饰者模式实现。它们内部包含了一个缓冲区，通过缓冲区来减少对底层输入/输出流的直接读写次数，从而提高效率。在 Java 中，字符缓冲流有两个主要的类：BufferedReader 和 BufferedWriter。

1. BufferedReader:
   • BufferedReader 继承自 Reader，它提供了带缓冲的字符输入流功能。
   • 主要用于包装其他的字符输入流，以提高读取性能。
   • 具备 read() 方法，但相比原始的 Reader，它会从缓冲区读取，而不是每次都直接从底层流读取。
   • 提供了 readLine() 方法，可以一次读取一行文本。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 处理每行字符数据
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. BufferedWriter:
   • BufferedWriter 继承自 Writer，它提供了带缓冲的字符输出流功能。
   • 主要用于包装其他的字符输出流，以提高写入性能。
   • 具备 write() 方法，但相比原始的 Writer，它会将数据先写入缓冲区，而不是每次都直接写入底层流。
   • 提供了 newLine() 方法，可以插入平台特定的换行符。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String data = "Hello, Buffered Streams!";
            writer.write(data);
            writer.newLine(); // 添加换行符
            // 其他写入操作
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这两个例子中，BufferedReader 和 BufferedWriter 分别包装了 FileReader 和 FileWriter。使用缓冲流的好处在于它们可以减少对磁盘或网络的实际读写操作次数，提高程序的性能。

总结

BufferedReader 和 BufferedInputStream 都是用于提高 I/O 性能的缓冲流，但它们分别用于字符流和字节流。以下是它们之间的主要区别：

1. 数据类型：

   • BufferedReader 是字符缓冲流，用于处理字符数据。
   • BufferedInputStream 是字节缓冲流，用于处理字节数据。

2. 继承关系：

   • BufferedReader 继承自 Reader，属于字符流的一部分。
   • BufferedInputStream 继承自 FilterInputStream，属于字节流的一部分。

3. 读取方法：

   • BufferedReader 提供了 read() 方法用于读取字符，以及 readLine() 方法用于读取一行字符数据。
   • BufferedInputStream 提供了 read() 方法用于读取字节数据。

4. 适用场景：

   • 使用 BufferedReader 时，通常用于读取文本文件，以便按行读取和处理字符数据。
   • 使用 BufferedInputStream 时，通常用于处理二进制文件，如图像、音频或视频文件等。

下面是一个简单的示例，演示如何使用 BufferedReader 和 BufferedInputStream 分别读取文件中的字符和字节数据：

import java.io.*;

public class BufferedStreamsExample {
    public static void main(String[] args) {
        // 使用 BufferedReader 读取字符数据
        try (BufferedReader reader = new BufferedReader(new FileReader("textfile.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 使用 BufferedInputStream 读取字节数据
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("binaryfile.bin"))) {
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我们介绍了几种不同类型的IO流，并且对于其使用场景和方法做了一个介绍，这里呢，我也是对于自己的基础做一个回顾总结和扎实，希望可以帮到大家！我们一起学习，一起进步！加油！！！