如何使用Java中的文件输入输出流函数

发布时间：2023-06-22 13:42:04

Java 中的文件输入输出流函数提供了一种便捷的方式来处理文件系统中的数据。文件输入输出流可以用来读取文件、写入文件、复制文件等操作。本文将介绍如何使用Java 中的文件输入输出流函数。

1. FileInputStream

FileInputStream 可以用来读取文件内容，它的构造函数需要传入一个文件路径参数，该路径指向想要读取的文件，如下所示：

FileInputStream fis = new FileInputStream("file.txt");

上述代码将创建一个 FileInputStream 对象 fis，以读取文件 file.txt 中的内容。

我们可以使用 read() 函数来读取文件中的数据：

int data = fis.read();
while (data != -1) {
    // 处理读取到的数据
    data = fis.read();
}

上述代码将从文件中读取数据并将其存储在变量 data 中，直到读取到文件结尾。在读取数据时，可以使用 Java 的 IO 流来避免一次读取大量数据造成的内存问题。

2. FileOutputStream

FileOutputStream 可以用来向文件写入数据，它其实就是 FileInputStream 的逆操作。通过使用 FileOutputStream，可以将任何数据写入文件中，例如简单的文本文件或二进制文件。

FileOutputStream fos = new FileOutputStream("output.txt");

上述代码将创建一个 FileOutputStream 对象 fos，以输出数据到文件 output.txt 中。为了将数据写入文件，可以使用 write() 函数，如下所示：

String data = "Hello, world!";
byte[] bytes = data.getBytes();
fos.write(bytes);

上述代码将创建一个字符串 data 并将其转换为字节数组，然后将字节数组写入文件中。

与 FileInputStream 一样，我们也可以一次写入大量数据。但在写入大量数据时，需要注意内存和磁盘 I/O 的使用。

3. FileReader

FileReader 类是 Java I/O 流中的另一种类，用于从文件中读取字符数据，它提供了方便的方式来读取文本文件中的数据。FileReader 与 FileInputStream 的区别是它会自动将字节转换为字符并进行编码。

FileReader reader = new FileReader("file.txt");

上述代码将创建一个 FileReader 对象 reader，以读取文件 file.txt 中的内容。要读取文件中的数据，可以使用 read() 函数：

int data = reader.read();
while (data != -1) {
    // 处理读取到的数据
    data = reader.read();
}

这里的 read() 函数返回的是 Unicode 字符的编码值。

4. FileWriter

FileWriter 类与 FileReader 类相似，它用于向文件中写入字符数据。它的构造函数需要传入一个文件路径参数以指向要写入的文件。

FileWriter writer = new FileWriter("output.txt");

上述代码将创建一个 FileWriter 对象 writer，以向文件 output.txt 中写入字符数据。要将数据写入文件中，可以使用 write() 函数：

String data = "Hello, world!";
writer.write(data);

上述代码将创建一个字符串 data 并将其写入文件中。与 FileOutputStream 类似，我们也可以一次写入大量数据。但在写入大量数据时，需要注意内存和磁盘 I/O 的使用。

5. BufferedInputStream 和 BufferedOutputStream

BufferedInputStream 和 BufferedOutputStream 是用于加速文件读取和写入操作的装饰器类。它们可以将 FileInputStream 和 FileOutputStream 转换为更高效的文件读取和写入操作。

FileInputStream fis = new FileInputStream("file.txt");
BufferedInputStream bis = new BufferedInputStream(fis);

上述代码将创建一个 BufferedInputStream 对象 bis，它可以加速 FileInputStream 对象 fis 中字节读取速度。要读取文件中的数据，我们现在可以使用 read() 函数：

int data = bis.read();
while (data != -1) {
    // 处理读取到的数据
    data = bis.read();
}

如果要写入大量数据，也可以使用 BufferedOutputStream：

FileOutputStream fos = new FileOutputStream("output.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
String data = "Hello, world!";
byte[] bytes = data.getBytes();
bos.write(bytes);
bos.flush();

上述代码将创建一个 BufferedOutputStream 对象 bos，以加速 FileOutputStream 对象 fos 中字节写入速度。

6. BufferedReader 和 BufferedWriter

BufferedReader 和 BufferedWriter 是用于加速文本读取和写入操作的装饰器类。它们可以将 FileReader 和 FileWriter 转换为更高效的文本读取和写入操作。与 BufferedInputStream 和 BufferedOutputStream 类似，BufferedReader 和 BufferedWriter 类也可以使读取和写入更高效。

FileReader reader = new FileReader("file.txt");
BufferedReader br = new BufferedReader(reader);

上述代码将创建一个 BufferedReader 对象 br，它可以加速 FileReader 对象 reader 中字符读取速度。要读取文件中的数据，我们可以使用 BufferedReader 对象的 readLine() 函数：

String line = br.readLine();
while (line != null) {
    // 处理读取到的数据
    line = br.readLine();
}

如果要写入大量数据，也可以使用 BufferedWriter：

FileWriter writer = new FileWriter("output.txt");
BufferedWriter bw = new BufferedWriter(writer);
String data = "Hello, world!";
bw.write(data);
bw.flush();

建议在操作大量数据时使用装饰器类。这样可以避免因数据量过大而导致的 I/O 问题。

7. 文件复制

Java 中的文件输入输出流函数也可以很容易地完成文件的复制操作。

下面是一个使用 FileInputStream 和 FileOutputStream 完成文件复制的示例：

FileInputStream fis = new FileInputStream("source.txt");
FileOutputStream fos = new FileOutputStream("destination.txt");
byte[] buffer = new byte[1024];
int length;
while ((length = fis.read(buffer)) > 0) {
    fos.write(buffer, 0, length);
}
fis.close();
fos.close();

上述代码将从 source.txt 文件中读取数据并将其写入到 destination.txt 文件中。使用了一个缓冲区来减少 I/O 操作的次数，从而提高了效率。

同样，可以使用 FileReader 和 FileWriter 来完成文件复制。下面是一个使用 BufferedReader 和 BufferedWriter 完成文件复制的示例：

FileReader reader = new FileReader("source.txt");
BufferedReader br = new BufferedReader(reader);
FileWriter writer = new FileWriter("destination.txt");
BufferedWriter bw = new BufferedWriter(writer);
String line;
while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();
}
br.close();
bw.close();

上述代码将从 source.txt 文件中读取行并将其写入到 destination.txt 文件中。使用了一个缓冲区来减少 I/O 操作的次数，从而提高了效率。

在复制文件时，要注意处理异常和关闭文件流。通常情况下，在使用文件输入输出流函数时，使用finally块确保文件流被关闭是一个好习惯。可以将关闭文件流的代码放在 finally 块中，如下所示：

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // 读取文件内容
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}