【Java 基础篇】自如应对文本数据：Java缓冲字符流详解

Java提供了许多用于读写文本文件的类，其中缓冲字符流(Buffered Character Stream)是一种非常常用且高效的方式。本篇博客将详细介绍Java缓冲字符流的使用，包括什么是缓冲字符流、为什么需要它们、如何创建和使用缓冲字符流、以及一些常见的使用场景和注意事项。

什么是缓冲字符流？

在了解缓冲字符流之前，我们需要先了解字符流和缓冲流的概念。

• 字符流：字符流是用于处理字符数据的I/O流，通常用于读写文本文件。它们以字符为单位进行读写，适用于文本数据的操作。

• 缓冲流：缓冲流是在字符流或字节流的基础上添加了缓冲区的功能。缓冲区是内存中的一块临时存储区域，可以减少实际的磁盘或网络I/O次数，从而提高读写性能。

缓冲字符流是字符流的一种，它们具有以下特点：

• 缓冲：缓冲字符流内部维护了一个缓冲区，可以一次性读写多个字符，减少了磁盘或网络I/O的频率，提高了效率。

• 自动刷新：缓冲字符流通常具有自动刷新缓冲区的功能，当缓冲区满了或者手动刷新时，数据会被写入目标文件。

• 适用于文本数据：缓冲字符流适用于处理文本数据，可以正确处理字符编码，避免字符乱码问题。

现在让我们深入了解如何使用缓冲字符流来处理文本文件。

为什么需要缓冲字符流？

在读写文本文件时，每次读取或写入一个字符可能涉及到磁盘或网络I/O操作，这是相对较慢的。而缓冲字符流通过引入内存缓冲区，可以将多个字符一次性读取或写入缓冲区，然后一次性执行I/O操作。这减少了I/O操作的次数，提高了读写效率。

此外，缓冲字符流还提供了自动刷新缓冲区的功能，这意味着在一定条件下，缓冲区会自动刷新，确保数据被及时写入目标文件，而不需要手动刷新。

综上所述，缓冲字符流具有高效、便捷和安全的特点，因此在处理文本文件时，使用缓冲字符流是一种明智的选择。

如何创建和使用缓冲字符流？

Java提供了两个主要的缓冲字符流类：BufferedReader用于读取文本数据，BufferedWriter用于写入文本数据。让我们分别看看它们的用法。

使用BufferedReader读取文本数据

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

public class ReadTextFile {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上面的示例演示了如何使用BufferedReader来读取文本文件（假设存在名为example.txt的文件）。重要的是要在代码块结束时关闭BufferedReader，这可以通过使用try-with-resources语句来实现。

BufferedReader提供了readLine()方法，它可以一次读取一行文本，并返回一个字符串。通过在循环中反复调用readLine()，我们可以逐行读取整个文本文件。

使用BufferedWriter写入文本数据

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

public class WriteTextFile {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String text = "Hello, World!\nThis is a new line.";
            writer.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的示例演示了如何使用BufferedWriter来写入文本数据到文件（输出文件名为output.txt）。同样，我们使用try-with-resources语句来自动关闭BufferedWriter。

BufferedWriter提供了write()方法，它可以将字符串写入到缓冲区，并在适当的时候刷新缓冲区以将数据写入文件。

字符缓冲流的更多用法

当涉及到更高级的缓冲字符流操作时，有一些技巧和方法可以派上用场，让您的文件处理任务更灵活和高效。以下是一些高级操作的示例：

1. 使用BufferedReader读取指定字符数

除了逐行读取文本，您还可以使用BufferedReader读取指定数量的字符。这对于处理特定格式的文件或需要按字符处理的情况很有用。以下示例演示了如何读取指定数量的字符：

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

public class ReadCharsFromFile {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            char[] buffer = new char[100]; // 读取的字符数量
            int charsRead;
            
