Java BufferedReader

最新推荐文章于 2025-03-05 22:24:26 发布

cunchi4221

最新推荐文章于 2025-03-05 22:24:26 发布

阅读量2.1k

点赞数 2

文章标签： java python jvm linux 大数据

原文链接：https://www.journaldev.com/19879/java-bufferedreader

版权

Java BufferedReader class is a part of java.io package.

Java BufferedReader类是java.io包的一部分。

BufferedReader is a sub class of java.io.Reader class.

BufferedReader是java.io.Reader类的子类。

Java BufferedReader (Java BufferedReader)

BufferedReader reads text from a character –input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
BufferedReader从字符输入流中读取文本，缓冲字符，以便有效读取字符，数组和行。
The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
可以指定缓冲区大小，也可以使用默认大小。对于大多数用途，默认值足够大。
Compared to FileReader, BufferedReader read relatively large chunks of data from a file at once and keep this data in a buffer. When you ask for the next character or line of data, it is retrieved from the buffer, which reduces the number of times that time-intensive, file-read operations are performed.
与FileReader相比，BufferedReader一次从文件读取相对较大的数据块，并将此数据保留在缓冲区中。当您要求输入下一个字符或数据行时，将从缓冲区中检索它，这减少了执行耗时的文件读取操作的次数。
In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream. It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReader and InputStreamReader. For example;
```
BufferedReader in = new BufferedReader(new FileReader("file.txt"));
```
Above code will buffer the input from the specified file. Without buffering, each invocation of read() or readLine() could cause bytes to be read from the file, converted into characters, and then returned, which can be very inefficient.
BufferedReader包装在其read()操作可能会很昂贵的任何Reader周围，例如FileReader和InputStreamReader 。例如;
```
BufferedReader in = new BufferedReader(new FileReader("file.txt"));
```
上面的代码将缓冲来自指定文件的输入。如果不进行缓冲，则每次调用read()或readLine()导致从文件中读取字节，将其转换为字符，然后返回，这可能会非常低效。

Java BufferedReader构造函数 (Java BufferedReader Constructors)

BufferedReader(Reader in): Creates a buffering character-input stream that uses a default-sized input buffer with specified Reader object.
BufferedReader(Reader in) ：创建一个缓冲字符输入流，该流使用带有指定Reader对象的默认大小的输入缓冲区。
BufferedReader(Reader in, int sz): Creates a buffering character-input stream that uses an input buffer of the specified size with specified Reader object.
BufferedReader(Reader in, int sz) ：创建一个缓冲字符输入流，该流使用具有指定Reader对象的指定大小的输入缓冲区。

Java BufferedReader示例 (Java BufferedReader Example)

Let’s have a look at important methods of BufferedReader class.

让我们看一下BufferedReader类的重要方法。

read(): This method reads a single character and it returns the character as an integer in the range 0 to 65535 (0x00-0xffff), or -1 if the end of the stream has been reached.

