* The buffer size may be specified, or the default size may be used. The default is large enough for most purposes. * *
* 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 FileReaders and InputStreamReaders. For example, * *
* BufferedReader in = new BufferedReader(new FileReader("foo.in"));
*
*
* 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.
*
* * Programs that use DataInputStreams for textual input can be localized by replacing each DataInputStream with an * appropriate BufferedReader. * * @see InputStreamReader * * @author Mark Reinhold * @since JDK1.1 */ public class BufferedReader extends Reader { @Nullable private Reader in; @Nullable private char cb[]; private int nChars, nextChar; private static final int INVALIDATED = -2; private static final int UNMARKED = -1; private int markedChar = UNMARKED; private int readAheadLimit = 0; /* Valid only when markedChar > 0 */ /** If the next character is a line feed, skip it */ private boolean skipLF = false; /** The skipLF flag when the mark was set */ private boolean markedSkipLF = false; private static int defaultCharBufferSize = 8192; private static int defaultExpectedLineLength = 80; /** * 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; this.cb = new char[sz]; this.nextChar = this.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); } /** Checks to make sure that the stream has not been closed */ private void ensureOpen() throws IOException { if (this.in == null) { throw new IOException("Stream closed"); } } /** * Fills the input buffer, taking the mark into account if it is valid. */ private void fill() throws IOException { char[] cb = this.cb; assert cb != null; Reader in = this.in; assert in != null; int dst; if (this.markedChar <= UNMARKED) { /* No mark */ dst = 0; } else { /* Marked */ int delta = this.nextChar - this.markedChar; if (delta >= this.readAheadLimit) { /* Gone past read-ahead limit: Invalidate mark */ this.markedChar = INVALIDATED; this.readAheadLimit = 0; dst = 0; } else { if (this.readAheadLimit <= cb.length) { /* Shuffle in the current buffer */ System.arraycopy(cb, this.markedChar, cb, 0, delta); this.markedChar = 0; dst = delta; } else { /* Reallocate buffer to accommodate read-ahead limit */ char ncb[] = new char[this.readAheadLimit]; System.arraycopy(cb, this.markedChar, ncb, 0, delta); this.cb = ncb; this.markedChar = 0; dst = delta; } this.nextChar = this.nChars = delta; } } int n; do { n = in.read(cb, dst, cb.length - dst); } while (n == 0); if (n > 0) { this.nChars = dst + n; this.nextChar = dst; } } /** * Reads a single character. * * @return The character read, as an integer in the range 0 to 65535 (0x00-0xffff), or -1 if the end of the * stream has been reached * @exception IOException * If an I/O error occurs */ @Override public int read() throws IOException { synchronized (this.lock) { ensureOpen(); char[] cb = this.cb; assert cb != null; for (;;) { if (this.nextChar >= this.nChars) { fill(); if (this.nextChar >= this.nChars) { return -1; } } if (this.skipLF) { this.skipLF = false; if (cb[this.nextChar] == '\n') { this.nextChar++; continue; } } return cb[this.nextChar++]; } } } /** * Reads characters into a portion of an array, reading from the underlying stream if necessary. */ private int read1(char[] cbuf, int off, int len) throws IOException { char[] cb = this.cb; assert cb != null; Reader in = this.in; assert in != null; if (this.nextChar >= this.nChars) { /* * If the requested length is at least as large as the buffer, and if there is no mark/reset activity, and * if line feeds are not being skipped, do not bother to copy the characters into the local buffer. In this * way buffered streams will cascade harmlessly. */ if (len >= cb.length && this.markedChar <= UNMARKED && !this.skipLF) { return in.read(cbuf, off, len); } fill(); } if (this.nextChar >= this.nChars) { return -1; } if (this.skipLF) { this.skipLF = false; if (cb[this.nextChar] == '\n') { this.nextChar++; if (this.nextChar >= this.nChars) { fill(); } if (this.nextChar >= this.nChars) { return -1; } } } int n = Math.min(len, this.nChars - this.nextChar); System.arraycopy(cb, this.nextChar, cbuf, off, n); this.nextChar += n; return n; } /** * Reads characters into a portion of an array. * *
* This method implements the general contract of the corresponding
* {@link Reader#read(char[], int, int) read} method of the {@link Reader} class. As an
* additional convenience, 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:
*
read method of the underlying stream returns -1, indicating end-of-file, or
*
* ready method of the underlying stream returns false, indicating that further
* input requests would block.
*
* 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.
*
* * Subclasses of this class are encouraged, but not required, to attempt to read as many characters as possible in * the same fashion. * *
* Ordinarily this method takes characters from this stream's character buffer, filling it from the underlying
* stream as necessary. If, however, the buffer is empty, the mark is not valid, and the requested length is at
* least as large as the buffer, then this method will read characters directly from the underlying stream into the
* given array. Thus redundant BufferedReaders will not copy data unnecessarily.
*
* @param cbuf
* Destination buffer
* @param off
* Offset at which to start storing characters
* @param len
* Maximum number of characters to read
*
* @return The number of characters read, or -1 if the end of the stream has been reached
*
* @exception IOException
* If an I/O error occurs
*/
@Override
public int read(char cbuf[], int off, int len) throws IOException {
synchronized (this.lock) {
ensureOpen();
if ((off < 0) || (off > cbuf.length) || (len < 0) || ((off + len) > cbuf.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int n = read1(cbuf, off, len);
if (n <= 0) {
return n;
}
Reader in = this.in;
assert in != null;
while ((n < len) && in.ready()) {
int n1 = read1(cbuf, off + n, len - n);
if (n1 <= 0) {
break;
}
n += n1;
}
return n;
}
}
/**
* 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 linefeed.
*
* @param ignoreLF
* If true, the next '\n' will be skipped
*
* @return 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
*
* @see java.io.LineNumberReader#readLine()
*
* @exception IOException
* If an I/O error occurs
*/
@Nullable
String readLine(boolean ignoreLF) throws IOException {
StringBuffer s = null;
int startChar;
synchronized (this.lock) {
ensureOpen();
boolean omitLF = ignoreLF || this.skipLF;
bufferLoop: for (;;) {
if (this.nextChar >= this.nChars) {
fill();
}
if (this.nextChar >= this.nChars) { /* EOF */
if (s != null && s.length() > 0) {
return s.toString();
} else {
return null;
}
}
boolean eol = false;
char c = 0;
int i;
char[] cb = this.cb;
assert cb != null;
/* Skip a leftover '\n', if necessary */
if (omitLF && (cb[this.nextChar] == '\n')) {
this.nextChar++;
}
this.skipLF = false;
omitLF = false;
charLoop: for (i = this.nextChar; i < this.nChars; i++) {
c = cb[i];
if ((c == '\n') || (c == '\r')) {
eol = true;
break charLoop;
}
}
startChar = this.nextChar;
this.nextChar = i;
if (eol) {
String str;
if (s == null) {
str = new String(cb, startChar, i - startChar);
} else {
s.append(cb, startChar, i - startChar);
str = s.toString();
}
this.nextChar++;
if (c == '\r') {
this.skipLF = true;
}
return str;
}
if (s == null) {
s = new StringBuffer(defaultExpectedLineLength);
}
s.append(cb, startChar, i - startChar);
}
}
}
/**
* 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 linefeed.
*
* @return 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
*
* @exception IOException
* If an I/O error occurs
*/
@Nullable
public String readLine() throws IOException {
return readLine(false);
}
/**
* Skips characters.
*
* @param n
* The number of characters to skip
*
* @return The number of characters actually skipped
*
* @exception IllegalArgumentException
* If n is negative.
* @exception IOException
* If an I/O error occurs
*/
@Override
public long skip(long n) throws IOException {
if (n < 0L) {
throw new IllegalArgumentException("skip value is negative");
}
synchronized (this.lock) {
ensureOpen();
long r = n;
while (r > 0) {
if (this.nextChar >= this.nChars) {
fill();
}
if (this.nextChar >= this.nChars) {
break;
}
if (this.skipLF) {
this.skipLF = false;
char[] cb = this.cb;
assert cb != null;
if (cb[this.nextChar] == '\n') {
this.nextChar++;
}
}
long d = this.nChars - this.nextChar;
if (r <= d) {
this.nextChar += r;
r = 0;
break;
} else {
r -= d;
this.nextChar = this.nChars;
}
}
return n - r;
}
}
/**
* Tells 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.
*
* @exception IOException
* If an I/O error occurs
*/
@Override
public boolean ready() throws IOException {
synchronized (this.lock) {
ensureOpen();
/*
* If newline needs to be skipped and the next char to be read is a newline character, then just skip it
* right away.
*/
Reader in = this.in;
assert in != null;
if (this.skipLF) {
/*
* Note that in.ready() will return true if and only if the next read on the stream will not block.
*/
if (this.nextChar >= this.nChars && in.ready()) {
fill();
}
if (this.nextChar < this.nChars) {
char[] cb = this.cb;
assert cb != null;
if (cb[this.nextChar] == '\n') {
this.nextChar++;
}
this.skipLF = false;
}
}
return (this.nextChar < this.nChars) || in.ready();
}
}
/**
* Tells whether this stream supports the mark() operation, which it does.
*/
@Override
public boolean markSupported() {
return true;
}
/**
* Marks the present position in the stream. Subsequent calls to reset() will attempt to reposition the stream to
* this point.
*
* @param readAheadLimit
* Limit on the number of characters that may be read while still preserving the mark. An attempt to
* reset the stream after reading characters up to this limit or beyond may fail. A limit value larger
* than the size of the input buffer will cause a new buffer to be allocated whose size is no smaller
* than limit. Therefore large values should be used with care.
*
* @exception IllegalArgumentException
* If {@code readAheadLimit < 0}
* @exception IOException
* If an I/O error occurs
*/
@Override
public void mark(int readAheadLimit) throws IOException {
if (readAheadLimit < 0) {
throw new IllegalArgumentException("Read-ahead limit < 0");
}
synchronized (this.lock) {
ensureOpen();
this.readAheadLimit = readAheadLimit;
this.markedChar = this.nextChar;
this.markedSkipLF = this.skipLF;
}
}
/**
* Resets the stream to the most recent mark.
*
* @exception IOException
* If the stream has never been marked, or if the mark has been invalidated
*/
@Override
public void reset() throws IOException {
synchronized (this.lock) {
ensureOpen();
if (this.markedChar < 0) {
throw new IOException((this.markedChar == INVALIDATED) ? "Mark invalid" : "Stream not marked");
}
this.nextChar = this.markedChar;
this.skipLF = this.markedSkipLF;
}
}
@Override
public void close() throws IOException {
synchronized (this.lock) {
Reader in = this.in;
if (in == null) {
return;
}
try {
in.close();
} finally {
this.in = null;
this.cb = null;
}
}
}
}