--- a/src/java.base/share/classes/java/io/InputStream.java Tue Sep 24 10:04:13 2019 +0000
+++ b/src/java.base/share/classes/java/io/InputStream.java Tue Sep 24 09:43:43 2019 +0100
@@ -34,7 +34,7 @@
* 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
@@ -167,15 +167,15 @@
/**
* 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
- * <code>255</code>. If no byte is available because the end of the stream
- * has been reached, the value <code>-1</code> is returned. This method
+ * returned as an {@code int} in the range {@code 0} to
+ * {@code 255}. If no byte is available because the end of the stream
+ * 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.
*/
@@ -183,35 +183,35 @@
/**
* 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
- * <code>0</code> is returned; otherwise, there is an attempt to read at
+ * <p> If the length of {@code b} is zero, then no bytes are read and
+ * {@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
- * least one byte is read and stored into <code>b</code>.
+ * end of the file, the value {@code -1} is returned; otherwise, at
+ * least one byte is read and stored into {@code b}.
*
- * <p> The first byte read is stored into element <code>b[0]</code>, the
- * next one into <code>b[1]</code>, 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
+ * <p> The first byte read is stored into element {@code b[0]}, the
+ * next one into {@code b[1]}, and so on. The number of bytes read is,
+ * 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>,
- * leaving elements <code>b[</code><i>k</i><code>]</code> through
- * <code>b[b.length-1]</code> unaffected.
+ * {@code b[0]} through {@code b[}<i>k</i>{@code -1]},
+ * leaving elements {@code b[}<i>k</i>{@code ]} through
+ * {@code b[b.length-1]} unaffected.
*
- * <p> The <code>read(b)</code> method for class <code>InputStream</code>
- * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
+ * <p> The {@code read(b)} method for class {@code InputStream}
+ * 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 {
@@ -219,60 +219,60 @@
}
/**
- * 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
- * <code>0</code> is returned; otherwise, there is an attempt to read at
+ * <p> If {@code len} is zero, then no bytes are read and
+ * {@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
- * byte is read and stored into <code>b</code>.
+ * file, the value {@code -1} is returned; otherwise, at least one
+ * byte is read and stored into {@code b}.
*
- * <p> The first byte read is stored into element <code>b[off]</code>, the
- * next one into <code>b[off+1]</code>, and so on. The number of bytes read
- * is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
+ * <p> The first byte read is stored into element {@code b[off]}, the
+ * next one into {@code b[off+1]}, and so on. The number of bytes read
+ * 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>,
- * leaving elements <code>b[off+</code><i>k</i><code>]</code> through
- * <code>b[off+len-1]</code> unaffected.
+ * {@code b[off]} through {@code b[off+}<i>k</i>{@code -1]},
+ * leaving elements {@code b[off+}<i>k</i>{@code ]} through
+ * {@code b[off+len-1]} unaffected.
*
- * <p> In every case, elements <code>b[0]</code> through
- * <code>b[off-1]</code> and elements <code>b[off+len]</code> through
- * <code>b[b.length-1]</code> are unaffected.
+ * <p> In every case, elements {@code b[0]} through
+ * {@code b[off-1]} and elements {@code b[off+len]} through
+ * {@code b[b.length-1]} are unaffected.
*
- * <p> The <code>read(b,</code> <code>off,</code> <code>len)</code> method
- * for class <code>InputStream</code> simply calls the method
- * <code>read()</code> repeatedly. If the first such call results in an
- * <code>IOException</code>, that exception is returned from the call to
- * the <code>read(b,</code> <code>off,</code> <code>len)</code> method. If
- * any subsequent call to <code>read()</code> results in a
- * <code>IOException</code>, the exception is caught and treated as if it
+ * <p> The {@code read(b, off, len)} method
+ * for class {@code InputStream} simply calls the method
+ * {@code read()} repeatedly. If the first such call results in an
+ * {@code IOException}, that exception is returned from the call to
+ * the {@code read(b,} {@code off,} {@code len)} method. If
+ * any subsequent call to {@code read()} results in a
+ * {@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 IndexOutOfBoundsException If <code>off</code> is negative,
- * <code>len</code> is negative, or <code>len</code> is greater than
- * <code>b.length - off</code>
+ * @throws NullPointerException If {@code b} is {@code null}.
+ * @throws IndexOutOfBoundsException If {@code off} is negative,
+ * {@code len} is negative, or {@code len} is greater than
+ * {@code b.length - off}
* @see java.io.InputStream#read()
*/
public int read(byte b[], int off, int len) throws IOException {
@@ -509,18 +509,18 @@
}
/**
- * Skips over and discards <code>n</code> bytes of data from this input
- * stream. The <code>skip</code> method may, for a variety of reasons, end
- * up skipping over some smaller number of bytes, possibly <code>0</code>.
+ * Skips over and discards {@code n} bytes of data from this input
+ * stream. The {@code skip} method may, for a variety of reasons, end
+ * 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
- * byte array and then repeatedly reads into it until <code>n</code> bytes
+ * <p> The {@code skip} method implementation of this class creates a
+ * 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.
@@ -644,7 +644,7 @@
* 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.
@@ -653,24 +653,24 @@
/**
* 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
- * <code>markSupported</code> returns <code>true</code>, the stream somehow
- * remembers all the bytes read after the call to <code>mark</code> and
+ * <p> The general contract of {@code mark} is that, if the method
+ * {@code markSupported} returns {@code true}, the stream somehow
+ * 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
- * remember any data at all if more than <code>readlimit</code> bytes are
- * read from the stream before <code>reset</code> is called.
+ * {@code reset} is called. However, the stream is not required to
+ * remember any data at all if more than {@code readlimit} bytes are
+ * 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
@@ -681,42 +681,42 @@
/**
* 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
- * <code>true</code>, then:
+ * <li> If the method {@code markSupported} returns
+ * {@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
- * to <code>mark</code> at that last call, then an
- * <code>IOException</code> might be thrown.
+ * since {@code mark} was last called is larger than the argument
+ * to {@code mark} at that last call, then an
+ * {@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
- * file, if <code>mark</code> has not been called) will be resupplied
- * to subsequent callers of the <code>read</code> method, followed by
+ * most recent call to {@code mark} (or since the start of the
+ * file, if {@code mark} has not been called) will be resupplied
+ * 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
- * <code>false</code>, then:
+ * <li> If the method {@code markSupported} returns
+ * {@code false}, then:
*
- * <ul><li> The call to <code>reset</code> may throw an
- * <code>IOException</code>.
+ * <ul><li> The call to {@code reset} may throw an
+ * {@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>
- * does nothing except throw an <code>IOException</code>.
+ * <p>The method {@code reset} for class {@code InputStream}
+ * does nothing except throw an {@code IOException}.
*
* @throws IOException if this stream has not been marked or if the
* mark has been invalidated.
@@ -728,14 +728,14 @@
}
/**
- * Tests if this input stream supports the <code>mark</code> and
- * <code>reset</code> methods. Whether or not <code>mark</code> and
- * <code>reset</code> are supported is an invariant property of a
- * particular input stream instance. The <code>markSupported</code> method
- * of <code>InputStream</code> returns <code>false</code>.
+ * Tests if this input stream supports the {@code mark} and
+ * {@code reset} methods. Whether or not {@code mark} and
+ * {@code reset} are supported is an invariant property of a
+ * particular input stream instance. The {@code markSupported} method
+ * of {@code InputStream} returns {@code false}.
*
- * @return <code>true</code> if this stream instance supports the mark
- * and reset methods; <code>false</code> otherwise.
+ * @return {@code true} if this stream instance supports the mark
+ * and reset methods; {@code false} otherwise.
* @see java.io.InputStream#mark(int)
* @see java.io.InputStream#reset()
*/