Java provides many classes for reading and writing text files, where buffered character streams are a very common and efficient way. This blog will introduce the use of Java buffered character streams in detail, including what is buffered character streams, why they are needed, how to create and use buffered character streams, as well as some common usage scenarios and considerations.
What is a buffered character stream?
Before we understand buffered character streams, we need to understand the concepts of character streams and buffered streams.
Character stream: A character stream is an I/O stream used to process character data, usually used to read and write text files. They are read and written in characters and are suitable for operations on text data.
Buffer stream: Buffer stream is the function of adding buffers to a character stream or byte stream. A buffer is a temporary storage area in memory that can reduce the actual number of disk or network I/Os, thereby improving read and write performance.
Buffered character streams are a type of character streams, and they have the following characteristics:
Buffer: The buffered character stream maintains a buffer internally, which can read and write multiple characters at once, reducing the frequency of disk or network I/O and improving efficiency.
Automatic refresh: Buffered character streams usually have the function of automatically refreshing the buffer. When the buffer is full or refreshed manually, the data will be written to the target file.
Suitable for text data: Buffered character streams are suitable for processing text data, which can correctly handle character encoding and avoid garbled character code problems.
Now let's dive into how to use buffered character streams to process text files.
Why do I need to buffer a character stream?
When reading or writing text files, reading or writing one character at a time may involve disk or network I/O operations, which is relatively slow. By introducing a memory buffer, multiple characters can be read or written to the buffer at one time, and then I/O operations can be performed at one time. This reduces the number of I/O operations and improves read and write efficiency.
In addition, the buffered character stream also provides the function of automatically refreshing the buffer, which means that under certain conditions, the buffer will be automatically refreshed to ensure that the data is written to the target file in time without manually refreshing.
To sum up, buffered character streams are efficient, convenient and safe, so using buffered character streams is a wise choice when working with text files.
How to create and use buffered character streams?
Java provides two main buffered character stream classes:BufferedReaderUsed to read text data,BufferedWriterUsed to write text data. Let's take a look at their usage separately.
Read text data using BufferedReader
import ;
import ;
import ;
public class ReadTextFile {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader(""))) {
String line;
while ((line = ()) != null) {
(line);
}
} catch (IOException e) {
();
}
}
}
The above example demonstrates how to use itBufferedReaderTo read the text file (assuming that there is a namefile). It is important to close at the end of the code blockBufferedReader, this can be achieved by using the try-with-resources statement.
BufferedReaderProvidedreadLine()Method, which can read one line of text at a time and return a string. By repeatedly calling in a loopreadLine(), we can read the entire text file line by line.
Write text data using BufferedWriter
import ;
import ;
import ;
public class WriteTextFile {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(""))) {
String text = "Hello, World!\nThis is a new line.";
(text);
} catch (IOException e) {
();
}
}
}
The above example demonstrates how to use itBufferedWriterto write text data to the file (output file name is). Similarly, we use the try-with-resources statement to automatically closeBufferedWriter。
BufferedWriterProvidedwrite()Method, it can write strings to the buffer and flush the buffer when appropriate to write data to the file.
More usages of character buffer streams
When it comes to more advanced buffered character streaming operations, there are tips and methods that can come in handy to make your file processing tasks more flexible and efficient. Here are some examples of advanced operations:
1. Use BufferedReader to read the specified number of characters
In addition to reading text line by line, you can also useBufferedReaderReads a specified number of characters. This is useful for handling files of a specific format or situations where it needs to be processed by character. The following example demonstrates how to read a specified number of characters:
import ;
import ;
import ;
public class ReadCharsFromFile {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader(""))) {
char[] buffer = new char[100]; // Number of characters read int charsRead;
while ((charsRead = (buffer, 0, )) != -1) {
String text = new String(buffer, 0, charsRead);
(text);
}
} catch (IOException e) {
();
}
}
}
2. Use BufferedWriter to write the specified number of characters
Similar to reading, you can useBufferedWriterTo write a specified number of characters. This is useful when precise control of the output format or file structure is required. The following example demonstrates how to write a specified number of characters:
import ;
import ;
import ;
public class WriteCharsToFile {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(""))) {
String text = "This is a sample text.";
char[] charArray = ();
(charArray, 0, 10); // Write the first 10 characters } catch (IOException e) {
();
}
}
}
3. Use LineNumberReader to get the line number
If you need to track the line number of the text file, you can useLineNumberReader. It isBufferedReadersubclass ofgetLineNumber()Method, which can return the currently read line number. The following example demonstrates how to use itLineNumberReader：
import ;
import ;
import ;
public class ReadWithLineNumber {
public static void main(String[] args) {
try (LineNumberReader reader = new LineNumberReader(new FileReader(""))) {
String line;
while ((line = ()) != null) {
("Line " + () + ": " + line);
}
} catch (IOException e) {
();
}
}
}
4. Customize the buffer size
By default, the buffer size of Java buffered character streams is selected according to system configuration. But in some cases, you may need to customize the buffer size to meet specific needs. To customize the buffer size, just create itBufferedReaderorBufferedWriterPass a customchar[]Just array.
import ;
import ;
import ;
public class CustomBufferSize {
public static void main(String[] args) {
int bufferSize = 1024; // Custom buffer size is 1KB char[] buffer = new char[bufferSize];
try (BufferedReader reader = new BufferedReader(new FileReader(""), bufferSize)) {
// Read operation } catch (IOException e) {
();
}
}
}
There are also some advanced operations and tricks to help you process text files more efficiently when using buffered character streams. Here are some more advanced operations:
5. Use reset() and mark() methods
BufferedReaderandBufferedWriterClass Supportmark()andreset()Methods, These methods allow you to mark a position in the stream and return to that position. This is useful when you need to fall back or reprocess part of the text. The following example demonstrates how to use these methods:
import .*;
public class MarkAndReset {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader(""))) {
// Read the first 10 characters char[] buffer = new char[10];
(buffer);
("Read 10 chars: " + new String(buffer));
// Mark the current location (10);
// Read 10 characters again (buffer);
("Read 10 more chars: " + new String(buffer));
// Reset to mark position ();
(buffer);
("Read from marked position: " + new String(buffer));
} catch (IOException e) {
();
}
}
}
6. Use FileReader and FileWriter to read and write character files
althoughBufferedReaderandBufferedWriterProvides more efficient buffering, but in some cases, use directlyFileReaderandFileWriterIt is also an effective choice. This is useful for handling smaller text files or files that require specific character encoding.
import .*;
public class FileReaderAndFileWriter {
public static void main(String[] args) {
try (FileReader reader = new FileReader("");
FileWriter writer = new FileWriter("")) {
int character;
while ((character = ()) != -1) {
(character);
}
} catch (IOException e) {
();
}
}
}
7. Use CharArrayReader and CharArrayWriter
If you have an array of characters and want to treat it as a character stream, you can useCharArrayReaderandCharArrayWriter. This is useful for writing character data in memory to a file or reading character data from memory.
import .*;
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 = ()) != -1) {
(((char) character));
}
(());
} catch (IOException e) {
();
}
}
}
8. Use StringReader and StringWriter
StringReaderandStringWriterThe class allows you to process strings as a character stream. This is useful for reading from a string or writing characters to a string.
import .*;
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 = ()) != -1) {
(((char) character));
}
(());
} catch (IOException e) {
();
}
}
}
9. Use LineNumberReader for line number tracking
LineNumberReaderyesBufferedReadersubclass of , which can be used to track the line number of read text. This is very useful for text files that need to be processed with line numbers.
import .*;
public class LineNumberReaderExample {
public static void main(String[] args) {
try (LineNumberReader reader = new LineNumberReader(new FileReader(""))) {
String line;
while ((line = ()) != null) {
("Line " + () + ": " + line);
}
} catch (IOException e) {
();
}
}
}
10. Copy text files using character streams
Character streams are ideal for copying text files. Here is an example of copying text files using character streams:
import .*;
public class CopyTextFile {
public static void main(String[] args) {
String sourceFile = "";
String destinationFile = "";
try (BufferedReader reader = new BufferedReader(new FileReader(sourceFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(destinationFile))) {
String line;
while ((line = ()) != null) {
(line);
(); // Add line breaks }
("File copied successfully.");
} catch (IOException e) {
();
}
}
}
This code usesBufferedReaderandBufferedWriterto copy the text file. It reads the source file line by line and writes it to the target file line by line, ensuring that the source file format and line newline characters are retained.
11. Using FileReader and FileWriter
If you need to read or write a file as a character stream, you can useFileReaderandFileWriter, they do not have buffers and are suitable for handling smaller files.
import .*;
public class FileReaderWriterExample {
public static void main(String[] args) {
String sourceFile = "";
String destinationFile = "";
try (FileReader reader = new FileReader(sourceFile);
FileWriter writer = new FileWriter(destinationFile)) {
int character;
while ((character = ()) != -1) {
(character);
}
("File copied successfully.");
} catch (IOException e) {
();
}
}
}
12. Using CharArrayReader and CharArrayWriter
CharArrayReaderandCharArrayWriterAllows you to manipulate character arrays in memory without having to rely on external files. This is very useful for processing temporary character data.
import .*;
public class CharArrayReaderWriter {
public static void main(String[] args) {
String text = "This is a sample text.";
try (CharArrayReader reader = new CharArrayReader(());
CharArrayWriter writer = new CharArrayWriter()) {
int character;
while ((character = ()) != -1) {
(((char) character));
}
(());
} catch (IOException e) {
();
}
}
}
13. Using PipedReader and PipedWriter
PipedReaderandPipedWriterAllows communication of character data between different threads. One thread can write characters, while another thread can read.
import .*;
public class PipedReaderWriterExample {
public static void main(String[] args) {
try {
PipedReader reader = new PipedReader();
PipedWriter writer = new PipedWriter(reader);
Thread writerThread = new Thread(() -> {
try {
("Hello from writer!");
();
} catch (IOException e) {
();
}
});
Thread readerThread = new Thread(() -> {
try {
int data;
while ((data = ()) != -1) {
((char) data);
}
();
} catch (IOException e) {
();
}
});
();
();
} catch (IOException e) {
();
}
}
}
Common usage scenarios and precautions
Common usage scenarios
Buffered character streams are usually used in the following situations:
Read text files line by line: Use
BufferedReaderRead large text files line by line, such as log files or configuration files.Write large amounts of text data: use
BufferedWriterWrite large amounts of text data to improve writing efficiency.Processing specific formats for text files: Using buffered character streams makes it easier to process specific formats for text files, such as CSV files or JSON files.
Things to note
There are some things to consider when using buffered character streams:
Close the flow in time: Always close streams when they are no longer needed to free up resources. You can use the try-with-resources statement to automatically close the stream.
Handle IOException: Buffered character stream operations may throw IOException exceptions, so make sure that exceptions are handled correctly, such as logging error logs or displaying error messages to the user.
Character encoding: Make sure to specify the correct character encoding when creating a buffered character stream to avoid garbled character code issues.
Refresh the buffer: Manually refresh the buffer when necessary, or use a buffered character stream with automatic refresh function.
Applicable to text data: Buffered character streams are suitable for processing text data. If binary data needs to be processed, use buffered byte streams.
in conclusion
Buffered character streams are powerful tools in Java for processing text files. They provide efficient read and write operations, automatic buffer refresh function, and character encoding processing. By usingBufferedReaderandBufferedWriter, you can process text data more easily, improve efficiency, and write more reliable file processing code.
This is the end of this article about Java buffered character stream implementation examples. For more related Java buffered character stream content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!