            while ((charsRead = reader.read(buffer, 0, buffer.length)) != -1) {
                String text = new String(buffer, 0, charsRead);
                System.out.print(text);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 使用BufferedWriter写入指定字符数

与读取类似，您可以使用BufferedWriter来写入指定数量的字符。这在需要精确控制输出格式或文件结构的情况下非常有用。以下示例演示了如何写入指定数量的字符：

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

public class WriteCharsToFile {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String text = "This is a sample text.";
            char[] charArray = text.toCharArray();
            
            writer.write(charArray, 0, 10); // 写入前10个字符
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 使用LineNumberReader获取行号

如果您需要跟踪文本文件的行号，可以使用LineNumberReader。它是BufferedReader的子类，具有getLineNumber()方法，可以返回当前读取的行号。以下示例演示了如何使用LineNumberReader：

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class ReadWithLineNumber {
    public static void main(String[] args) {
        try (LineNumberReader reader = new LineNumberReader(new FileReader("example.txt"))) {
            String line;
            
            while ((line = reader.readLine()) != null) {
                System.out.println("Line " + reader.getLineNumber() + ": " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. 自定义缓冲区大小

默认情况下，Java缓冲字符流的缓冲区大小是根据系统配置来选择的。但在某些情况下，您可能需要自定义缓冲区大小以满足特定的需求。要自定义缓冲区大小，只需在创建BufferedReader或BufferedWriter时传递一个自定义的char[]数组即可。

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

public class CustomBufferSize {
    public static void main(String[] args) {
        int bufferSize = 1024; // 自定义缓冲区大小为1KB
        char[] buffer = new char[bufferSize];
        
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"), bufferSize)) {
            // 读取操作
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

当使用缓冲字符流时，还有一些高级操作和技巧可以帮助您更有效地处理文本文件。以下是一些更多高级操作：

5. 使用reset()和mark()方法

BufferedReader和BufferedWriter类支持mark()和reset()方法，这些方法允许您在流中标记位置并返回到该位置。这在需要回退或重新处理部分文本时非常有用。以下示例演示了如何使用这些方法：

import java.io.*;

public class MarkAndReset {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            // 读取前10个字符
            char[] buffer = new char[10];
            reader.read(buffer);
            System.out.println("Read 10 chars: " + new String(buffer));

            // 标记当前位置
            reader.mark(10);

            // 再次读取10个字符
            reader.read(buffer);
            System.out.println("Read 10 more chars: " + new String(buffer));

            // 重置到标记位置
            reader.reset();
            reader.read(buffer);
            System.out.println("Read from marked position: " + new String(buffer));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

6. 使用FileReader和FileWriter进行字符文件的读写

尽管BufferedReader和BufferedWriter提供了更高效的缓冲功能，但在某些情况下，直接使用FileReader和FileWriter也是一种有效的选择。这对于处理较小的文本文件或需要特定字符编码的文件很有用。

import java.io.*;

public class FileReaderAndFileWriter {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt");
             FileWriter writer = new FileWriter("output.txt")) {
            int character;
            
            while ((character = reader.read()) != -1) {
                writer.write(character);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7. 使用CharArrayReader和CharArrayWriter

如果您有一个字符数组，并且希望将其视为字符流进行处理，可以使用CharArrayReader和CharArrayWriter。这对于将内存中的字符数据写入文件或从内存中读取字符数据非常有用。

import java.io.*;

public class CharArrayReaderWriter {
    public static void main(String[] args) {
        char[] charArray = "Hello, World!".toCharArray();

        try (CharArrayReader reader = new CharArrayReader(charArray);
             CharArrayWriter writer = new CharArrayWriter()) {
            int character;
            
            while ((character = reader.read()) != -1) {
                writer.write(Character.toUpperCase((char) character));
            }
            
            System.out.println(writer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

8. 使用StringReader和StringWriter

StringReader和StringWriter类允许您将字符串作为字符流进行处理。这对于从字符串中读取或将字符写入字符串非常有用。

import java.io.*;

public class StringReaderWriter {
    public static void main(String[] args) {
        String text = "This is a sample text.";
        
        try (StringReader reader = new StringReader(text);
             StringWriter writer = new StringWriter()) {
            int character;
            
            while ((character = reader.read()) != -1) {
                writer.write(Character.toUpperCase((char) character));
            }
            
            System.out.println(writer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

9. 使用LineNumberReader进行行号追踪

LineNumberReader是BufferedReader的子类，它可以用于追踪读取的文本的行号。这对于需要处理带有行号的文本文件非常有用。

import java.io.*;

public class LineNumberReaderExample {
    public static void main(String[] args) {
        try (LineNumberReader reader = new LineNumberReader(new FileReader("example.txt"))) {
            String line;
            
            while ((line = reader.readLine()) != null) {
                System.out.println("Line " + reader.getLineNumber() + ": " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

10. 使用字符流复制文本文件

字符流非常适合用于文本文件的复制。以下是一个使用字符流复制文本文件的示例：

import java.io.*;

public class CopyTextFile {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String destinationFile = "destination.txt";

        try (BufferedReader reader = new BufferedReader(new FileReader(sourceFile));
             BufferedWriter writer = new BufferedWriter(new FileWriter(destinationFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine(); // 添加换行符
            }
            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这段代码使用了BufferedReader和BufferedWriter来复制文本文件。它逐行读取源文件并逐行写入目标文件，确保保留了源文件的格式和换行符。

11. 使用FileReader和FileWriter

如果您需要以字符流的形式读取或写入文件，可以使用FileReader和FileWriter，它们不带缓冲区，适合处理较小的文件。

import java.io.*;

public class FileReaderWriterExample {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String destinationFile = "destination.txt";

        try (FileReader reader = new FileReader(sourceFile);
             FileWriter writer = new FileWriter(destinationFile)) {
            int character;
            while ((character = reader.read()) != -1) {
                writer.write(character);
            }
            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

12. 使用CharArrayReader和CharArrayWriter

CharArrayReader和CharArrayWriter允许您在内存中操作字符数组，而不必依赖外部文件。这对于临时字符数据的处理非常有用。

import java.io.*;

public class CharArrayReaderWriter {
    public static void main(String[] args) {
        String text = "This is a sample text.";

        try (CharArrayReader reader = new CharArrayReader(text.toCharArray());
             CharArrayWriter writer = new CharArrayWriter()) {
            int character;
            
            while ((character = reader.read()) != -1) {
                writer.write(Character.toUpperCase((char) character));
            }
            
            System.out.println(writer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

13. 使用PipedReader和PipedWriter

PipedReader和PipedWriter允许不同线程之间进行字符数据的通信。一个线程可以写入字符，而另一个线程可以读取。

import java.io.*;

public class PipedReaderWriterExample {
    public static void main(String[] args) {
        try {
            PipedReader reader = new PipedReader();
            PipedWriter writer = new PipedWriter(reader);

            Thread writerThread = new Thread(() -> {
                try {
                    writer.write("Hello from writer!");
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            Thread readerThread = new Thread(() -> {
                try {
                    int data;
                    while ((data = reader.read()) != -1) {
                        System.out.print((char) data);
                    }
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            writerThread.start();
            readerThread.start();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

常见的使用场景和注意事项

常见的使用场景

缓冲字符流通常用于以下情况：

• 逐行读取文本文件：使用BufferedReader逐行读取大型文本文件，例如日志文件或配置文件。

• 写入大量文本数据：使用BufferedWriter写入大量文本数据，以提高写入效率。

• 处理文本文件的特定格式：使用缓冲字符流可以更轻松地处理文本文件的特定格式，例如CSV文件或JSON文件。

注意事项

在使用缓冲字符流时，有一些注意事项需要考虑：

• 及时关闭流：始终在不再需要流时关闭它们，以释放资源。可以使用try-with-resources语句来自动关闭流。

• 处理IOException：缓冲字符流操作可能会引发IOException异常，因此要确保正确地处理异常，例如记录错误日志或向用户显示错误信息。

• 字符编码：确保在创建缓冲字符流时指定正确的字符编码，以避免字符乱码问题。

• 刷新缓冲区：在必要的时候手动刷新缓冲区，或者使用具有自动刷新功能的缓冲字符流。

• 适用于文本数据：缓冲字符流适用于处理文本数据，如果需要处理二进制数据，请使用缓冲字节流。

结论

缓冲字符流是Java中用于处理文本文件的强大工具，它们提供了高效的读写操作、自动刷新缓冲区的功能以及字符编码处理。通过使用BufferedReader和BufferedWriter，您可以更轻松地处理文本数据，提高效率，并编写更可靠的文件处理代码。

希望这篇博客能帮助您更好地理解和使用Java缓冲字符流，让您的文本文件处理变得更加高效和便捷。