java.io
public abstract class Reader extends Object implements Closeable, Readable
Modifier and Type | Field and Description |
---|---|
protected Object |
lock
This is the
Object used for synchronizing critical code
sections. |
Modifier | Constructor and Description |
---|---|
protected |
Reader()
Unitializes a
Reader that will use the object
itself for synchronization of critical code sections. |
protected |
Reader(Object lock)
Initializes a
Reader that will use the specified
Object for synchronization of critical code sections. |
Modifier and Type | Method and Description |
---|---|
abstract void |
close()
Closes the stream.
|
void |
mark(int readLimit)
Marks a position in the input to which the stream can be
"reset" by calling the
reset() method. |
boolean |
markSupported()
Returns a boolean that indicates whether the mark/reset
methods are supported in this class.
|
int |
read()
Reads an char from the input stream and returns it
as an int in the range of 0-65535.
|
int |
read(char[] buf)
Reads chars from a stream and stores them into a caller
supplied buffer.
|
abstract int |
read(char[] buf,
int offset,
int count)
Read chars from a stream and stores them into a caller
supplied buffer.
|
int |
read(CharBuffer buffer)
Adds the character data supplied by this
Readable
to the specified character buffer. |
boolean |
ready()
Determines whether or not this stream is ready to be
read.
|
void |
reset()
Resets a stream to the point where the
mark()
method was called. |
long |
skip(long count)
Skips the specified number of chars in the stream.
|
protected Reader()
Reader
that will use the object
itself for synchronization of critical code sections.public abstract int read(char[] buf, int offset, int count) throws IOException
offset
into the buffer and attempts to read len
chars. This method
can return before reading the number of chars requested. The actual
number of chars read is returned as an int. A -1 is returned to indicate
the end of the stream.
This method will block until some data can be read.
This method operates by calling the single char read()
method
in a loop until the desired number of chars are read. The read loop
stops short if the end of the stream is encountered or if an IOException
is encountered on any read operation except the first. If the first
attempt to read a chars fails, the IOException is allowed to propagate
upward. And subsequent IOException is caught and treated identically
to an end of stream condition. Subclasses can (and should if possible)
override this method to provide a more efficient implementation.
buf
- The array into which the chars read should be storedoffset
- The offset into the array to start storing charscount
- The requested number of chars to readIOException
- If an error occurs.public int read(char[] buf) throws IOException
This method will block until some data can be read.
This method operates by calling an overloaded read method like so:
read(buf, 0, buf.length)
buf
- The buffer into which the chars read will be stored.IOException
- If an error occurs.public int read() throws IOException
This method will block until the char can be read.
IOException
- If an error occurspublic int read(CharBuffer buffer) throws IOException
Readable
Readable
to the specified character buffer. This method simply places
each character into the buffer as supplied, using put()
,
without flipping or rewinding.read
in interface Readable
buffer
- the buffer to place the character data in.char
values placed in the buffer,
or -1 if no more characters are available.IOException
- if an I/O error occurs.public abstract void close() throws IOException
IOException
.close
in interface Closeable
IOException
- If an error occurspublic boolean markSupported()
This method always returns false
in this class, but
subclasses can override this method to return true
if they
support mark/reset functionality.
true
if mark/reset functionality is supported,
false
otherwisepublic void mark(int readLimit) throws IOException
reset()
method. The parameter
readlimit
is the number of chars that can be read from the
stream after setting the mark before the mark becomes invalid. For
example, if mark()
is called with a read limit of 10, then
when 11 chars of data are read from the stream before the
reset()
method is called, then the mark is invalid and the
stream object instance is not required to remember the mark.readLimit
- The number of chars that can be read before the mark
becomes invalidIOException
- If an error occurs such as mark not being
supported for this classpublic void reset() throws IOException
mark()
method was called. Any chars that were read after the mark point was
set will be re-read during subsequent reads.
This method always throws an IOException in this class, but subclasses can override this method if they provide mark/reset functionality.
IOException
- Always thrown for this classpublic boolean ready() throws IOException
false
the stream may block if a
read is attempted, but it is not guaranteed to do so.
This method always returns false
in this class
true
if the stream is ready to be read,
false
otherwise.IOException
- If an error occurspublic long skip(long count) throws IOException
This method reads and discards chars into a 256 char array until the specified number of chars were skipped or until either the end of stream is reached or a read attempt returns a short count. Subclasses can override this method to provide a more efficient implementation where one exists.
count
- The requested number of chars to skipIOException
- If an error occurs