Java IO learning summary (1) Input stream/output stream
Java IO learning summary (2) File class
Java IO learning summary (3) BufferedInputStream
Java IO learning summary (4) BufferedReader buffered character stream
Java IO learning summary (5) OutputStreamWriter
Foreword:
Learn IO flows, record and share. If there are any errors in the article, please correct me.
Class Diagram:
1. What is BufferedReader?
BufferedReader is a buffered character input stream. This stream can wrap FileRead , provide a cache array, and read data into the cache area according to certain rules at a time. Each time the input stream reads file data, the data needs to be character-encoded. , and the emergence of BufferedReader reduces the number of times the input stream accesses the data source , reads data of a certain size into the buffer area at one time and performs character encoding, thereby improving IO efficiency.
2. Why use BufferedReader?
BufferedReader reads text from a character input stream, buffering characters for efficient reading of characters, arrays, and lines. The buffer size can be specified or the default size (8192) can be used . The default value is large enough for most purposes .
Generally speaking, each read request issued to a Reader results in a corresponding read request to the underlying character or byte stream. Therefore, it is recommended to wrap a BufferedReader around any Reader whose read() operation may be expensive (such as FileReaders and InputStreamReaders).
For example:
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
Will buffer input from the specified file. Without buffering, each call to read() or readLine() could result in bytes being read from the file, converted to characters, and then returned, which could be very inefficient.
Programs that use DataInputStreams for text input can be localized by replacing each DataInputStream with the appropriate BufferedReader.
3. Constructor of BufferedReader
/**
* Creates a buffering character-input stream that uses an input buffer of
* the specified size.
*
* @param in A Reader
* @param sz Input-buffer size
*
* @exception IllegalArgumentException If {@code sz <= 0}
*/
public BufferedReader(Reader in, int sz) {
super(in);
if (sz <= 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.in = in;
cb = new char[sz];
nextChar = nChars = 0;
}
/**
* Creates a buffering character-input stream that uses a default-sized
* input buffer.
*
* @param in A Reader
*/
public BufferedReader(Reader in) {
this(in, defaultCharBufferSize);
}
Brief analysis of constructor:
public BufferedReader(Reader in, int sz); // 创建一个BufferedRead 缓冲字符流对象，使用指定大小的缓存区。
public BufferedReader(Reader in); // 创建一个BufferedRead 缓冲字符流对象，使用默认大小（8192）的缓存区。
4. Public methods of BufferedReader
int read(); // 读取单个字符。
int read(char[] cbuf, int off, int len); // 将指定范围内的字符读入数组。
String readLine(); // 读取一个文本行。
boolean ready(); // 判断此流是否可读。
void reset(); // 将流重置到最新的标记。
long skip(long n); // 跳过字符。
void close(); // 关闭该流并释放与之关联的所有资源。
void mark(int readAheadLimit); // 标记流中的当前位置。
boolean markSupported(); // 判断此流是否支持 mark() 操作（它一定支持）。
5. Actual combat
How to use BufferedReader
uses buffered character input/output streams to copy a file from disk A to disk B.
public class TestBufferedReadAndWrite {
public static void main(String[] args) {
copyFile();
}
/**
* 使用缓冲字符输入/输出流，将A磁盘的某文件复制到B磁盘中。
* <p>
* throws FileNotFoundException 创建输入流，如果根据路径找不到文件，可能会抛出这个异常
* throws IOException 写入数据到目标文件中失败，调用 close() 关闭流，可能会抛出这个异常
*/
private static void copyFile() {
// 文件信息
String sourceFilePath = "D:/test/gls.txt";
String targetFilePath = "D:/test/success/Writer.txt";
// 输入流/输出流
Reader reader = null;
BufferedReader bufferedReader = null;
Writer writer = null;
BufferedWriter bufferedWriter = null;
try {
// 输入流
reader = new FileReader(sourceFilePath);
// 使用默认的缓冲区大小来创建缓冲字符输入流，默认大小为8192个字符
bufferedReader = new BufferedReader(reader);
// 输出流
writer = new FileWriter(targetFilePath);
bufferedWriter = new BufferedWriter(writer);
String result = "";
while ((result = bufferedReader.readLine()) != null) {
writer.write(result); // 把内容写入文件
bufferedWriter.newLine(); // 换行 result 是一行数据，所以每写一行就要换行
}
writer.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
throw new RuntimeException(e);
} catch (IOException e) { // new FileWriter();
e.printStackTrace();
throw new RuntimeException(e);
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
System.out.println("执行完成！");
}
}
public class TestBufferedReadAndWrite {
public static void main(String[] args) {
copyFile();
}
/**
* 使用缓冲字符输入/输出流，将A磁盘的某文件复制到B磁盘中。
* <p>
* throws FileNotFoundException 创建输入流，如果根据路径找不到文件，可能会抛出这个异常
* throws IOException 写入数据到目标文件中失败，调用 close() 关闭流，可能会抛出这个异常
*/
private static void copyFile() {
// 文件信息
String sourceFilePath = "D:/test/gls.txt";
String targetFilePath = "D:/test/success/Writer.txt";
// 输入流/输出流
Reader reader = null;
BufferedReader bufferedReader = null;
Writer writer = null;
BufferedWriter bufferedWriter = null;
try {
// 输入流
reader = new FileReader(sourceFilePath);
// 使用默认的缓冲区大小来创建缓冲字符输入流，默认大小为8192个字符
bufferedReader = new BufferedReader(reader);
// 输出流
writer = new FileWriter(targetFilePath);
bufferedWriter = new BufferedWriter(writer);
String result = "";
while ((result = bufferedReader.readLine()) != null) {
writer.write(result); // 把内容写入文件
bufferedWriter.newLine(); // 换行 result 是一行数据，所以每写一行就要换行
}
writer.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
throw new RuntimeException(e);
} catch (IOException e) { // new FileWriter();
e.printStackTrace();
throw new RuntimeException(e);
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
System.out.println("执行完成！");
}
}
public class TestBufferedReadAndWrite {
public static void main(String[] args) {
copyFile();
}
/**
* 使用缓冲字符输入/输出流，将A磁盘的某文件复制到B磁盘中。
* <p>
* throws FileNotFoundException 创建输入流，如果根据路径找不到文件，可能会抛出这个异常
* throws IOException 写入数据到目标文件中失败，调用 close() 关闭流，可能会抛出这个异常
*/
private static void copyFile() {
// 文件信息
String sourceFilePath = "D:/test/gls.txt";
String targetFilePath = "D:/test/success/Writer.txt";
// 输入流/输出流
Reader reader = null;
BufferedReader bufferedReader = null;
Writer writer = null;
BufferedWriter bufferedWriter = null;
try {
// 输入流
reader = new FileReader(sourceFilePath);
// 使用默认的缓冲区大小来创建缓冲字符输入流，默认大小为8192个字符
bufferedReader = new BufferedReader(reader);
// 输出流
writer = new FileWriter(targetFilePath);
bufferedWriter = new BufferedWriter(writer);
String result = "";
while ((result = bufferedReader.readLine()) != null) {
writer.write(result); // 把内容写入文件
bufferedWriter.newLine(); // 换行 result 是一行数据，所以每写一行就要换行
}
writer.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
throw new RuntimeException(e);
} catch (IOException e) { // new FileWriter();
e.printStackTrace();
throw new RuntimeException(e);
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
System.out.println("执行完成！");
}
}
Java IO learning summary (5) is being improved and will be updated later~