package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader Read method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderReadExample {

	public static void main(String[] args) {
		BufferedReader bufferedReader = null;
		FileReader fileReader = null;
		try {
			fileReader = new FileReader("D:/data/file.txt");
			bufferedReader = new BufferedReader(fileReader);
			
			int val = 0;
			while ((val = bufferedReader.read()) != -1) {
				char c = (char) val;
				//prints the character
				System.out.print(c);
			}
					
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if (fileReader != null) {
				try {
					fileReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if (bufferedReader != null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

}

BufferedReader implements AutoCloseable interface, hence we can use try with resource while using BufferedReader class.

Let’s have look at the below example program.

read() ：此方法读取单个字符，并以整数形式返回该字符，范围为0到65535（0x00-0xffff）；如果已到达流的末尾，则返回-1。

package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader Read method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderReadExample {

	public static void main(String[] args) {
		BufferedReader bufferedReader = null;
		FileReader fileReader = null;
		try {
			fileReader = new FileReader("D:/data/file.txt");
			bufferedReader = new BufferedReader(fileReader);
			
			int val = 0;
			while ((val = bufferedReader.read()) != -1) {
				char c = (char) val;
				//prints the character
				System.out.print(c);
			}
					
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if (fileReader != null) {
				try {
					fileReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if (bufferedReader != null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

}

BufferedReader实现了AutoCloseable接口，因此我们在使用BufferedReader类时可以尝试使用资源。

让我们看下面的示例程序。

read(char[] cbuf, int off, int len): This methods reads character into specified array. It attempts to read as many characters as possible by repeatedly invoking the read method of the underlying stream. This iterated read continues until one of the following conditions becomes true:
1. The specified number of characters have been read
2. The read() method of the underlying stream returns -1, indicating end-of-file
3. The ready() method of the underlying stream returns false, indicating that further input requests would block.
If the first read on the underlying stream returns -1 to indicate end-of-file then this method returns -1. Otherwise this method returns the number of characters actually read.
```
package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader read(char[] cbuf, int off, int len) method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderReadUsingArray {

	public static void main(String[] args) {
		try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/data/file.txt"))){
			
			char[] array = new char[10];
			//read into array
			bufferedReader.read(array, 0, 5);
			for (char c : array) {
				 // if char is empty
	            if(c == (char)0) {
	               c = '*';
	            }
	            // prints characters
	            System.out.print(c);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
```
read(char[] cbuf, int off, int len) ：此方法将字符读取到指定数组中。它试图通过重复调用基础流的read方法来读取尽可能多的字符。重复进行此迭代读取，直到满足以下条件之一：
1. 已读取指定数量的字符
2. 基础流的read（）方法返回-1，表示文件结束
3. 基础流的ready（）方法返回false，指示其他输入请求将被阻塞。
如果对基础流的第一次读取返回-1表示文件结束，则此方法返回-1。否则，此方法返回实际读取的字符数。
readLine(): This method reads a line of text. A line is considered to be terminated by any one of a line feed (‘\n’), a carriage return (‘\r’), or a carriage return followed immediately by a line feed and it returns a String containing the contents of the line, not including any line-termination characters, or null if the end of the stream has been reached.
```
package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader readLine() method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderReadLineExample {

	public static void main(String[] args) {
		String line = null;
		try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/data/file.txt"))){
			while ((line = bufferedReader.readLine()) != null) {
				System.out.println(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}
```
readLine() ：此方法读取一行文本。某行被认为由换行符（'\ n'），回车符（'\ r'）或回车符（紧随换行符）中的任何一个终止，并且它返回包含以下内容的String该行，不包括任何行终止符；如果已到达流的末尾，则为null。
ready(): This method checks whether this stream is ready to be read. A buffered character stream is ready if the buffer is not empty, or if the underlying character stream is ready and it returns true if the next read() is guaranteed not to block for input else returns false. Note that returning false does not guarantee that the next read will block.
```
package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader ready method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderReadyExample {

	public static void main(String[] args) {
		try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/data/file.txt"))){
			//check of ready
			if (bufferedReader.ready()) {
				int val = 0;
				while ((val = bufferedReader.read()) != -1) {
					char c = (char) val;
					//prints the character
					System.out.print(c);
				}	
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}
```
ready() ：此方法检查此流是否已准备好被读取。如果缓冲区不为空，或者如果基础字符流已准备好，则缓冲的字符流已准备就绪，并且如果保证下一个read()不会阻塞输入，则返回true，否则返回false。请注意，返回false不能保证下一次读取将被阻止。

skip(long n): This method skips the specified number character and returns the number of character actually skipped. It will throw an IllegalArgumentException if n is negative.

package com.journaldev.examples;

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

/**
 * Java Read file using BufferedReader skip method
 * 
 * @author pankaj
 *
 */
public class BufferedReaderSkipExample {

	public static void main(String[] args) {
		try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/data/file.txt"))) {
			// skip 5 character
			bufferedReader.skip(5);
			System.out.println(bufferedReader.readLine());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

Also check java read text file for more about how to read text file in java.

skip(long n) ：此方法跳过指定的数字字符，并返回实际跳过的字符数。如果n为负数，它将抛出IllegalArgumentException 。

还要检查Java读取文本文件，以获取有关如何在Java中读取文本文件的更多信息。

BufferedReader与扫描仪 (BufferedReader vs Scanner)

BufferedReader is synchronized while the Scanner is not.
BufferedReader同步，而Scanner不同步。
BufferedReader has big sized (8KB byte buffer) buffer while Scanner has small (1KB char buffer) buffer.
BufferedReader具有较大的缓冲区（8KB字节缓冲区），而Scanner具有较小的缓冲区（1KB char缓冲区）。
BufferedReader is faster compared to Scanner.
BufferedReader比Scanner更快。
Scanner parses the token from contents of the stream while BufferedReader only reads the stream.
扫描器从流的内容中解析令牌，而BufferedReader仅读取流。

That’s all for Java BufferedReader, I hope nothing important got missed here.

这就是Java BufferedReader的全部内容，我希望这里不会错过任何重要的事情。

Reference: Java doc

参考： Java文档