jdk-sandbox: comparison src/java.base/share/classes/java/io/InputStream.java

equal deleted inserted replaced

-:a7f16447085e
+:48e480e56aad
 /**
 * This abstract class is the superclass of all classes representing
 * an input stream of bytes.
 *
-* <p> Applications that need to define a subclass of <code>InputStream</code>
+* <p> Applications that need to define a subclass of {@code InputStream}
 * must always provide a method that returns the next byte of input.
 *
 * @author  Arthur van Hoff
 * @see     java.io.BufferedInputStream
 * @see     java.io.ByteArrayInputStream
 };
 }
 /**
 * Reads the next byte of data from the input stream. The value byte is
-* returned as an <code>int</code> in the range <code>0</code> to
+* returned as an {@code int} in the range {@code 0} to
-* <code>255</code>. If no byte is available because the end of the stream
+* {@code 255}. If no byte is available because the end of the stream
-* has been reached, the value <code>-1</code> is returned. This method
+* has been reached, the value {@code -1} is returned. This method
 * blocks until input data is available, the end of the stream is detected,
 * or an exception is thrown.
 *
 * <p> A subclass must provide an implementation of this method.
 *
-* @return     the next byte of data, or <code>-1</code> if the end of the
+* @return     the next byte of data, or {@code -1} if the end of the
 *             stream is reached.
 * @throws     IOException  if an I/O error occurs.
 */
 public abstract int read() throws IOException;
 /**
 * Reads some number of bytes from the input stream and stores them into
-* the buffer array <code>b</code>. The number of bytes actually read is
+* the buffer array {@code b}. The number of bytes actually read is
 * returned as an integer.  This method blocks until input data is
 * available, end of file is detected, or an exception is thrown.
 *
-* <p> If the length of <code>b</code> is zero, then no bytes are read and
+* <p> If the length of {@code b} is zero, then no bytes are read and
-* <code>0</code> is returned; otherwise, there is an attempt to read at
+* {@code 0} is returned; otherwise, there is an attempt to read at
 * least one byte. If no byte is available because the stream is at the
-* end of the file, the value <code>-1</code> is returned; otherwise, at
+* end of the file, the value {@code -1} is returned; otherwise, at
-* least one byte is read and stored into <code>b</code>.
+* least one byte is read and stored into {@code b}.
 *
-* <p> The first byte read is stored into element <code>b[0]</code>, the
+* <p> The first byte read is stored into element {@code b[0]}, the
-* next one into <code>b[1]</code>, and so on. The number of bytes read is,
+* next one into {@code b[1]}, and so on. The number of bytes read is,
-* at most, equal to the length of <code>b</code>. Let <i>k</i> be the
+* at most, equal to the length of {@code b}. Let <i>k</i> be the
 * number of bytes actually read; these bytes will be stored in elements
-* <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
+* {@code b[0]} through {@code b[}<i>k</i>{@code -1]},
-* leaving elements <code>b[</code><i>k</i><code>]</code> through
+* leaving elements {@code b[}<i>k</i>{@code ]} through
-* <code>b[b.length-1]</code> unaffected.
+* {@code b[b.length-1]} unaffected.
 *
-* <p> The <code>read(b)</code> method for class <code>InputStream</code>
+* <p> The {@code read(b)} method for class {@code InputStream}
-* has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
+* has the same effect as: <pre>{@code  read(b, 0, b.length) }</pre>
 *
 * @param      b   the buffer into which the data is read.
 * @return     the total number of bytes read into the buffer, or
-*             <code>-1</code> if there is no more data because the end of
+*             {@code -1} if there is no more data because the end of
 *             the stream has been reached.
 * @throws     IOException  If the first byte cannot be read for any reason
 *             other than the end of the file, if the input stream has been
 *             closed, or if some other I/O error occurs.
-* @throws     NullPointerException  if <code>b</code> is <code>null</code>.
+* @throws     NullPointerException  if {@code b} is {@code null}.
 * @see        java.io.InputStream#read(byte[], int, int)
 */
 public int read(byte b[]) throws IOException {
 return read(b, 0, b.length);
 }
 /**
-* Reads up to <code>len</code> bytes of data from the input stream into
+* Reads up to {@code len} bytes of data from the input stream into
 * an array of bytes.  An attempt is made to read as many as
-* <code>len</code> bytes, but a smaller number may be read.
+* {@code len} bytes, but a smaller number may be read.
 * The number of bytes actually read is returned as an integer.
 *
 * <p> This method blocks until input data is available, end of file is
 * detected, or an exception is thrown.
 *
-* <p> If <code>len</code> is zero, then no bytes are read and
+* <p> If {@code len} is zero, then no bytes are read and
-* <code>0</code> is returned; otherwise, there is an attempt to read at
+* {@code 0} is returned; otherwise, there is an attempt to read at
 * least one byte. If no byte is available because the stream is at end of
-* file, the value <code>-1</code> is returned; otherwise, at least one
+* file, the value {@code -1} is returned; otherwise, at least one
-* byte is read and stored into <code>b</code>.
+* byte is read and stored into {@code b}.
 *
-* <p> The first byte read is stored into element <code>b[off]</code>, the
+* <p> The first byte read is stored into element {@code b[off]}, the
-* next one into <code>b[off+1]</code>, and so on. The number of bytes read
+* next one into {@code b[off+1]}, and so on. The number of bytes read
-* is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
+* is, at most, equal to {@code len}. Let <i>k</i> be the number of
 * bytes actually read; these bytes will be stored in elements
-* <code>b[off]</code> through <code>b[off+</code><i>k</i><code>-1]</code>,
+* {@code b[off]} through {@code b[off+}<i>k</i>{@code -1]},
-* leaving elements <code>b[off+</code><i>k</i><code>]</code> through
+* leaving elements {@code b[off+}<i>k</i>{@code ]} through
-* <code>b[off+len-1]</code> unaffected.
+* {@code b[off+len-1]} unaffected.
 *
-* <p> In every case, elements <code>b[0]</code> through
+* <p> In every case, elements {@code b[0]} through
-* <code>b[off-1]</code> and elements <code>b[off+len]</code> through
+* {@code b[off-1]} and elements {@code b[off+len]} through
-* <code>b[b.length-1]</code> are unaffected.
+* {@code b[b.length-1]} are unaffected.
 *
-* <p> The <code>read(b,</code> <code>off,</code> <code>len)</code> method
+* <p> The {@code read(b, off, len)} method
-* for class <code>InputStream</code> simply calls the method
+* for class {@code InputStream} simply calls the method
-* <code>read()</code> repeatedly. If the first such call results in an
+* {@code read()} repeatedly. If the first such call results in an
-* <code>IOException</code>, that exception is returned from the call to
+* {@code IOException}, that exception is returned from the call to
-* the <code>read(b,</code> <code>off,</code> <code>len)</code> method.  If
+* the {@code read(b,} {@code off,} {@code len)} method.  If
-* any subsequent call to <code>read()</code> results in a
+* any subsequent call to {@code read()} results in a
-* <code>IOException</code>, the exception is caught and treated as if it
+* {@code IOException}, the exception is caught and treated as if it
 * were end of file; the bytes read up to that point are stored into
-* <code>b</code> and the number of bytes read before the exception
+* {@code b} and the number of bytes read before the exception
 * occurred is returned. The default implementation of this method blocks
-* until the requested amount of input data <code>len</code> has been read,
+* until the requested amount of input data {@code len} has been read,
 * end of file is detected, or an exception is thrown. Subclasses are
 * encouraged to provide a more efficient implementation of this method.
 *
 * @param      b     the buffer into which the data is read.
-* @param      off   the start offset in array <code>b</code>
+* @param      off   the start offset in array {@code b}
 *                   at which the data is written.
 * @param      len   the maximum number of bytes to read.
 * @return     the total number of bytes read into the buffer, or
-*             <code>-1</code> if there is no more data because the end of
+*             {@code -1} if there is no more data because the end of
 *             the stream has been reached.
 * @throws     IOException If the first byte cannot be read for any reason
 *             other than end of file, or if the input stream has been closed,
 *             or if some other I/O error occurs.
-* @throws     NullPointerException If <code>b</code> is <code>null</code>.
+* @throws     NullPointerException If {@code b} is {@code null}.
-* @throws     IndexOutOfBoundsException If <code>off</code> is negative,
+* @throws     IndexOutOfBoundsException If {@code off} is negative,
-*             <code>len</code> is negative, or <code>len</code> is greater than
+*             {@code len} is negative, or {@code len} is greater than
-*             <code>b.length - off</code>
+*             {@code b.length - off}
 * @see        java.io.InputStream#read()
 */
 public int read(byte b[], int off, int len) throws IOException {
 Objects.checkFromIndexSize(off, len, b.length);
 if (len == 0) {
 }
 return n;
 }
 /**
-* Skips over and discards <code>n</code> bytes of data from this input
+* Skips over and discards {@code n} bytes of data from this input
-* stream. The <code>skip</code> method may, for a variety of reasons, end
+* stream. The {@code skip} method may, for a variety of reasons, end
-* up skipping over some smaller number of bytes, possibly <code>0</code>.
+* up skipping over some smaller number of bytes, possibly {@code 0}.
 * This may result from any of a number of conditions; reaching end of file
-* before <code>n</code> bytes have been skipped is only one possibility.
+* before {@code n} bytes have been skipped is only one possibility.
 * The actual number of bytes skipped is returned. If {@code n} is
 * negative, the {@code skip} method for class {@code InputStream} always
 * returns 0, and no bytes are skipped. Subclasses may handle the negative
 * value differently.
 *
-* <p> The <code>skip</code> method implementation of this class creates a
+* <p> The {@code skip} method implementation of this class creates a
-* byte array and then repeatedly reads into it until <code>n</code> bytes
+* byte array and then repeatedly reads into it until {@code n} bytes
 * have been read or the end of the stream has been reached. Subclasses are
 * encouraged to provide a more efficient implementation of this method.
 * For instance, the implementation may depend on the ability to seek.
 *
 * @param      n   the number of bytes to be skipped.
 /**
 * Closes this input stream and releases any system resources associated
 * with the stream.
 *
-* <p> The <code>close</code> method of <code>InputStream</code> does
+* <p> The {@code close} method of {@code InputStream} does
 * nothing.
 *
 * @throws     IOException  if an I/O error occurs.
 */
 public void close() throws IOException {}
 /**
 * Marks the current position in this input stream. A subsequent call to
-* the <code>reset</code> method repositions this stream at the last marked
+* the {@code reset} method repositions this stream at the last marked
 * position so that subsequent reads re-read the same bytes.
 *
-* <p> The <code>readlimit</code> arguments tells this input stream to
+* <p> The {@code readlimit} arguments tells this input stream to
 * allow that many bytes to be read before the mark position gets
 * invalidated.
 *
-* <p> The general contract of <code>mark</code> is that, if the method
+* <p> The general contract of {@code mark} is that, if the method
-* <code>markSupported</code> returns <code>true</code>, the stream somehow
+* {@code markSupported} returns {@code true}, the stream somehow
-* remembers all the bytes read after the call to <code>mark</code> and
+* remembers all the bytes read after the call to {@code mark} and
 * stands ready to supply those same bytes again if and whenever the method
-* <code>reset</code> is called.  However, the stream is not required to
+* {@code reset} is called.  However, the stream is not required to
-* remember any data at all if more than <code>readlimit</code> bytes are
+* remember any data at all if more than {@code readlimit} bytes are
-* read from the stream before <code>reset</code> is called.
+* read from the stream before {@code reset} is called.
 *
 * <p> Marking a closed stream should not have any effect on the stream.
 *
-* <p> The <code>mark</code> method of <code>InputStream</code> does
+* <p> The {@code mark} method of {@code InputStream} does
 * nothing.
 *
 * @param   readlimit   the maximum limit of bytes that can be read before
 *                      the mark position becomes invalid.
 * @see     java.io.InputStream#reset()
 */
 public synchronized void mark(int readlimit) {}
 /**
 * Repositions this stream to the position at the time the
-* <code>mark</code> method was last called on this input stream.
+* {@code mark} method was last called on this input stream.
 *
-* <p> The general contract of <code>reset</code> is:
+* <p> The general contract of {@code reset} is:
 *
 * <ul>
-* <li> If the method <code>markSupported</code> returns
+* <li> If the method {@code markSupported} returns
-* <code>true</code>, then:
+* {@code true}, then:
 *
-*     <ul><li> If the method <code>mark</code> has not been called since
+*     <ul><li> If the method {@code mark} has not been called since
 *     the stream was created, or the number of bytes read from the stream
-*     since <code>mark</code> was last called is larger than the argument
+*     since {@code mark} was last called is larger than the argument
-*     to <code>mark</code> at that last call, then an
+*     to {@code mark} at that last call, then an
-*     <code>IOException</code> might be thrown.
+*     {@code IOException} might be thrown.
 *
-*     <li> If such an <code>IOException</code> is not thrown, then the
+*     <li> If such an {@code IOException} is not thrown, then the
 *     stream is reset to a state such that all the bytes read since the
-*     most recent call to <code>mark</code> (or since the start of the
+*     most recent call to {@code mark} (or since the start of the
-*     file, if <code>mark</code> has not been called) will be resupplied
+*     file, if {@code mark} has not been called) will be resupplied
-*     to subsequent callers of the <code>read</code> method, followed by
+*     to subsequent callers of the {@code read} method, followed by
 *     any bytes that otherwise would have been the next input data as of
-*     the time of the call to <code>reset</code>. </ul>
+*     the time of the call to {@code reset}. </ul>
 *
-* <li> If the method <code>markSupported</code> returns
+* <li> If the method {@code markSupported} returns
-* <code>false</code>, then:
+* {@code false}, then:
 *
-*     <ul><li> The call to <code>reset</code> may throw an
+*     <ul><li> The call to {@code reset} may throw an
-*     <code>IOException</code>.
+*     {@code IOException}.
 *
-*     <li> If an <code>IOException</code> is not thrown, then the stream
+*     <li> If an {@code IOException} is not thrown, then the stream
 *     is reset to a fixed state that depends on the particular type of the
 *     input stream and how it was created. The bytes that will be supplied
-*     to subsequent callers of the <code>read</code> method depend on the
+*     to subsequent callers of the {@code read} method depend on the
 *     particular type of the input stream. </ul></ul>
 *
-* <p>The method <code>reset</code> for class <code>InputStream</code>
+* <p>The method {@code reset} for class {@code InputStream}
-* does nothing except throw an <code>IOException</code>.
+* does nothing except throw an {@code IOException}.
 *
 * @throws  IOException  if this stream has not been marked or if the
 *          mark has been invalidated.
 * @see     java.io.InputStream#mark(int)
 * @see     java.io.IOException
 public synchronized void reset() throws IOException {
 throw new IOException("mark/reset not supported");
 }
 /**
-* Tests if this input stream supports the <code>mark</code> and
+* Tests if this input stream supports the {@code mark} and
-* <code>reset</code> methods. Whether or not <code>mark</code> and
+* {@code reset} methods. Whether or not {@code mark} and
-* <code>reset</code> are supported is an invariant property of a
+* {@code reset} are supported is an invariant property of a
-* particular input stream instance. The <code>markSupported</code> method
+* particular input stream instance. The {@code markSupported} method
-* of <code>InputStream</code> returns <code>false</code>.
+* of {@code InputStream} returns {@code false}.
 *
-* @return  <code>true</code> if this stream instance supports the mark
+* @return  {@code true} if this stream instance supports the mark
-*          and reset methods; <code>false</code> otherwise.
+*          and reset methods; {@code false} otherwise.
 * @see     java.io.InputStream#mark(int)
 * @see     java.io.InputStream#reset()
 */
 public boolean markSupported() {
 return false;

changeset 58288	48e480e56aad
parent 58242	94bb65cb37d3
child 58679	9c3209ff7550