mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 06:45:07 +02:00
8231186: Replace html tag <code>foo</code> with javadoc tag {@code foo} in java.base
Minor coding style update of javadoc tag in any file in java.base Reviewed-by: bchristi, lancea
This commit is contained in:
Julia Boes
parent
13d0bac294
commit
d15a57b842
139 changed files with 3499 additions and 3499 deletions
|
|
@ -34,7 +34,7 @@ import java.util.Objects;
|
|||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
}
|
||||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
}
|
||||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
|
||||
/**
|
||||
* 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 @@ public abstract class InputStream implements Closeable {
|
|||
}
|
||||
|
||||
/**
|
||||
* 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()
|
||||
*/
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue