Merge
This commit is contained in:
commit
6503bf1602
@ -275,7 +275,6 @@ class ByteArrayInputStream extends InputStream {
|
||||
* Closing a <tt>ByteArrayInputStream</tt> has no effect. The methods in
|
||||
* this class can be called after the stream has been closed without
|
||||
* generating an <tt>IOException</tt>.
|
||||
* <p>
|
||||
*/
|
||||
public void close() throws IOException {
|
||||
}
|
||||
|
@ -263,8 +263,6 @@ public class ByteArrayOutputStream extends OutputStream {
|
||||
* Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
|
||||
* this class can be called after the stream has been closed without
|
||||
* generating an <tt>IOException</tt>.
|
||||
* <p>
|
||||
*
|
||||
*/
|
||||
public void close() throws IOException {
|
||||
}
|
||||
|
@ -155,7 +155,7 @@ interface DataInput {
|
||||
* to the length of {@code b}.
|
||||
* <p>
|
||||
* This method blocks until one of the
|
||||
* following conditions occurs:<p>
|
||||
* following conditions occurs:
|
||||
* <ul>
|
||||
* <li>{@code b.length}
|
||||
* bytes of input data are available, in which
|
||||
@ -197,7 +197,7 @@ interface DataInput {
|
||||
* <p>
|
||||
* This method
|
||||
* blocks until one of the following conditions
|
||||
* occurs:<p>
|
||||
* occurs:
|
||||
* <ul>
|
||||
* <li>{@code len} bytes
|
||||
* of input data are available, in which case
|
||||
@ -316,8 +316,8 @@ interface DataInput {
|
||||
* be the second byte. The value
|
||||
* returned
|
||||
* is:
|
||||
* <p><pre><code>(short)((a << 8) | (b & 0xff))
|
||||
* </code></pre>
|
||||
* <pre>{@code (short)((a << 8) | (b & 0xff))
|
||||
* }</pre>
|
||||
* This method
|
||||
* is suitable for reading the bytes written
|
||||
* by the {@code writeShort} method of
|
||||
@ -337,8 +337,8 @@ interface DataInput {
|
||||
* be the first byte read and
|
||||
* {@code b}
|
||||
* be the second byte. The value returned is:
|
||||
* <p><pre><code>(((a & 0xff) << 8) | (b & 0xff))
|
||||
* </code></pre>
|
||||
* <pre>{@code (((a & 0xff) << 8) | (b & 0xff))
|
||||
* }</pre>
|
||||
* This method is suitable for reading the bytes
|
||||
* written by the {@code writeShort} method
|
||||
* of interface {@code DataOutput} if
|
||||
@ -359,8 +359,8 @@ interface DataInput {
|
||||
* be the first byte read and {@code b}
|
||||
* be the second byte. The value
|
||||
* returned is:
|
||||
* <p><pre><code>(char)((a << 8) | (b & 0xff))
|
||||
* </code></pre>
|
||||
* <pre>{@code (char)((a << 8) | (b & 0xff))
|
||||
* }</pre>
|
||||
* This method
|
||||
* is suitable for reading bytes written by
|
||||
* the {@code writeChar} method of interface
|
||||
@ -377,10 +377,10 @@ interface DataInput {
|
||||
* Reads four input bytes and returns an
|
||||
* {@code int} value. Let {@code a-d}
|
||||
* be the first through fourth bytes read. The value returned is:
|
||||
* <p><pre><code>
|
||||
* (((a & 0xff) << 24) | ((b & 0xff) << 16) |
|
||||
*  ((c & 0xff) << 8) | (d & 0xff))
|
||||
* </code></pre>
|
||||
* <pre>{@code
|
||||
* (((a & 0xff) << 24) | ((b & 0xff) << 16) |
|
||||
* ((c & 0xff) << 8) | (d & 0xff))
|
||||
* }</pre>
|
||||
* This method is suitable
|
||||
* for reading bytes written by the {@code writeInt}
|
||||
* method of interface {@code DataOutput}.
|
||||
@ -397,16 +397,16 @@ interface DataInput {
|
||||
* a {@code long} value. Let {@code a-h}
|
||||
* be the first through eighth bytes read.
|
||||
* The value returned is:
|
||||
* <p><pre><code>
|
||||
* (((long)(a & 0xff) << 56) |
|
||||
* ((long)(b & 0xff) << 48) |
|
||||
* ((long)(c & 0xff) << 40) |
|
||||
* ((long)(d & 0xff) << 32) |
|
||||
* ((long)(e & 0xff) << 24) |
|
||||
* ((long)(f & 0xff) << 16) |
|
||||
* ((long)(g & 0xff) << 8) |
|
||||
* ((long)(h & 0xff)))
|
||||
* </code></pre>
|
||||
* <pre>{@code
|
||||
* (((long)(a & 0xff) << 56) |
|
||||
* ((long)(b & 0xff) << 48) |
|
||||
* ((long)(c & 0xff) << 40) |
|
||||
* ((long)(d & 0xff) << 32) |
|
||||
* ((long)(e & 0xff) << 24) |
|
||||
* ((long)(f & 0xff) << 16) |
|
||||
* ((long)(g & 0xff) << 8) |
|
||||
* ((long)(h & 0xff)))
|
||||
* }</pre>
|
||||
* <p>
|
||||
* This method is suitable
|
||||
* for reading bytes written by the {@code writeLong}
|
||||
@ -540,9 +540,9 @@ interface DataInput {
|
||||
* not match the bit pattern {@code 10xxxxxx},
|
||||
* then a {@code UTFDataFormatException}
|
||||
* is thrown. Otherwise, the group is converted
|
||||
* to the character:<p>
|
||||
* <pre><code>(char)(((a& 0x1F) << 6) | (b & 0x3F))
|
||||
* </code></pre>
|
||||
* to the character:
|
||||
* <pre>{@code (char)(((a & 0x1F) << 6) | (b & 0x3F))
|
||||
* }</pre>
|
||||
* If the first byte of a group
|
||||
* matches the bit pattern {@code 1110xxxx},
|
||||
* then the group consists of that byte {@code a}
|
||||
@ -554,10 +554,10 @@ interface DataInput {
|
||||
* does not match the bit pattern {@code 10xxxxxx},
|
||||
* then a {@code UTFDataFormatException}
|
||||
* is thrown. Otherwise, the group is converted
|
||||
* to the character:<p>
|
||||
* <pre><code>
|
||||
* (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F))
|
||||
* </code></pre>
|
||||
* to the character:
|
||||
* <pre>{@code
|
||||
* (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F))
|
||||
* }</pre>
|
||||
* If the first byte of a group matches the
|
||||
* pattern {@code 1111xxxx} or the pattern
|
||||
* {@code 10xxxxxx}, then a {@code UTFDataFormatException}
|
||||
|
@ -134,11 +134,11 @@ interface DataOutput {
|
||||
* Writes two bytes to the output
|
||||
* stream to represent the value of the argument.
|
||||
* The byte values to be written, in the order
|
||||
* shown, are: <p>
|
||||
* <pre><code>
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* </code> </pre> <p>
|
||||
* shown, are:
|
||||
* <pre>{@code
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* }</pre> <p>
|
||||
* The bytes written by this method may be
|
||||
* read by the <code>readShort</code> method
|
||||
* of interface <code>DataInput</code> , which
|
||||
@ -156,10 +156,10 @@ interface DataOutput {
|
||||
* output stream.
|
||||
* The byte values to be written, in the order
|
||||
* shown, are:
|
||||
* <p><pre><code>
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* </code></pre><p>
|
||||
* <pre>{@code
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* }</pre><p>
|
||||
* The bytes written by this method may be
|
||||
* read by the <code>readChar</code> method
|
||||
* of interface <code>DataInput</code> , which
|
||||
@ -176,12 +176,12 @@ interface DataOutput {
|
||||
* comprised of four bytes, to the output stream.
|
||||
* The byte values to be written, in the order
|
||||
* shown, are:
|
||||
* <p><pre><code>
|
||||
* (byte)(0xff & (v >> 24))
|
||||
* (byte)(0xff & (v >> 16))
|
||||
* (byte)(0xff & (v >>    8))
|
||||
* (byte)(0xff & v)
|
||||
* </code></pre><p>
|
||||
* <pre>{@code
|
||||
* (byte)(0xff & (v >> 24))
|
||||
* (byte)(0xff & (v >> 16))
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* }</pre><p>
|
||||
* The bytes written by this method may be read
|
||||
* by the <code>readInt</code> method of interface
|
||||
* <code>DataInput</code> , which will then
|
||||
@ -197,16 +197,16 @@ interface DataOutput {
|
||||
* comprised of eight bytes, to the output stream.
|
||||
* The byte values to be written, in the order
|
||||
* shown, are:
|
||||
* <p><pre><code>
|
||||
* (byte)(0xff & (v >> 56))
|
||||
* (byte)(0xff & (v >> 48))
|
||||
* (byte)(0xff & (v >> 40))
|
||||
* (byte)(0xff & (v >> 32))
|
||||
* (byte)(0xff & (v >> 24))
|
||||
* (byte)(0xff & (v >> 16))
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* </code></pre><p>
|
||||
* <pre>{@code
|
||||
* (byte)(0xff & (v >> 56))
|
||||
* (byte)(0xff & (v >> 48))
|
||||
* (byte)(0xff & (v >> 40))
|
||||
* (byte)(0xff & (v >> 32))
|
||||
* (byte)(0xff & (v >> 24))
|
||||
* (byte)(0xff & (v >> 16))
|
||||
* (byte)(0xff & (v >> 8))
|
||||
* (byte)(0xff & v)
|
||||
* }</pre><p>
|
||||
* The bytes written by this method may be
|
||||
* read by the <code>readLong</code> method
|
||||
* of interface <code>DataInput</code> , which
|
||||
@ -314,24 +314,24 @@ interface DataOutput {
|
||||
* If a character <code>c</code>
|
||||
* is in the range <code>\u0001</code> through
|
||||
* <code>\u007f</code>, it is represented
|
||||
* by one byte:<p>
|
||||
* by one byte:
|
||||
* <pre>(byte)c </pre> <p>
|
||||
* If a character <code>c</code> is <code>\u0000</code>
|
||||
* or is in the range <code>\u0080</code>
|
||||
* through <code>\u07ff</code>, then it is
|
||||
* represented by two bytes, to be written
|
||||
* in the order shown:<p> <pre><code>
|
||||
* (byte)(0xc0 | (0x1f & (c >> 6)))
|
||||
* (byte)(0x80 | (0x3f & c))
|
||||
* </code></pre> <p> If a character
|
||||
* in the order shown: <pre>{@code
|
||||
* (byte)(0xc0 | (0x1f & (c >> 6)))
|
||||
* (byte)(0x80 | (0x3f & c))
|
||||
* }</pre> <p> If a character
|
||||
* <code>c</code> is in the range <code>\u0800</code>
|
||||
* through <code>uffff</code>, then it is
|
||||
* represented by three bytes, to be written
|
||||
* in the order shown:<p> <pre><code>
|
||||
* (byte)(0xe0 | (0x0f & (c >> 12)))
|
||||
* (byte)(0x80 | (0x3f & (c >> 6)))
|
||||
* (byte)(0x80 | (0x3f & c))
|
||||
* </code></pre> <p> First,
|
||||
* in the order shown: <pre>{@code
|
||||
* (byte)(0xe0 | (0x0f & (c >> 12)))
|
||||
* (byte)(0x80 | (0x3f & (c >> 6)))
|
||||
* (byte)(0x80 | (0x3f & c))
|
||||
* }</pre> <p> First,
|
||||
* the total number of bytes needed to represent
|
||||
* all the characters of <code>s</code> is
|
||||
* calculated. If this number is larger than
|
||||
|
@ -55,7 +55,7 @@ import sun.security.util.SecurityConstants;
|
||||
* a list of one or more comma-separated keywords. The possible keywords are
|
||||
* "read", "write", "execute", "delete", and "readlink". Their meaning is
|
||||
* defined as follows:
|
||||
* <P>
|
||||
*
|
||||
* <DL>
|
||||
* <DT> read <DD> read permission
|
||||
* <DT> write <DD> write permission
|
||||
@ -297,11 +297,11 @@ public final class FilePermission extends Permission implements Serializable {
|
||||
/**
|
||||
* Checks if this FilePermission object "implies" the specified permission.
|
||||
* <P>
|
||||
* More specifically, this method returns true if:<p>
|
||||
* More specifically, this method returns true if:
|
||||
* <ul>
|
||||
* <li> <i>p</i> is an instanceof FilePermission,<p>
|
||||
* <li> <i>p</i> is an instanceof FilePermission,
|
||||
* <li> <i>p</i>'s actions are a proper subset of this
|
||||
* object's actions, and <p>
|
||||
* object's actions, and
|
||||
* <li> <i>p</i>'s pathname is implied by this object's
|
||||
* pathname. For example, "/tmp/*" implies "/tmp/foo", since
|
||||
* "/tmp/*" encompasses all files in the "/tmp" directory,
|
||||
|
@ -306,8 +306,7 @@ public abstract class InputStream implements Closeable {
|
||||
*
|
||||
* <p> The general contract of <code>reset</code> is:
|
||||
*
|
||||
* <p><ul>
|
||||
*
|
||||
* <ul>
|
||||
* <li> If the method <code>markSupported</code> returns
|
||||
* <code>true</code>, then:
|
||||
*
|
||||
|
@ -109,7 +109,7 @@ import sun.reflect.misc.ReflectUtil;
|
||||
*
|
||||
* <p>Serializable classes that require special handling during the
|
||||
* serialization and deserialization process should implement the following
|
||||
* methods:<p>
|
||||
* methods:
|
||||
*
|
||||
* <pre>
|
||||
* private void writeObject(java.io.ObjectOutputStream stream)
|
||||
|
@ -172,15 +172,14 @@ public class PipedInputStream extends InputStream {
|
||||
* unconnected piped output stream and <code>snk</code>
|
||||
* is an unconnected piped input stream, they
|
||||
* may be connected by either the call:
|
||||
* <p>
|
||||
*
|
||||
* <pre><code>snk.connect(src)</code> </pre>
|
||||
* <p>
|
||||
* or the call:
|
||||
* <p>
|
||||
*
|
||||
* <pre><code>src.connect(snk)</code> </pre>
|
||||
* <p>
|
||||
* The two
|
||||
* calls have the same effect.
|
||||
* The two calls have the same effect.
|
||||
*
|
||||
* @param src The piped output stream to connect to.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
|
@ -145,15 +145,14 @@ public class PipedReader extends Reader {
|
||||
* unconnected piped writer and <code>snk</code>
|
||||
* is an unconnected piped reader, they
|
||||
* may be connected by either the call:
|
||||
* <p>
|
||||
*
|
||||
* <pre><code>snk.connect(src)</code> </pre>
|
||||
* <p>
|
||||
* or the call:
|
||||
* <p>
|
||||
*
|
||||
* <pre><code>src.connect(snk)</code> </pre>
|
||||
* <p>
|
||||
* The two
|
||||
* calls have the same effect.
|
||||
* The two calls have the same effect.
|
||||
*
|
||||
* @param src The piped writer to connect to.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
|
@ -784,7 +784,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
|
||||
* </pre></blockquote>
|
||||
* <p>
|
||||
* then the result is equal to:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* ((long)b1 << 56) + ((long)b2 << 48)
|
||||
* + ((long)b3 << 40) + ((long)b4 << 32)
|
||||
* + ((long)b5 << 24) + ((long)b6 << 16)
|
||||
|
@ -55,7 +55,7 @@ package java.io;
|
||||
*
|
||||
* Classes that require special handling during the serialization and
|
||||
* deserialization process must implement special methods with these exact
|
||||
* signatures: <p>
|
||||
* signatures:
|
||||
*
|
||||
* <PRE>
|
||||
* private void writeObject(java.io.ObjectOutputStream out)
|
||||
@ -101,7 +101,7 @@ package java.io;
|
||||
*
|
||||
* <p>Serializable classes that need to designate an alternative object to be
|
||||
* used when writing an object to the stream should implement this
|
||||
* special method with the exact signature: <p>
|
||||
* special method with the exact signature:
|
||||
*
|
||||
* <PRE>
|
||||
* ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
|
||||
@ -115,7 +115,7 @@ package java.io;
|
||||
*
|
||||
* Classes that need to designate a replacement when an instance of it
|
||||
* is read from the stream should implement this special method with the
|
||||
* exact signature.<p>
|
||||
* exact signature.
|
||||
*
|
||||
* <PRE>
|
||||
* ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
|
||||
@ -133,7 +133,7 @@ package java.io;
|
||||
* deserialization will result in an {@link InvalidClassException}. A
|
||||
* serializable class can declare its own serialVersionUID explicitly by
|
||||
* declaring a field named <code>"serialVersionUID"</code> that must be static,
|
||||
* final, and of type <code>long</code>:<p>
|
||||
* final, and of type <code>long</code>:
|
||||
*
|
||||
* <PRE>
|
||||
* ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
|
||||
|
@ -43,7 +43,6 @@ import java.util.StringTokenizer;
|
||||
* The following table lists all the possible SerializablePermission target names,
|
||||
* and for each provides a description of what the permission allows
|
||||
* and a discussion of the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="Permission target name, what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
|
@ -330,9 +330,9 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
* characters to be copied is {@code srcEnd-srcBegin}. The
|
||||
* characters are copied into the subarray of {@code dst} starting
|
||||
* at index {@code dstBegin} and ending at index:
|
||||
* <p><blockquote><pre>
|
||||
* <pre>{@code
|
||||
* dstbegin + (srcEnd-srcBegin) - 1
|
||||
* </pre></blockquote>
|
||||
* }</pre>
|
||||
*
|
||||
* @param srcBegin start copying at this offset.
|
||||
* @param srcEnd stop copying at this offset.
|
||||
@ -859,16 +859,16 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
*
|
||||
* <p> An invocation of this method of the form
|
||||
*
|
||||
* <blockquote><pre>
|
||||
* sb.subSequence(begin, end)</pre></blockquote>
|
||||
* <pre>{@code
|
||||
* sb.subSequence(begin, end)}</pre>
|
||||
*
|
||||
* behaves in exactly the same way as the invocation
|
||||
*
|
||||
* <blockquote><pre>
|
||||
* sb.substring(begin, end)</pre></blockquote>
|
||||
* <pre>{@code
|
||||
* sb.substring(begin, end)}</pre>
|
||||
*
|
||||
* This method is provided so that this class can
|
||||
* implement the {@link CharSequence} interface. </p>
|
||||
* implement the {@link CharSequence} interface.
|
||||
*
|
||||
* @param start the start index, inclusive.
|
||||
* @param end the end index, exclusive.
|
||||
@ -1287,9 +1287,9 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
* Returns the index within this string of the first occurrence of the
|
||||
* specified substring. The integer returned is the smallest value
|
||||
* <i>k</i> such that:
|
||||
* <blockquote><pre>
|
||||
* <pre>{@code
|
||||
* this.toString().startsWith(str, <i>k</i>)
|
||||
* </pre></blockquote>
|
||||
* }</pre>
|
||||
* is {@code true}.
|
||||
*
|
||||
* @param str any string.
|
||||
@ -1306,10 +1306,10 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
* Returns the index within this string of the first occurrence of the
|
||||
* specified substring, starting at the specified index. The integer
|
||||
* returned is the smallest value {@code k} for which:
|
||||
* <blockquote><pre>
|
||||
* <pre>{@code
|
||||
* k >= Math.min(fromIndex, this.length()) &&
|
||||
* this.toString().startsWith(str, k)
|
||||
* </pre></blockquote>
|
||||
* }</pre>
|
||||
* If no such value of <i>k</i> exists, then -1 is returned.
|
||||
*
|
||||
* @param str the substring for which to search.
|
||||
@ -1326,9 +1326,9 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
* of the specified substring. The rightmost empty string "" is
|
||||
* considered to occur at the index value {@code this.length()}.
|
||||
* The returned index is the largest value <i>k</i> such that
|
||||
* <blockquote><pre>
|
||||
* <pre>{@code
|
||||
* this.toString().startsWith(str, k)
|
||||
* </pre></blockquote>
|
||||
* }</pre>
|
||||
* is true.
|
||||
*
|
||||
* @param str the substring to search for.
|
||||
@ -1345,10 +1345,10 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
* Returns the index within this string of the last occurrence of the
|
||||
* specified substring. The integer returned is the largest value <i>k</i>
|
||||
* such that:
|
||||
* <blockquote><pre>
|
||||
* <pre>{@code
|
||||
* k <= Math.min(fromIndex, this.length()) &&
|
||||
* this.toString().startsWith(str, k)
|
||||
* </pre></blockquote>
|
||||
* }</pre>
|
||||
* If no such value of <i>k</i> exists, then -1 is returned.
|
||||
*
|
||||
* @param str the substring to search for.
|
||||
|
@ -29,7 +29,7 @@ package java.lang;
|
||||
* Thrown to indicate that an attempt has been made to store the
|
||||
* wrong type of object into an array of objects. For example, the
|
||||
* following code generates an <code>ArrayStoreException</code>:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* Object x[] = new String[3];
|
||||
* x[0] = new Integer(0);
|
||||
* </pre></blockquote>
|
||||
|
@ -244,7 +244,7 @@ public final class Byte extends Number implements Comparable<Byte> {
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
|
||||
* <p>
|
||||
*
|
||||
* <dt><i>Sign:</i>
|
||||
* <dd>{@code -}
|
||||
* <dd>{@code +}
|
||||
|
@ -5394,7 +5394,7 @@ class Character implements java.io.Serializable, Comparable<Character> {
|
||||
* Other_Lowercase as defined by the Unicode Standard.
|
||||
* <p>
|
||||
* The following are examples of lowercase characters:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* a b c d e f g h i j k l m n o p q r s t u v w x y z
|
||||
* '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
|
||||
* '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
|
||||
@ -5430,7 +5430,7 @@ class Character implements java.io.Serializable, Comparable<Character> {
|
||||
* Other_Lowercase as defined by the Unicode Standard.
|
||||
* <p>
|
||||
* The following are examples of lowercase characters:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* a b c d e f g h i j k l m n o p q r s t u v w x y z
|
||||
* '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
|
||||
* '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
|
||||
@ -5461,14 +5461,14 @@ class Character implements java.io.Serializable, Comparable<Character> {
|
||||
* or it has contributory property Other_Uppercase as defined by the Unicode Standard.
|
||||
* <p>
|
||||
* The following are examples of uppercase characters:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
|
||||
* '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
|
||||
* '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
|
||||
* '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
|
||||
* '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
|
||||
* </pre></blockquote>
|
||||
* <p> Many other Unicode characters are uppercase too.<p>
|
||||
* <p> Many other Unicode characters are uppercase too.
|
||||
*
|
||||
* <p><b>Note:</b> This method cannot handle <a
|
||||
* href="#supplementary"> supplementary characters</a>. To support
|
||||
@ -5496,7 +5496,7 @@ class Character implements java.io.Serializable, Comparable<Character> {
|
||||
* or it has contributory property Other_Uppercase as defined by the Unicode Standard.
|
||||
* <p>
|
||||
* The following are examples of uppercase characters:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
|
||||
* '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
|
||||
* '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
|
||||
@ -5540,7 +5540,7 @@ class Character implements java.io.Serializable, Comparable<Character> {
|
||||
* <li>{@code LATIN CAPITAL LETTER N WITH SMALL LETTER J}
|
||||
* <li>{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z}
|
||||
* </ul>
|
||||
* <p> Many other Unicode characters are titlecase too.<p>
|
||||
* <p> Many other Unicode characters are titlecase too.
|
||||
*
|
||||
* <p><b>Note:</b> This method cannot handle <a
|
||||
* href="#supplementary"> supplementary characters</a>. To support
|
||||
|
@ -91,7 +91,7 @@ import sun.reflect.misc.ReflectUtil;
|
||||
* <p> The following example uses a {@code Class} object to print the
|
||||
* class name of an object:
|
||||
*
|
||||
* <p> <blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* void printClassName(Object obj) {
|
||||
* System.out.println("The class of " + obj +
|
||||
* " is " + obj.getClass().getName());
|
||||
@ -103,7 +103,7 @@ import sun.reflect.misc.ReflectUtil;
|
||||
* <cite>The Java™ Language Specification</cite>.
|
||||
* For example:
|
||||
*
|
||||
* <p> <blockquote>
|
||||
* <blockquote>
|
||||
* {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
|
||||
* </blockquote>
|
||||
*
|
||||
|
@ -29,7 +29,7 @@ package java.lang;
|
||||
* Thrown to indicate that the code has attempted to cast an object
|
||||
* to a subclass of which it is not an instance. For example, the
|
||||
* following code generates a <code>ClassCastException</code>:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* Object x = new Integer(0);
|
||||
* System.out.println((String)x);
|
||||
* </pre></blockquote>
|
||||
|
@ -361,15 +361,11 @@ public final class Double extends Number implements Comparable<Double> {
|
||||
* <dd><i>SignedInteger</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>HexFloatingPointLiteral</i>:
|
||||
* <dd> <i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>HexSignificand:</i>
|
||||
* <dd><i>HexNumeral</i>
|
||||
@ -380,15 +376,11 @@ public final class Double extends Number implements Comparable<Double> {
|
||||
* </i>{@code .} <i>HexDigits</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>BinaryExponent:</i>
|
||||
* <dd><i>BinaryExponentIndicator SignedInteger</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>BinaryExponentIndicator:</i>
|
||||
* <dd>{@code p}
|
||||
|
@ -321,15 +321,11 @@ public final class Float extends Number implements Comparable<Float> {
|
||||
* <dd><i>SignedInteger</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>HexFloatingPointLiteral</i>:
|
||||
* <dd> <i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>HexSignificand:</i>
|
||||
* <dd><i>HexNumeral</i>
|
||||
@ -340,15 +336,11 @@ public final class Float extends Number implements Comparable<Float> {
|
||||
* </i>{@code .} <i>HexDigits</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>BinaryExponent:</i>
|
||||
* <dd><i>BinaryExponentIndicator SignedInteger</i>
|
||||
* </dl>
|
||||
*
|
||||
* <p>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><i>BinaryExponentIndicator:</i>
|
||||
* <dd>{@code p}
|
||||
|
@ -1123,7 +1123,7 @@ public final class Integer extends Number implements Comparable<Integer> {
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
|
||||
* <p>
|
||||
*
|
||||
* <dt><i>Sign:</i>
|
||||
* <dd>{@code -}
|
||||
* <dd>{@code +}
|
||||
|
@ -51,10 +51,12 @@ public interface Iterable<T> {
|
||||
Iterator<T> iterator();
|
||||
|
||||
/**
|
||||
* Performs the given action on the contents of the {@code Iterable}, in the
|
||||
* order elements occur when iterating, until all elements have been
|
||||
* processed or the action throws an exception. Errors or runtime
|
||||
* exceptions thrown by the action are relayed to the caller.
|
||||
* Performs the given action for each element of the {@code Iterable}
|
||||
* until all elements have been processed or the action throws an
|
||||
* exception. Unless otherwise specified by the implementing class,
|
||||
* actions are performed in the order of iteration (if an iteration order
|
||||
* is specified). Exceptions thrown by the action are relayed to the
|
||||
* caller.
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
@ -99,4 +101,3 @@ public interface Iterable<T> {
|
||||
return Spliterators.spliteratorUnknownSize(iterator(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -853,7 +853,7 @@ public final class Long extends Number implements Comparable<Long> {
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
|
||||
* <p>
|
||||
*
|
||||
* <dt><i>Sign:</i>
|
||||
* <dd>{@code -}
|
||||
* <dd>{@code +}
|
||||
|
@ -47,7 +47,6 @@ import java.util.StringTokenizer;
|
||||
* The following table lists all the possible RuntimePermission target names,
|
||||
* and for each provides a description of what the permission allows
|
||||
* and a discussion of the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="permission target name,
|
||||
* what the target allows,and associated risks">
|
||||
|
@ -249,7 +249,7 @@ public final class Short extends Number implements Comparable<Short> {
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
|
||||
* <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
|
||||
* <p>
|
||||
*
|
||||
* <dt><i>Sign:</i>
|
||||
* <dd>{@code -}
|
||||
* <dd>{@code +}
|
||||
|
@ -47,16 +47,16 @@ import java.util.regex.PatternSyntaxException;
|
||||
* Strings are constant; their values cannot be changed after they
|
||||
* are created. String buffers support mutable strings.
|
||||
* Because String objects are immutable they can be shared. For example:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* String str = "abc";
|
||||
* </pre></blockquote><p>
|
||||
* is equivalent to:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* char data[] = {'a', 'b', 'c'};
|
||||
* String str = new String(data);
|
||||
* </pre></blockquote><p>
|
||||
* Here are some more examples of how strings can be used:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* System.out.println("abc");
|
||||
* String cde = "cde";
|
||||
* System.out.println("abc" + cde);
|
||||
@ -786,7 +786,7 @@ public final class String
|
||||
* {@code srcEnd-srcBegin}). The characters are copied into the
|
||||
* subarray of {@code dst} starting at index {@code dstBegin}
|
||||
* and ending at index:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* dstbegin + (srcEnd-srcBegin) - 1
|
||||
* </pre></blockquote>
|
||||
*
|
||||
@ -2662,7 +2662,7 @@ public final class String
|
||||
* {@code String} may be a different length than the original {@code String}.
|
||||
* <p>
|
||||
* Examples of locale-sensitive and 1:M case mappings are in the following table.
|
||||
* <p>
|
||||
*
|
||||
* <table border="1" summary="Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description.">
|
||||
* <tr>
|
||||
* <th>Language Code of Locale</th>
|
||||
|
@ -76,7 +76,7 @@ import sun.security.util.SecurityConstants;
|
||||
* <code>Thread</code>. An instance of the subclass can then be
|
||||
* allocated and started. For example, a thread that computes primes
|
||||
* larger than a stated value could be written as follows:
|
||||
* <p><hr><blockquote><pre>
|
||||
* <hr><blockquote><pre>
|
||||
* class PrimeThread extends Thread {
|
||||
* long minPrime;
|
||||
* PrimeThread(long minPrime) {
|
||||
@ -91,7 +91,7 @@ import sun.security.util.SecurityConstants;
|
||||
* </pre></blockquote><hr>
|
||||
* <p>
|
||||
* The following code would then create a thread and start it running:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* PrimeThread p = new PrimeThread(143);
|
||||
* p.start();
|
||||
* </pre></blockquote>
|
||||
@ -102,7 +102,7 @@ import sun.security.util.SecurityConstants;
|
||||
* then be allocated, passed as an argument when creating
|
||||
* <code>Thread</code>, and started. The same example in this other
|
||||
* style looks like the following:
|
||||
* <p><hr><blockquote><pre>
|
||||
* <hr><blockquote><pre>
|
||||
* class PrimeRun implements Runnable {
|
||||
* long minPrime;
|
||||
* PrimeRun(long minPrime) {
|
||||
@ -117,7 +117,7 @@ import sun.security.util.SecurityConstants;
|
||||
* </pre></blockquote><hr>
|
||||
* <p>
|
||||
* The following code would then create a thread and start it running:
|
||||
* <p><blockquote><pre>
|
||||
* <blockquote><pre>
|
||||
* PrimeRun p = new PrimeRun(143);
|
||||
* new Thread(p).start();
|
||||
* </pre></blockquote>
|
||||
|
@ -183,15 +183,15 @@ public class LambdaMetafactory {
|
||||
* @param samMethodType MethodType of the method in the functional interface
|
||||
* to which the lambda or method reference is being
|
||||
* converted, represented as a MethodType.
|
||||
* @param implMethod The implementation method which should be called
|
||||
* (with suitable adaptation of argument types, return
|
||||
* types, and adjustment for captured arguments) when
|
||||
* methods of the resulting functional interface instance
|
||||
* are invoked.
|
||||
* @param implMethod A direct method handle describing the implementation
|
||||
* method which should be called (with suitable adaptation
|
||||
* of argument types, return types, and adjustment for
|
||||
* captured arguments) when methods of the resulting
|
||||
* functional interface instance are invoked.
|
||||
* @param instantiatedMethodType The signature of the primary functional
|
||||
* interface method after type variables
|
||||
* are substituted with their instantiation
|
||||
* from the capture site
|
||||
* from the capture site.
|
||||
* @return a CallSite, which, when invoked, will return an instance of the
|
||||
* functional interface
|
||||
* @throws ReflectiveOperationException if the caller is not able to
|
||||
@ -220,15 +220,21 @@ public class LambdaMetafactory {
|
||||
* references to functional interfaces, which supports serialization and
|
||||
* other uncommon options.
|
||||
*
|
||||
* The declared argument list for this method is:
|
||||
* <p>The declared argument list for this method is:
|
||||
*
|
||||
* <pre>{@code
|
||||
* CallSite altMetafactory(MethodHandles.Lookup caller,
|
||||
* String invokedName,
|
||||
* MethodType invokedType,
|
||||
* Object... args)
|
||||
* }</pre>
|
||||
*
|
||||
* but it behaves as if the argument list is:
|
||||
* <p>but it behaves as if the argument list is as follows, where names that
|
||||
* appear in the argument list for
|
||||
* {@link #metafactory(MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType)}
|
||||
* have the same specification as in that method:
|
||||
*
|
||||
* <pre>{@code
|
||||
* CallSite altMetafactory(MethodHandles.Lookup caller,
|
||||
* String invokedName,
|
||||
* MethodType invokedType,
|
||||
@ -241,7 +247,15 @@ public class LambdaMetafactory {
|
||||
* int bridgeCount, // IF flags has BRIDGES set
|
||||
* MethodType... bridges // IF flags has BRIDGES set
|
||||
* )
|
||||
* }</pre>
|
||||
*
|
||||
* <p>If the flags contains {@code FLAG_SERIALIZABLE}, or one of the marker
|
||||
* interfaces extends {@link Serializable}, the metafactory will link the
|
||||
* call site to one that produces a serializable lambda. In addition to
|
||||
* the lambda instance implementing {@code Serializable}, it will have a
|
||||
* {@code writeReplace} method that returns an appropriate {@link
|
||||
* SerializedLambda}, and an appropriate {@code $deserializeLambda$}
|
||||
* method.
|
||||
*
|
||||
* @param caller Stacked automatically by VM; represents a lookup context
|
||||
* with the accessibility privileges of the caller.
|
||||
@ -257,7 +271,7 @@ public class LambdaMetafactory {
|
||||
* In the event that the implementation method is an
|
||||
* instance method, the first argument in the invocation
|
||||
* signature will correspond to the receiver.
|
||||
* @param args flags and optional arguments, as described above
|
||||
* @param args flags and optional arguments, as described above.
|
||||
* @return a CallSite, which, when invoked, will return an instance of the
|
||||
* functional interface
|
||||
* @throws ReflectiveOperationException if the caller is not able to
|
||||
|
@ -32,9 +32,26 @@ import java.security.PrivilegedExceptionAction;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Serialized form of a lambda expression. The properties of this class represent the information that is present
|
||||
* at the lambda factory site, including the identity of the primary functional interface method, the identity of the
|
||||
* implementation method, and any variables captured from the local environment at the time of lambda capture.
|
||||
* Serialized form of a lambda expression. The properties of this class
|
||||
* represent the information that is present at the lambda factory site, including
|
||||
* static metafactory arguments such as the identity of the primary functional
|
||||
* interface method and the identity of the implementation method, as well as
|
||||
* dynamic metafactory arguments such as values captured from the lexical scope
|
||||
* at the time of lambda capture.
|
||||
*
|
||||
* <p>Implementors of serializable lambdas, such as compilers or language
|
||||
* runtime libraries, are expected to ensure that instances deserialize properly.
|
||||
* One means to do so is to ensure that the {@code writeReplace} method returns
|
||||
* an instance of {@code SerializedLambda}, rather than allowing default
|
||||
* serialization to proceed.
|
||||
*
|
||||
* <p>{@code SerializedLambda} has a {@code readResolve} method that looks for
|
||||
* a (possibly private) static method called
|
||||
* {@code $deserializeLambda$(SerializedLambda)} in the capturing class, invokes
|
||||
* that with itself as the first argument, and returns the result. Lambda classes
|
||||
* implementing {@code $deserializeLambda$} are responsible for validating
|
||||
* that the properties of the {@code SerializedLambda} are consistent with a
|
||||
* lambda actually captured by that class.
|
||||
*
|
||||
* @see LambdaMetafactory
|
||||
*/
|
||||
|
@ -60,7 +60,7 @@ import sun.management.ManagementFactoryHelper;
|
||||
* one or more <i>platform MXBeans</i> representing
|
||||
* the management interface of a component of the Java virtual
|
||||
* machine.
|
||||
* <p>
|
||||
*
|
||||
* <h3><a name="MXBean">Platform MXBeans</a></h3>
|
||||
* <p>
|
||||
* A platform MXBean is a <i>managed bean</i> that
|
||||
|
@ -33,10 +33,8 @@ package java.lang.management;
|
||||
* The following table
|
||||
* provides a summary description of what the permission allows,
|
||||
* and discusses the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="Table shows permission target name, wh
|
||||
at the permission allows, and associated risks">
|
||||
* <table border=1 cellpadding=5 summary="Table shows permission target name, what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
* <th>Permission Target Name</th>
|
||||
* <th>What the Permission Allows</th>
|
||||
|
@ -79,7 +79,7 @@ import sun.management.MemoryUsageCompositeData;
|
||||
* </table>
|
||||
*
|
||||
* Below is a picture showing an example of a memory pool:
|
||||
* <p>
|
||||
*
|
||||
* <pre>
|
||||
* +----------------------------------------------+
|
||||
* +//////////////// | +
|
||||
@ -250,7 +250,7 @@ public class MemoryUsage {
|
||||
* Returns a <tt>MemoryUsage</tt> object represented by the
|
||||
* given <tt>CompositeData</tt>. The given <tt>CompositeData</tt>
|
||||
* must contain the following attributes:
|
||||
* <p>
|
||||
*
|
||||
* <blockquote>
|
||||
* <table border summary="The attributes and the types the given CompositeData contains">
|
||||
* <tr>
|
||||
|
@ -82,7 +82,7 @@ Java virtual machine and the runtime in the following ways:
|
||||
<b>1. Direct access to an MXBean interface</b>
|
||||
<p>
|
||||
<ul>
|
||||
<li>Get an MXBean instance locally in the running Java virtual machine:<p>
|
||||
<li>Get an MXBean instance locally in the running Java virtual machine:
|
||||
<pre>
|
||||
RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();
|
||||
|
||||
@ -103,7 +103,7 @@ Java virtual machine and the runtime in the following ways:
|
||||
<p>
|
||||
</li>
|
||||
<li>Construct an MXBean proxy instance that forwards the
|
||||
method calls to a given MBeanServer:<p>
|
||||
method calls to a given MBeanServer:
|
||||
<pre>
|
||||
MBeanServerConnection mbs;
|
||||
|
||||
|
@ -31,7 +31,6 @@ package java.lang.reflect;
|
||||
* The following table
|
||||
* provides a summary description of what the permission allows,
|
||||
* and discusses the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="Table shows permission target name, what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
|
@ -196,7 +196,7 @@ class DatagramSocket implements java.io.Closeable {
|
||||
* socket address.
|
||||
* <p>
|
||||
* If, if the address is {@code null}, creates an unbound socket.
|
||||
* <p>
|
||||
*
|
||||
* <p>If there is a security manager,
|
||||
* its {@code checkListen} method is first called
|
||||
* with the port from the socket address
|
||||
@ -1109,7 +1109,7 @@ class DatagramSocket implements java.io.Closeable {
|
||||
* represent the value of the TOS octet in IP packets sent by
|
||||
* the socket.
|
||||
* RFC 1349 defines the TOS values as follows:
|
||||
* <p>
|
||||
*
|
||||
* <UL>
|
||||
* <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
|
||||
* <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
|
||||
|
@ -133,7 +133,7 @@ import java.util.Arrays;
|
||||
* representation. However, it will be converted into an IPv4
|
||||
* address.</td></tr>
|
||||
* </table></blockquote>
|
||||
* <p>
|
||||
*
|
||||
* <h4><A NAME="scoped">Textual representation of IPv6 scoped addresses</a></h4>
|
||||
*
|
||||
* <p> The textual representation of IPv6 addresses as described above can be
|
||||
@ -150,11 +150,11 @@ import java.util.Arrays;
|
||||
*
|
||||
* <p> The general format for specifying the <i>scope_id</i> is the following:
|
||||
*
|
||||
* <p><blockquote><i>IPv6-address</i>%<i>scope_id</i></blockquote>
|
||||
* <blockquote><i>IPv6-address</i>%<i>scope_id</i></blockquote>
|
||||
* <p> The IPv6-address is a literal IPv6 address as described above.
|
||||
* The <i>scope_id</i> refers to an interface on the local system, and it can be
|
||||
* specified in two ways.
|
||||
* <p><ol><li><i>As a numeric identifier.</i> This must be a positive integer
|
||||
* <ol><li><i>As a numeric identifier.</i> This must be a positive integer
|
||||
* that identifies the particular interface and scope as understood by the
|
||||
* system. Usually, the numeric values can be determined through administration
|
||||
* tools on the system. Each interface may have multiple values, one for each
|
||||
|
@ -140,7 +140,7 @@ class MulticastSocket extends DatagramSocket {
|
||||
* Create a MulticastSocket bound to the specified socket address.
|
||||
* <p>
|
||||
* Or, if the address is {@code null}, create an unbound socket.
|
||||
* <p>
|
||||
*
|
||||
* <p>If there is a security manager,
|
||||
* its {@code checkListen} method is first called
|
||||
* with the SocketAddress port as its argument to ensure the operation is allowed.
|
||||
|
@ -46,7 +46,6 @@ import java.util.StringTokenizer;
|
||||
* The following table lists all the possible NetPermission target names,
|
||||
* and for each provides a description of what the permission allows
|
||||
* and a discussion of the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="Permission target name, what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
|
@ -66,8 +66,8 @@ public class Proxy {
|
||||
* Used, for instance, to create sockets bypassing any other global
|
||||
* proxy settings (like SOCKS):
|
||||
* <P>
|
||||
* {@code Socket s = new Socket(Proxy.NO_PROXY);}<br>
|
||||
* <P>
|
||||
* {@code Socket s = new Socket(Proxy.NO_PROXY);}
|
||||
*
|
||||
*/
|
||||
public final static Proxy NO_PROXY = new Proxy();
|
||||
|
||||
|
@ -1230,13 +1230,13 @@ class Socket implements java.io.Closeable {
|
||||
* Generally, the window size can be modified at any time when a socket is
|
||||
* connected. However, if a receive window larger than 64K is required then
|
||||
* this must be requested <B>before</B> the socket is connected to the
|
||||
* remote peer. There are two cases to be aware of:<p>
|
||||
* remote peer. There are two cases to be aware of:
|
||||
* <ol>
|
||||
* <li>For sockets accepted from a ServerSocket, this must be done by calling
|
||||
* {@link ServerSocket#setReceiveBufferSize(int)} before the ServerSocket
|
||||
* is bound to a local address.<p></li>
|
||||
* <li>For client sockets, setReceiveBufferSize() must be called before
|
||||
* connecting the socket to its remote peer.<p></li></ol>
|
||||
* connecting the socket to its remote peer.</li></ol>
|
||||
* @param size the size to which to set the receive buffer
|
||||
* size. This value must be greater than 0.
|
||||
*
|
||||
@ -1329,7 +1329,7 @@ class Socket implements java.io.Closeable {
|
||||
* represent the value of the TOS octet in IP packets sent by
|
||||
* the socket.
|
||||
* RFC 1349 defines the TOS values as follows:
|
||||
* <p>
|
||||
*
|
||||
* <UL>
|
||||
* <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
|
||||
* <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
|
||||
|
@ -134,7 +134,7 @@ public interface SocketOptions {
|
||||
* previously written data.
|
||||
*<P>
|
||||
* Valid for TCP only: SocketImpl.
|
||||
* <P>
|
||||
*
|
||||
* @see Socket#setTcpNoDelay
|
||||
* @see Socket#getTcpNoDelay
|
||||
*/
|
||||
@ -155,7 +155,7 @@ public interface SocketOptions {
|
||||
* This option <B>must</B> be specified in the constructor.
|
||||
* <P>
|
||||
* Valid for: SocketImpl, DatagramSocketImpl
|
||||
* <P>
|
||||
*
|
||||
* @see Socket#getLocalAddress
|
||||
* @see DatagramSocket#getLocalAddress
|
||||
*/
|
||||
@ -186,7 +186,7 @@ public interface SocketOptions {
|
||||
* want to use other than the system default. Takes/returns an InetAddress.
|
||||
* <P>
|
||||
* Valid for Multicast: DatagramSocketImpl
|
||||
* <P>
|
||||
*
|
||||
* @see MulticastSocket#setInterface(InetAddress)
|
||||
* @see MulticastSocket#getInterface()
|
||||
*/
|
||||
|
@ -779,27 +779,27 @@ public final class SocketPermission extends Permission
|
||||
* specified permission.
|
||||
* <P>
|
||||
* More specifically, this method first ensures that all of the following
|
||||
* are true (and returns false if any of them are not):<p>
|
||||
* are true (and returns false if any of them are not):
|
||||
* <ul>
|
||||
* <li> <i>p</i> is an instanceof SocketPermission,<p>
|
||||
* <li> <i>p</i> is an instanceof SocketPermission,
|
||||
* <li> <i>p</i>'s actions are a proper subset of this
|
||||
* object's actions, and<p>
|
||||
* object's actions, and
|
||||
* <li> <i>p</i>'s port range is included in this port range. Note:
|
||||
* port range is ignored when p only contains the action, 'resolve'.<p>
|
||||
* port range is ignored when p only contains the action, 'resolve'.
|
||||
* </ul>
|
||||
*
|
||||
* Then {@code implies} checks each of the following, in order,
|
||||
* and for each returns true if the stated condition is true:<p>
|
||||
* and for each returns true if the stated condition is true:
|
||||
* <ul>
|
||||
* <li> If this object was initialized with a single IP address and one of <i>p</i>'s
|
||||
* IP addresses is equal to this object's IP address.<p>
|
||||
* IP addresses is equal to this object's IP address.
|
||||
* <li>If this object is a wildcard domain (such as *.sun.com), and
|
||||
* <i>p</i>'s canonical name (the name without any preceding *)
|
||||
* ends with this object's canonical host name. For example, *.sun.com
|
||||
* implies *.eng.sun.com..<p>
|
||||
* implies *.eng.sun.com.
|
||||
* <li>If this object was not initialized with a single IP address, and one of this
|
||||
* object's IP addresses equals one of <i>p</i>'s IP addresses.<p>
|
||||
* <li>If this canonical name equals <i>p</i>'s canonical name.<p>
|
||||
* object's IP addresses equals one of <i>p</i>'s IP addresses.
|
||||
* <li>If this canonical name equals <i>p</i>'s canonical name.
|
||||
* </ul>
|
||||
*
|
||||
* If none of the above are true, {@code implies} returns false.
|
||||
|
@ -389,20 +389,20 @@ import java.lang.NullPointerException; // for javadoc
|
||||
* colon following a host name but no port (as in
|
||||
* {@code http://java.sun.com:} ), and that does not encode characters
|
||||
* except those that must be quoted, the following identities also hold:
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* new URI(<i>u</i>.getScheme(),
|
||||
* <i>u</i>.getSchemeSpecificPart(),
|
||||
* <i>u</i>.getFragment())
|
||||
* .equals(<i>u</i>)</pre>
|
||||
* in all cases,
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* new URI(<i>u</i>.getScheme(),
|
||||
* <i>u</i>.getUserInfo(), <i>u</i>.getAuthority(),
|
||||
* <i>u</i>.getPath(), <i>u</i>.getQuery(),
|
||||
* <i>u</i>.getFragment())
|
||||
* .equals(<i>u</i>)</pre>
|
||||
* if <i>u</i> is hierarchical, and
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* new URI(<i>u</i>.getScheme(),
|
||||
* <i>u</i>.getUserInfo(), <i>u</i>.getHost(), <i>u</i>.getPort(),
|
||||
* <i>u</i>.getPath(), <i>u</i>.getQuery(),
|
||||
|
@ -45,7 +45,7 @@ import sun.net.www.MessageHeader;
|
||||
* application and a URL. Instances of this class can be used both to
|
||||
* read from and to write to the resource referenced by the URL. In
|
||||
* general, creating a connection to a URL is a multistep process:
|
||||
* <p>
|
||||
*
|
||||
* <center><table border=2 summary="Describes the process of creating a connection to a URL: openConnection() and connect() over time.">
|
||||
* <tr><th>{@code openConnection()}</th>
|
||||
* <th>{@code connect()}</th></tr>
|
||||
|
@ -43,7 +43,7 @@ import java.io.*;
|
||||
* as the start of a special escaped sequence.
|
||||
* <p>
|
||||
* The following rules are applied in the conversion:
|
||||
* <p>
|
||||
*
|
||||
* <ul>
|
||||
* <li>The alphanumeric characters "{@code a}" through
|
||||
* "{@code z}", "{@code A}" through
|
||||
|
@ -49,7 +49,6 @@ import sun.security.action.GetPropertyAction;
|
||||
* <p>
|
||||
* When encoding a String, the following rules apply:
|
||||
*
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li>The alphanumeric characters "{@code a}" through
|
||||
* "{@code z}", "{@code A}" through
|
||||
|
@ -45,7 +45,7 @@ import java.security.Permission;
|
||||
* </pre>
|
||||
* <i>scheme</i> will typically be http or https, but is not restricted by this
|
||||
* class.
|
||||
* <i>authority</i> is specified as:<p>
|
||||
* <i>authority</i> is specified as:
|
||||
* <pre>
|
||||
* authority = hostrange [ : portrange ]
|
||||
* portrange = portnumber | -portnumber | portnumber-[portnumber] | *
|
||||
@ -223,7 +223,7 @@ public final class URLPermission extends Permission {
|
||||
* Checks if this URLPermission implies the given permission.
|
||||
* Specifically, the following checks are done as if in the
|
||||
* following sequence:
|
||||
* <p><ul>
|
||||
* <ul>
|
||||
* <li>if 'p' is not an instance of URLPermission return false</li>
|
||||
* <li>if any of p's methods are not in this's method list, and if
|
||||
* this's method list is not equal to "*", then return false.</li>
|
||||
@ -242,7 +242,7 @@ public final class URLPermission extends Permission {
|
||||
* <li>otherwise, return false</li>
|
||||
* </ul>
|
||||
* <p>Some examples of how paths are matched are shown below:
|
||||
* <p><table border>
|
||||
* <table border>
|
||||
* <caption>Examples of Path Matching</caption>
|
||||
* <tr><th>this's path</th><th>p's path</th><th>match</th></tr>
|
||||
* <tr><td>/a/b</td><td>/a/b</td><td>yes</td></tr>
|
||||
|
@ -127,9 +127,9 @@
|
||||
* resources, then convert it into a {@link java.net.URL} when it is time to
|
||||
* access the resource. From that URL, you can either get the
|
||||
* {@link java.net.URLConnection} for fine control, or get directly the
|
||||
* InputStream.<p>
|
||||
* InputStream.
|
||||
* <p>Here is an example:</p>
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* URI uri = new URI("http://java.sun.com/");
|
||||
* URL url = uri.toURL();
|
||||
* InputStream in = url.openStream();
|
||||
@ -147,7 +147,7 @@
|
||||
* the {@code java.protocol.handler.pkgs} system property. For instance if
|
||||
* it is set to {@code myapp.protocols}, then the URL code will try, in the
|
||||
* case of http, first to load {@code myapp.protocols.http.Handler}, then,
|
||||
* if this fails, {@code http.Handler} from the default location.<p>
|
||||
* if this fails, {@code http.Handler} from the default location.
|
||||
* <p>Note that the Handler class <b>has to</b> be a subclass of the abstract
|
||||
* class {@link java.net.URLStreamHandler}.</p>
|
||||
* <h2>Additional Specification</h2>
|
||||
|
@ -1129,7 +1129,7 @@ public abstract class $Type$Buffer
|
||||
*
|
||||
* <p> Two $type$ buffers are equal if, and only if,
|
||||
*
|
||||
* <p><ol>
|
||||
* <ol>
|
||||
*
|
||||
* <li><p> They have the same element type, </p></li>
|
||||
*
|
||||
|
@ -355,7 +355,7 @@ public abstract class FileSystem
|
||||
*
|
||||
* <p> The following rules are used to interpret glob patterns:
|
||||
*
|
||||
* <p> <ul>
|
||||
* <ul>
|
||||
* <li><p> The {@code *} character matches zero or more {@link Character
|
||||
* characters} of a {@link Path#getName(int) name} component without
|
||||
* crossing directory boundaries. </p></li>
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -28,35 +28,38 @@ package java.rmi;
|
||||
import java.security.*;
|
||||
|
||||
/**
|
||||
* A subclass of {@link SecurityManager} used by RMI applications that use
|
||||
* downloaded code. RMI's class loader will not download any classes from
|
||||
* remote locations if no security manager has been set.
|
||||
* <code>RMISecurityManager</code> does not apply to applets, which run
|
||||
* under the protection of their browser's security manager.
|
||||
* {@code RMISecurityManager} implements a policy identical to the policy
|
||||
* implemented by {@link SecurityManager}. RMI applications
|
||||
* should use the {@code SecurityManager} class or another appropriate
|
||||
* {@code SecurityManager} implementation instead of this class. RMI's class
|
||||
* loader will download classes from remote locations only if a security
|
||||
* manager has been set.
|
||||
*
|
||||
* <code>RMISecurityManager</code> implements a policy that
|
||||
* is no different than the policy implemented by {@link SecurityManager}.
|
||||
* Therefore an RMI application should use the <code>SecurityManager</code>
|
||||
* class or another application-specific <code>SecurityManager</code>
|
||||
* implementation instead of this class.
|
||||
* @implNote
|
||||
* <p>Applets typically run in a container that already has a security
|
||||
* manager, so there is generally no need for applets to set a security
|
||||
* manager. If you have a standalone application, you might need to set a
|
||||
* {@code SecurityManager} in order to enable class downloading. This can be
|
||||
* done by adding the following to your code. (It needs to be executed before
|
||||
* RMI can download code from remote hosts, so it most likely needs to appear
|
||||
* in the {@code main} method of your application.)
|
||||
*
|
||||
* <p>To use a <code>SecurityManager</code> in your application, add
|
||||
* the following statement to your code (it needs to be executed before RMI
|
||||
* can download code from remote hosts, so it most likely needs to appear
|
||||
* in the <code>main</code> method of your application):
|
||||
*
|
||||
* <pre>
|
||||
* System.setSecurityManager(new SecurityManager());
|
||||
* </pre>
|
||||
* <pre>{@code
|
||||
* if (System.getSecurityManager() == null) {
|
||||
* System.setSecurityManager(new SecurityManager());
|
||||
* }
|
||||
* }</pre>
|
||||
*
|
||||
* @author Roger Riggs
|
||||
* @author Peter Jones
|
||||
* @since JDK1.1
|
||||
**/
|
||||
* @deprecated Use {@link SecurityManager} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public class RMISecurityManager extends SecurityManager {
|
||||
|
||||
/**
|
||||
* Constructs a new <code>RMISecurityManager</code>.
|
||||
* Constructs a new {@code RMISecurityManager}.
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public RMISecurityManager() {
|
||||
|
@ -74,7 +74,7 @@ import sun.security.action.GetIntegerAction;
|
||||
* <code>ActivationGroup</code> will override the system properties
|
||||
* with the properties requested when its
|
||||
* <code>ActivationGroupDesc</code> was created, and will set a
|
||||
* <code>java.rmi.RMISecurityManager</code> as the default system
|
||||
* {@link SecurityManager} as the default system
|
||||
* security manager. If your application requires specific properties
|
||||
* to be set when objects are activated in the group, the application
|
||||
* should create a special <code>Properties</code> object containing
|
||||
@ -84,7 +84,7 @@ import sun.security.action.GetIntegerAction;
|
||||
* <code>ActivationDesc</code>s (before the default
|
||||
* <code>ActivationGroupDesc</code> is created). If your application
|
||||
* requires the use of a security manager other than
|
||||
* <code>java.rmi.RMISecurityManager</code>, in the
|
||||
* {@link SecurityManager}, in the
|
||||
* ActivativationGroupDescriptor properties list you can set
|
||||
* <code>java.security.manager</code> property to the name of the security
|
||||
* manager you would like to install.
|
||||
@ -154,21 +154,21 @@ public abstract class ActivationGroup
|
||||
* active). If the object does not call
|
||||
* <code>Activatable.inactive</code> when it deactivates, the
|
||||
* object will never be garbage collected since the group keeps
|
||||
* strong references to the objects it creates. <p>
|
||||
* strong references to the objects it creates.
|
||||
*
|
||||
* <p>The group's <code>inactiveObject</code> method unexports the
|
||||
* remote object from the RMI runtime so that the object can no
|
||||
* longer receive incoming RMI calls. An object will only be unexported
|
||||
* if the object has no pending or executing calls.
|
||||
* The subclass of <code>ActivationGroup</code> must override this
|
||||
* method and unexport the object. <p>
|
||||
* method and unexport the object.
|
||||
*
|
||||
* <p>After removing the object from the RMI runtime, the group
|
||||
* must inform its <code>ActivationMonitor</code> (via the monitor's
|
||||
* <code>inactiveObject</code> method) that the remote object is
|
||||
* not currently active so that the remote object will be
|
||||
* re-activated by the activator upon a subsequent activation
|
||||
* request.<p>
|
||||
* request.
|
||||
*
|
||||
* <p>This method simply informs the group's monitor that the object
|
||||
* is inactive. It is up to the concrete subclass of ActivationGroup
|
||||
@ -235,7 +235,7 @@ public abstract class ActivationGroup
|
||||
* <p>Note that if your application creates its own custom
|
||||
* activation group, a security manager must be set for that
|
||||
* group. Otherwise objects cannot be activated in the group.
|
||||
* <code>java.rmi.RMISecurityManager</code> is set by default.
|
||||
* {@link SecurityManager} is set by default.
|
||||
*
|
||||
* <p>If a security manager is already set in the group VM, this
|
||||
* method first calls the security manager's
|
||||
|
@ -67,7 +67,7 @@ public final class VMID implements java.io.Serializable {
|
||||
* conditions: a) the conditions for uniqueness for objects of
|
||||
* the class <code>java.rmi.server.UID</code> are satisfied, and b) an
|
||||
* address can be obtained for this host that is unique and constant
|
||||
* for the lifetime of this object. <p>
|
||||
* for the lifetime of this object.
|
||||
*/
|
||||
public VMID() {
|
||||
addr = randomBytes;
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1996, 1999, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -33,7 +33,9 @@ import java.rmi.*;
|
||||
*
|
||||
* @author Ann Wollrath
|
||||
* @since JDK1.1
|
||||
* @deprecated No replacement. This interface is unused and is obsolete.
|
||||
*/
|
||||
@Deprecated
|
||||
public interface ServerRef extends RemoteRef {
|
||||
|
||||
/** indicate compatibility with JDK 1.1.x version of class. */
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -30,7 +30,9 @@ package java.rmi.server;
|
||||
*
|
||||
* @author Ann Wollrath
|
||||
* @since JDK1.1
|
||||
**/
|
||||
* @deprecated This class is obsolete. Use {@link ExportException} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public class SocketSecurityException extends ExportException {
|
||||
|
||||
/* indicate compatibility with JDK 1.1.x version of class */
|
||||
|
@ -36,7 +36,7 @@ import sun.rmi.server.UnicastServerRef2;
|
||||
* below, the stub for a remote object being exported is obtained as
|
||||
* follows:
|
||||
*
|
||||
* <p><ul>
|
||||
* <ul>
|
||||
*
|
||||
* <li>If the remote object is exported using the {@link
|
||||
* #exportObject(Remote) UnicastRemoteObject.exportObject(Remote)} method,
|
||||
@ -66,9 +66,8 @@ import sun.rmi.server.UnicastServerRef2;
|
||||
* could not be loaded, or a problem occurs creating the stub instance, a
|
||||
* {@link StubNotFoundException} is thrown.
|
||||
*
|
||||
* <p>
|
||||
* <li>For all other means of exporting:
|
||||
* <p><ul>
|
||||
* <ul>
|
||||
*
|
||||
* <li>If the remote object's stub class (as defined above) could not be
|
||||
* loaded or the system property
|
||||
@ -93,7 +92,6 @@ import sun.rmi.server.UnicastServerRef2;
|
||||
* will be thrown.
|
||||
* </ul>
|
||||
*
|
||||
* <p>
|
||||
* <li>Otherwise, an instance of the remote object's stub class (as
|
||||
* described above) is used as the stub.
|
||||
*
|
||||
|
@ -39,9 +39,9 @@ import sun.reflect.Reflection;
|
||||
* <ul>
|
||||
* <li> to decide whether an access to a critical system
|
||||
* resource is to be allowed or denied, based on the security policy
|
||||
* currently in effect,<p>
|
||||
* currently in effect,
|
||||
* <li>to mark code as being "privileged", thus affecting subsequent
|
||||
* access determinations, and<p>
|
||||
* access determinations, and
|
||||
* <li>to obtain a "snapshot" of the current calling context so
|
||||
* access-control decisions from a different context can be made with
|
||||
* respect to the saved context. </ul>
|
||||
|
@ -48,7 +48,7 @@ import java.security.spec.AlgorithmParameterSpec;
|
||||
* of the prime modulus (in bits).
|
||||
* When using this approach, algorithm-specific parameter generation
|
||||
* values - if any - default to some standard values, unless they can be
|
||||
* derived from the specified size.<P>
|
||||
* derived from the specified size.
|
||||
*
|
||||
* <li>The other approach initializes a parameter generator object
|
||||
* using algorithm-specific semantics, which are represented by a set of
|
||||
|
@ -57,7 +57,6 @@ import java.io.IOException;
|
||||
* Subclasses may implement actions on top of BasicPermission,
|
||||
* if desired.
|
||||
* <p>
|
||||
* <P>
|
||||
* @see java.security.Permission
|
||||
* @see java.security.Permissions
|
||||
* @see java.security.PermissionCollection
|
||||
@ -153,9 +152,9 @@ public abstract class BasicPermission extends Permission
|
||||
* Checks if the specified permission is "implied" by
|
||||
* this object.
|
||||
* <P>
|
||||
* More specifically, this method returns true if:<p>
|
||||
* More specifically, this method returns true if:
|
||||
* <ul>
|
||||
* <li> <i>p</i>'s class is the same as this object's class, and<p>
|
||||
* <li> <i>p</i>'s class is the same as this object's class, and
|
||||
* <li> <i>p</i>'s name equals or (in the case of wildcards)
|
||||
* is implied by this object's
|
||||
* name. For example, "a.b.*" implies "a.b.c".
|
||||
|
@ -234,7 +234,7 @@ public class CodeSource implements java.io.Serializable {
|
||||
* Returns true if this CodeSource object "implies" the specified CodeSource.
|
||||
* <p>
|
||||
* More specifically, this method makes the following checks.
|
||||
* If any fail, it returns false. If they all succeed, it returns true.<p>
|
||||
* If any fail, it returns false. If they all succeed, it returns true.
|
||||
* <ul>
|
||||
* <li> <i>codesource</i> must not be null.
|
||||
* <li> If this object's certificates are not null, then all
|
||||
@ -242,7 +242,7 @@ public class CodeSource implements java.io.Serializable {
|
||||
* certificates.
|
||||
* <li> If this object's location (getLocation()) is not null, then the
|
||||
* following checks are made against this object's location and
|
||||
* <i>codesource</i>'s:<p>
|
||||
* <i>codesource</i>'s:
|
||||
* <ul>
|
||||
* <li> <i>codesource</i>'s location must not be null.
|
||||
*
|
||||
|
@ -39,7 +39,7 @@ package java.security;
|
||||
* RSA), which will work with those algorithms and with related
|
||||
* algorithms (such as MD5 with RSA, SHA-1 with RSA, Raw DSA, etc.)
|
||||
* The name of the algorithm of a key is obtained using the
|
||||
* {@link #getAlgorithm() getAlgorithm} method.<P>
|
||||
* {@link #getAlgorithm() getAlgorithm} method.
|
||||
*
|
||||
* <LI>An Encoded Form
|
||||
*
|
||||
@ -65,12 +65,11 @@ package java.security;
|
||||
* For more information, see
|
||||
* <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280:
|
||||
* Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a>.
|
||||
* <P>
|
||||
*
|
||||
* <LI>A Format
|
||||
*
|
||||
* <P>This is the name of the format of the encoded key. It is returned
|
||||
* by the {@link #getFormat() getFormat} method.<P>
|
||||
* by the {@link #getFormat() getFormat} method.
|
||||
*
|
||||
* </UL>
|
||||
*
|
||||
|
@ -77,7 +77,6 @@ import sun.security.jca.GetInstance.Instance;
|
||||
* providers might have precomputed parameter sets for more than just the
|
||||
* three modulus sizes mentioned above. Still others might not have a list of
|
||||
* precomputed parameters at all and instead always create new parameter sets.
|
||||
* <p>
|
||||
*
|
||||
* <li><b>Algorithm-Specific Initialization</b>
|
||||
* <p>For situations where a set of algorithm-specific parameters already
|
||||
|
@ -98,7 +98,6 @@ import javax.security.auth.callback.*;
|
||||
* KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
|
||||
* </pre>
|
||||
* The system will return a keystore implementation for the default type.
|
||||
* <p>
|
||||
*
|
||||
* <li>To provide a specific keystore type:
|
||||
* <pre>
|
||||
|
@ -54,21 +54,21 @@ import java.nio.ByteBuffer;
|
||||
*
|
||||
* <p>Implementations are free to implement the Cloneable interface.
|
||||
* Client applications can test cloneability by attempting cloning
|
||||
* and catching the CloneNotSupportedException: <p>
|
||||
* and catching the CloneNotSupportedException:
|
||||
*
|
||||
* <pre>
|
||||
* MessageDigest md = MessageDigest.getInstance("SHA");
|
||||
*
|
||||
* try {
|
||||
* md.update(toChapter1);
|
||||
* MessageDigest tc1 = md.clone();
|
||||
* byte[] toChapter1Digest = tc1.digest();
|
||||
* md.update(toChapter2);
|
||||
* ...etc.
|
||||
* } catch (CloneNotSupportedException cnse) {
|
||||
* throw new DigestException("couldn't make digest of partial content");
|
||||
* }
|
||||
* </pre>
|
||||
* <pre>{@code
|
||||
* MessageDigest md = MessageDigest.getInstance("SHA");
|
||||
*
|
||||
* try {
|
||||
* md.update(toChapter1);
|
||||
* MessageDigest tc1 = md.clone();
|
||||
* byte[] toChapter1Digest = tc1.digest();
|
||||
* md.update(toChapter2);
|
||||
* ...etc.
|
||||
* } catch (CloneNotSupportedException cnse) {
|
||||
* throw new DigestException("couldn't make digest of partial content");
|
||||
* }
|
||||
* }</pre>
|
||||
*
|
||||
* <p>Note that if a given implementation is not cloneable, it is
|
||||
* still possible to compute intermediate digests by instantiating
|
||||
|
@ -138,14 +138,14 @@ public abstract class Permission implements Guard, java.io.Serializable {
|
||||
* Returns the hash code value for this Permission object.
|
||||
* <P>
|
||||
* The required {@code hashCode} behavior for Permission Objects is
|
||||
* the following: <p>
|
||||
* the following:
|
||||
* <ul>
|
||||
* <li>Whenever it is invoked on the same Permission object more than
|
||||
* once during an execution of a Java application, the
|
||||
* {@code hashCode} method
|
||||
* must consistently return the same integer. This integer need not
|
||||
* remain consistent from one execution of an application to another
|
||||
* execution of the same application. <p>
|
||||
* execution of the same application.
|
||||
* <li>If two Permission objects are equal according to the
|
||||
* {@code equals}
|
||||
* method, then calling the {@code hashCode} method on each of the
|
||||
|
@ -37,7 +37,6 @@ import java.util.*;
|
||||
* collection, using the {@code implies} method.
|
||||
* <LI> enumerate all the permissions, using the {@code elements} method.
|
||||
* </UL>
|
||||
* <P>
|
||||
*
|
||||
* <p>When it is desirable to group together a number of Permission objects
|
||||
* of the same type, the {@code newPermissionCollection} method on that
|
||||
|
@ -44,7 +44,6 @@ import java.util.StringTokenizer;
|
||||
* The following table lists all the possible SecurityPermission target names,
|
||||
* and for each provides a description of what the permission allows
|
||||
* and a discussion of the risks of granting code the permission.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="target name,what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
@ -193,7 +192,6 @@ import java.util.StringTokenizer;
|
||||
* associated with classes that have been deprecated: {@link Identity},
|
||||
* {@link IdentityScope}, {@link Signer}. Use of them is discouraged. See the
|
||||
* applicable classes for more information.
|
||||
* <P>
|
||||
*
|
||||
* <table border=1 cellpadding=5 summary="target name,what the permission allows, and associated risks">
|
||||
* <tr>
|
||||
|
@ -77,13 +77,13 @@ import sun.security.jca.GetInstance.Instance;
|
||||
* (see {@link #initSign(PrivateKey)}
|
||||
* and {@link #initSign(PrivateKey, SecureRandom)}).
|
||||
*
|
||||
* </ul><p>
|
||||
* </ul>
|
||||
*
|
||||
* <li>Updating<p>
|
||||
* <li>Updating
|
||||
*
|
||||
* <p>Depending on the type of initialization, this will update the
|
||||
* bytes to be signed or verified. See the
|
||||
* {@link #update(byte) update} methods.<p>
|
||||
* {@link #update(byte) update} methods.
|
||||
*
|
||||
* <li>Signing or Verifying a signature on all updated bytes. See the
|
||||
* {@link #sign() sign} methods and the {@link #verify(byte[]) verify}
|
||||
|
@ -43,7 +43,7 @@ import java.io.*;
|
||||
* object passed to the constructor and the {@code verify} method.
|
||||
* A typical usage for signing is the following:
|
||||
*
|
||||
* <p> <pre>{@code
|
||||
* <pre>{@code
|
||||
* Signature signingEngine = Signature.getInstance(algorithm,
|
||||
* provider);
|
||||
* SignedObject so = new SignedObject(myobject, signingKey,
|
||||
@ -53,7 +53,7 @@ import java.io.*;
|
||||
* <p> A typical usage for verification is the following (having
|
||||
* received SignedObject {@code so}):
|
||||
*
|
||||
* <p> <pre>{@code
|
||||
* <pre>{@code
|
||||
* Signature verificationEngine =
|
||||
* Signature.getInstance(algorithm, provider);
|
||||
* if (so.verify(publickey, verificationEngine))
|
||||
|
@ -42,27 +42,27 @@ import java.security.Principal;
|
||||
* granted to the associated principal. If negative, the permissions
|
||||
* are to be denied.<p>
|
||||
*
|
||||
* The ACL Entries in each ACL observe the following rules:<p>
|
||||
* The ACL Entries in each ACL observe the following rules:
|
||||
*
|
||||
* <ul> <li>Each principal can have at most one positive ACL entry and
|
||||
* one negative entry; that is, multiple positive or negative ACL
|
||||
* entries are not allowed for any principal. Each entry specifies
|
||||
* the set of permissions that are to be granted (if positive) or
|
||||
* denied (if negative). <p>
|
||||
* denied (if negative).
|
||||
*
|
||||
* <li>If there is no entry for a particular principal, then the
|
||||
* principal is considered to have a null (empty) permission set.<p>
|
||||
* principal is considered to have a null (empty) permission set.
|
||||
*
|
||||
* <li>If there is a positive entry that grants a principal a
|
||||
* particular permission, and a negative entry that denies the
|
||||
* principal the same permission, the result is as though the
|
||||
* permission was never granted or denied. <p>
|
||||
* permission was never granted or denied.
|
||||
*
|
||||
* <li>Individual permissions always override permissions of the
|
||||
* group(s) to which the individual belongs. That is, individual
|
||||
* negative permissions (specific denial of permissions) override the
|
||||
* groups' positive permissions. And individual positive permissions
|
||||
* override the groups' negative permissions.<p>
|
||||
* override the groups' negative permissions.
|
||||
*
|
||||
* </ul>
|
||||
*
|
||||
@ -159,12 +159,12 @@ public interface Acl extends Owner {
|
||||
* Returns an enumeration for the set of allowed permissions for the
|
||||
* specified principal (representing an entity such as an individual or
|
||||
* a group). This set of allowed permissions is calculated as
|
||||
* follows:<p>
|
||||
* follows:
|
||||
*
|
||||
* <ul>
|
||||
*
|
||||
* <li>If there is no entry in this Access Control List for the
|
||||
* specified principal, an empty permission set is returned.<p>
|
||||
* specified principal, an empty permission set is returned.
|
||||
*
|
||||
* <li>Otherwise, the principal's group permission sets are determined.
|
||||
* (A principal can belong to one or more groups, where a group is a
|
||||
|
@ -63,7 +63,7 @@ import sun.security.jca.GetInstance.Instance;
|
||||
* supports those methods), so that each call to
|
||||
* {@code generateCertificate} consumes only one certificate, and the
|
||||
* read position of the input stream is positioned to the next certificate in
|
||||
* the file:<p>
|
||||
* the file:
|
||||
*
|
||||
* <pre>{@code
|
||||
* FileInputStream fis = new FileInputStream(filename);
|
||||
@ -78,7 +78,7 @@ import sun.security.jca.GetInstance.Instance;
|
||||
* }</pre>
|
||||
*
|
||||
* <p>The following example parses a PKCS#7-formatted certificate reply stored
|
||||
* in a file and extracts all the certificates from it:<p>
|
||||
* in a file and extracts all the certificates from it:
|
||||
*
|
||||
* <pre>
|
||||
* FileInputStream fis = new FileInputStream(filename);
|
||||
|
@ -299,7 +299,7 @@ public abstract class PKIXRevocationChecker extends PKIXCertPathChecker {
|
||||
/**
|
||||
* Allow revocation check to succeed if the revocation status cannot be
|
||||
* determined for one of the following reasons:
|
||||
* <p><ul>
|
||||
* <ul>
|
||||
* <li>The CRL or OCSP response cannot be obtained because of a
|
||||
* network error.
|
||||
* <li>The OCSP responder returns one of the following errors
|
||||
|
@ -35,7 +35,7 @@ import sun.security.util.DerValue;
|
||||
* structure.
|
||||
*
|
||||
* <p>The ASN.1 definition is as follows:
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* PolicyQualifierInfo ::= SEQUENCE {
|
||||
* policyQualifierId PolicyQualifierId,
|
||||
* qualifier ANY DEFINED BY policyQualifierId }
|
||||
|
@ -44,7 +44,6 @@ import sun.security.x509.X500Name;
|
||||
* individual parameters.
|
||||
* <p>
|
||||
* <b>Concurrent Access</b>
|
||||
* <p>
|
||||
* <p>All {@code TrustAnchor} objects must be immutable and
|
||||
* thread-safe. That is, multiple threads may concurrently invoke the
|
||||
* methods defined in this class on a single {@code TrustAnchor}
|
||||
|
@ -359,7 +359,7 @@ public class X509CertSelector implements CertSelector {
|
||||
* criticality setting, and encapsulating OCTET STRING)
|
||||
* for a SubjectKeyIdentifier extension.
|
||||
* The ASN.1 notation for this structure follows.
|
||||
* <p>
|
||||
*
|
||||
* <pre>{@code
|
||||
* SubjectKeyIdentifier ::= KeyIdentifier
|
||||
*
|
||||
@ -399,7 +399,7 @@ public class X509CertSelector implements CertSelector {
|
||||
* criticality setting, and encapsulating OCTET STRING)
|
||||
* for an AuthorityKeyIdentifier extension.
|
||||
* The ASN.1 notation for this structure follows.
|
||||
* <p>
|
||||
*
|
||||
* <pre>{@code
|
||||
* AuthorityKeyIdentifier ::= SEQUENCE {
|
||||
* keyIdentifier [0] KeyIdentifier OPTIONAL,
|
||||
|
@ -43,11 +43,11 @@ import java.security.*;
|
||||
*
|
||||
* <li>Get a key pair generator for the DSA algorithm by calling the
|
||||
* KeyPairGenerator {@code getInstance} method with "DSA"
|
||||
* as its argument.<p>
|
||||
* as its argument.
|
||||
*
|
||||
* <li>Initialize the generator by casting the result to a DSAKeyPairGenerator
|
||||
* and calling one of the
|
||||
* {@code initialize} methods from this DSAKeyPairGenerator interface.<p>
|
||||
* {@code initialize} methods from this DSAKeyPairGenerator interface.
|
||||
*
|
||||
* <li>Generate a key pair by calling the {@code generateKeyPair}
|
||||
* method from the KeyPairGenerator class.
|
||||
|
@ -125,7 +125,6 @@ import java.util.Locale;
|
||||
* valid patterns, but <code>"ab {0'}' de"</code>, <code>"ab } de"</code>
|
||||
* and <code>"''{''"</code> are not.
|
||||
*
|
||||
* <p>
|
||||
* <dl><dt><b>Warning:</b><dd>The rules for using quotes within message
|
||||
* format patterns unfortunately have shown to be somewhat confusing.
|
||||
* In particular, it isn't always obvious to localizers whether single
|
||||
@ -146,7 +145,7 @@ import java.util.Locale;
|
||||
* table shows how the values map to {@code Format} instances. Combinations not
|
||||
* shown in the table are illegal. A <i>SubformatPattern</i> must
|
||||
* be a valid pattern string for the {@code Format} subclass used.
|
||||
* <p>
|
||||
*
|
||||
* <table border=1 summary="Shows how FormatType and FormatStyle values map to Format instances">
|
||||
* <tr>
|
||||
* <th id="ft" class="TableHeadingColor">FormatType
|
||||
@ -215,7 +214,6 @@ import java.util.Locale;
|
||||
* <td headers="fs"><i>SubformatPattern</i>
|
||||
* <td headers="sc">{@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)}
|
||||
* </table>
|
||||
* <p>
|
||||
*
|
||||
* <h4>Usage Information</h4>
|
||||
*
|
||||
@ -761,7 +759,7 @@ public class MessageFormat extends Format {
|
||||
* as indicated by the first matching line of the following table. An
|
||||
* argument is <i>unavailable</i> if <code>arguments</code> is
|
||||
* <code>null</code> or has fewer than argumentIndex+1 elements.
|
||||
* <p>
|
||||
*
|
||||
* <table border=1 summary="Examples of subformat,argument,and formatted text">
|
||||
* <tr>
|
||||
* <th>Subformat
|
||||
|
@ -53,12 +53,12 @@ import sun.text.normalizer.NormalizerImpl;
|
||||
* several different ways in Unicode. For example, take the character A-acute.
|
||||
* In Unicode, this can be encoded as a single character (the "composed" form):
|
||||
*
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE</pre>
|
||||
*
|
||||
* or as two separate characters (the "decomposed" form):
|
||||
*
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* U+0041 LATIN CAPITAL LETTER A
|
||||
* U+0301 COMBINING ACUTE ACCENT</pre>
|
||||
*
|
||||
@ -72,14 +72,14 @@ import sun.text.normalizer.NormalizerImpl;
|
||||
* <p>
|
||||
* Similarly, the string "ffi" can be encoded as three separate letters:
|
||||
*
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* U+0066 LATIN SMALL LETTER F
|
||||
* U+0066 LATIN SMALL LETTER F
|
||||
* U+0069 LATIN SMALL LETTER I</pre>
|
||||
*
|
||||
* or as the single character
|
||||
*
|
||||
* <p><pre>
|
||||
* <pre>
|
||||
* U+FB03 LATIN SMALL LIGATURE FFI</pre>
|
||||
*
|
||||
* The ffi ligature is not a distinct semantic character, and strictly speaking
|
||||
|
@ -356,7 +356,6 @@ import sun.util.locale.provider.LocaleProviderAdapter;
|
||||
* may be replaced with other, locale dependent, pattern letters.
|
||||
* <code>SimpleDateFormat</code> does not deal with the localization of text
|
||||
* other than the pattern letters; that's up to the client of the class.
|
||||
* <p>
|
||||
*
|
||||
* <h4>Examples</h4>
|
||||
*
|
||||
|
@ -141,7 +141,7 @@ public final class Duration
|
||||
/**
|
||||
* The pattern for parsing.
|
||||
*/
|
||||
private final static Pattern PATTERN =
|
||||
private static final Pattern PATTERN =
|
||||
Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)D)?" +
|
||||
"(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?",
|
||||
Pattern.CASE_INSENSITIVE);
|
||||
@ -554,7 +554,7 @@ public final class Duration
|
||||
* the simple initialization in Duration.
|
||||
*/
|
||||
private static class DurationUnits {
|
||||
final static List<TemporalUnit> UNITS =
|
||||
static final List<TemporalUnit> UNITS =
|
||||
Collections.unmodifiableList(Arrays.<TemporalUnit>asList(SECONDS, NANOS));
|
||||
}
|
||||
|
||||
|
@ -1903,9 +1903,9 @@ public final class OffsetDateTime
|
||||
* <a href="../../serialized-form.html#java.time.Ser">dedicated serialized form</a>.
|
||||
* @serialData
|
||||
* <pre>
|
||||
* out.writeByte(10); // identifies a OffsetDateTime
|
||||
* out.writeObject(dateTime);
|
||||
* out.writeObject(offset);
|
||||
* out.writeByte(10); // identifies an OffsetDateTime
|
||||
* // the <a href="../../serialized-form.html#java.time.LocalDateTime">datetime</a> excluding the one byte header
|
||||
* // the <a href="../../serialized-form.html#java.time.ZoneOffset">offset</a> excluding the one byte header
|
||||
* </pre>
|
||||
*
|
||||
* @return the instance of {@code Ser}, not null
|
||||
@ -1924,13 +1924,13 @@ public final class OffsetDateTime
|
||||
}
|
||||
|
||||
void writeExternal(ObjectOutput out) throws IOException {
|
||||
out.writeObject(dateTime);
|
||||
out.writeObject(offset);
|
||||
dateTime.writeExternal(out);
|
||||
offset.writeExternal(out);
|
||||
}
|
||||
|
||||
static OffsetDateTime readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
|
||||
LocalDateTime dateTime = (LocalDateTime) in.readObject();
|
||||
ZoneOffset offset = (ZoneOffset) in.readObject();
|
||||
LocalDateTime dateTime = LocalDateTime.readExternal(in);
|
||||
ZoneOffset offset = ZoneOffset.readExternal(in);
|
||||
return OffsetDateTime.of(dateTime, offset);
|
||||
}
|
||||
|
||||
|
@ -1374,9 +1374,9 @@ public final class OffsetTime
|
||||
* <a href="../../serialized-form.html#java.time.Ser">dedicated serialized form</a>.
|
||||
* @serialData
|
||||
* <pre>
|
||||
* out.writeByte(9); // identifies a OffsetTime
|
||||
* out.writeObject(time);
|
||||
* out.writeObject(offset);
|
||||
* out.writeByte(9); // identifies an OffsetTime
|
||||
* // the <a href="../../serialized-form.html#java.time.LocalTime">time</a> excluding the one byte header
|
||||
* // the <a href="../../serialized-form.html#java.time.ZoneOffset">offset</a> excluding the one byte header
|
||||
* </pre>
|
||||
*
|
||||
* @return the instance of {@code Ser}, not null
|
||||
@ -1395,13 +1395,13 @@ public final class OffsetTime
|
||||
}
|
||||
|
||||
void writeExternal(ObjectOutput out) throws IOException {
|
||||
out.writeObject(time);
|
||||
out.writeObject(offset);
|
||||
time.writeExternal(out);
|
||||
offset.writeExternal(out);
|
||||
}
|
||||
|
||||
static OffsetTime readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
|
||||
LocalTime time = (LocalTime) in.readObject();
|
||||
ZoneOffset offset = (ZoneOffset) in.readObject();
|
||||
LocalTime time = LocalTime.readExternal(in);
|
||||
ZoneOffset offset = ZoneOffset.readExternal(in);
|
||||
return OffsetTime.of(time, offset);
|
||||
}
|
||||
|
||||
|
@ -138,13 +138,13 @@ public final class Period
|
||||
/**
|
||||
* The pattern for parsing.
|
||||
*/
|
||||
private final static Pattern PATTERN =
|
||||
private static final Pattern PATTERN =
|
||||
Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?", Pattern.CASE_INSENSITIVE);
|
||||
|
||||
/**
|
||||
* The set of supported units.
|
||||
*/
|
||||
private final static List<TemporalUnit> SUPPORTED_UNITS =
|
||||
private static final List<TemporalUnit> SUPPORTED_UNITS =
|
||||
Collections.unmodifiableList(Arrays.<TemporalUnit>asList(YEARS, MONTHS, DAYS));
|
||||
|
||||
/**
|
||||
|
@ -104,7 +104,7 @@ final class ChronoPeriodImpl
|
||||
/**
|
||||
* The set of supported units.
|
||||
*/
|
||||
private final static List<TemporalUnit> SUPPORTED_UNITS =
|
||||
private static final List<TemporalUnit> SUPPORTED_UNITS =
|
||||
Collections.unmodifiableList(Arrays.<TemporalUnit>asList(YEARS, MONTHS, DAYS));
|
||||
|
||||
/**
|
||||
|
@ -140,7 +140,7 @@ public final class JapaneseDate
|
||||
/**
|
||||
* The first day supported by the JapaneseChronology is Meiji 6, January 1st.
|
||||
*/
|
||||
final static LocalDate MEIJI_6_ISODATE = LocalDate.of(1873, 1, 1);
|
||||
static final LocalDate MEIJI_6_ISODATE = LocalDate.of(1873, 1, 1);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
/**
|
||||
|
@ -245,15 +245,15 @@ public final class WeekFields implements Serializable {
|
||||
/**
|
||||
* The field used to access the computed DayOfWeek.
|
||||
*/
|
||||
private transient final TemporalField dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
|
||||
private final transient TemporalField dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
|
||||
/**
|
||||
* The field used to access the computed WeekOfMonth.
|
||||
*/
|
||||
private transient final TemporalField weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
|
||||
private final transient TemporalField weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
|
||||
/**
|
||||
* The field used to access the computed WeekOfYear.
|
||||
*/
|
||||
private transient final TemporalField weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
|
||||
private final transient TemporalField weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
|
||||
/**
|
||||
* The field that represents the week-of-week-based-year.
|
||||
* <p>
|
||||
@ -261,7 +261,7 @@ public final class WeekFields implements Serializable {
|
||||
* <p>
|
||||
* This unit is an immutable and thread-safe singleton.
|
||||
*/
|
||||
private transient final TemporalField weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
|
||||
private final transient TemporalField weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
|
||||
/**
|
||||
* The field that represents the week-based-year.
|
||||
* <p>
|
||||
@ -269,7 +269,7 @@ public final class WeekFields implements Serializable {
|
||||
* <p>
|
||||
* This unit is an immutable and thread-safe singleton.
|
||||
*/
|
||||
private transient final TemporalField weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
|
||||
private final transient TemporalField weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
/**
|
||||
|
@ -171,9 +171,9 @@ final class Ser implements Externalizable {
|
||||
* <li><a href="../../../serialized-form.html#java.time.zone.ZoneRules">ZoneRules</a>
|
||||
* - {@code ZoneRules.of(standardTransitions, standardOffsets, savingsInstantTransitions, wallOffsets, lastRules);}
|
||||
* <li><a href="../../../serialized-form.html#java.time.zone.ZoneOffsetTransition">ZoneOffsetTransition</a>
|
||||
* - {@code ;}
|
||||
* - {@code ZoneOffsetTransition of(LocalDateTime.ofEpochSecond(epochSecond), offsetBefore, offsetAfter);}
|
||||
* <li><a href="../../../serialized-form.html#java.time.zone.ZoneOffsetTransitionRule">ZoneOffsetTransitionRule</a>
|
||||
* - {@code ;}
|
||||
* - {@code ZoneOffsetTransitionRule.of(month, dom, dow, time, timeEndOfDay, timeDefinition, standardOffset, offsetBefore, offsetAfter);}
|
||||
* </ul>
|
||||
* @param in the data to read, not null
|
||||
*/
|
||||
|
@ -191,7 +191,7 @@ public final class ZoneOffsetTransition
|
||||
* out.writeByte(2); // identifies a ZoneOffsetTransition
|
||||
* out.writeEpochSec(toEpochSecond);
|
||||
* out.writeOffset(offsetBefore);
|
||||
* out.writeOfset(offsetAfter);
|
||||
* out.writeOffset(offsetAfter);
|
||||
* }
|
||||
* </pre>
|
||||
* @return the replacing object, not null
|
||||
|
@ -40,7 +40,6 @@ import java.nio.charset.StandardCharsets;
|
||||
* <a href="http://www.ietf.org/rfc/rfc4648.txt">RFC 4648</a> and
|
||||
* <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>.
|
||||
*
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li><a name="basic"><b>Basic</b></a>
|
||||
* <p> Uses "The Base64 Alphabet" as specified in Table 1 of
|
||||
|
@ -1164,10 +1164,10 @@ public class BitSet implements Cloneable, java.io.Serializable {
|
||||
* <p>Example:
|
||||
* <pre>
|
||||
* BitSet drPepper = new BitSet();</pre>
|
||||
* Now {@code drPepper.toString()} returns "{@code {}}".<p>
|
||||
* Now {@code drPepper.toString()} returns "{@code {}}".
|
||||
* <pre>
|
||||
* drPepper.set(2);</pre>
|
||||
* Now {@code drPepper.toString()} returns "{@code {2}}".<p>
|
||||
* Now {@code drPepper.toString()} returns "{@code {2}}".
|
||||
* <pre>
|
||||
* drPepper.set(4);
|
||||
* drPepper.set(10);</pre>
|
||||
|
@ -56,7 +56,6 @@ package java.util;
|
||||
* <p>The twelve methods described above are summarized in the
|
||||
* following table:
|
||||
*
|
||||
* <p>
|
||||
* <table BORDER CELLPADDING=3 CELLSPACING=1>
|
||||
* <caption>Summary of Deque methods</caption>
|
||||
* <tr>
|
||||
@ -100,7 +99,6 @@ package java.util;
|
||||
* inherited from the {@code Queue} interface are precisely equivalent to
|
||||
* {@code Deque} methods as indicated in the following table:
|
||||
*
|
||||
* <p>
|
||||
* <table BORDER CELLPADDING=3 CELLSPACING=1>
|
||||
* <caption>Comparison of Queue and Deque methods</caption>
|
||||
* <tr>
|
||||
@ -139,7 +137,6 @@ package java.util;
|
||||
* beginning of the deque. Stack methods are precisely equivalent to
|
||||
* {@code Deque} methods as indicated in the table below:
|
||||
*
|
||||
* <p>
|
||||
* <table BORDER CELLPADDING=3 CELLSPACING=1>
|
||||
* <caption>Comparison of Stack and Deque methods</caption>
|
||||
* <tr>
|
||||
|
@ -127,7 +127,7 @@ public class DoubleSummaryStatistics implements DoubleConsumer {
|
||||
* numerical sum compared to a simple summation of {@code double}
|
||||
* values.
|
||||
*
|
||||
* @apiNote Sorting values by increasing absolute magnitude tends to yield
|
||||
* @apiNote Values sorted by increasing absolute magnitude tend to yield
|
||||
* more accurate results.
|
||||
*
|
||||
* @return the sum of values, or zero if none
|
||||
|
@ -94,10 +94,10 @@ public interface Iterator<E> {
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the given action for each remaining element, in the order
|
||||
* elements occur when iterating, until all elements have been processed or
|
||||
* the action throws an exception. Errors or runtime exceptions thrown by
|
||||
* the action are relayed to the caller.
|
||||
* Performs the given action for each remaining element until all elements
|
||||
* have been processed or the action throws an exception. Actions are
|
||||
* performed in the order of iteration, if that order is specified.
|
||||
* Exceptions thrown by the action are relayed to the caller.
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
|
@ -192,8 +192,9 @@ public interface List<E> extends Collection<E> {
|
||||
* The following code can be used to dump the list into a newly
|
||||
* allocated array of <tt>String</tt>:
|
||||
*
|
||||
* <pre>
|
||||
* String[] y = x.toArray(new String[0]);</pre>
|
||||
* <pre>{@code
|
||||
* String[] y = x.toArray(new String[0]);
|
||||
* }</pre>
|
||||
*
|
||||
* Note that <tt>toArray(new Object[0])</tt> is identical in function to
|
||||
* <tt>toArray()</tt>.
|
||||
@ -383,14 +384,13 @@ public interface List<E> extends Collection<E> {
|
||||
*
|
||||
* @implSpec
|
||||
* The default implementation is equivalent to, for this {@code list}:
|
||||
* <pre>
|
||||
* {@code
|
||||
* final ListIterator<E> li = list.listIterator();
|
||||
* while (li.hasNext()) {
|
||||
* li.set(operator.apply(li.next()));
|
||||
* }
|
||||
* }
|
||||
* </pre>
|
||||
* <pre>{@code
|
||||
* final ListIterator<E> li = list.listIterator();
|
||||
* while (li.hasNext()) {
|
||||
* li.set(operator.apply(li.next()));
|
||||
* }
|
||||
* }</pre>
|
||||
*
|
||||
* If the list's list-iterator does not support the {@code set} operation
|
||||
* then an {@code UnsupportedOperationException} will be thrown when
|
||||
* replacing the first element.
|
||||
@ -469,11 +469,11 @@ public interface List<E> extends Collection<E> {
|
||||
/**
|
||||
* Returns the hash code value for this list. The hash code of a list
|
||||
* is defined to be the result of the following calculation:
|
||||
* <pre>
|
||||
* int hashCode = 1;
|
||||
* for (E e : list)
|
||||
* hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
|
||||
* </pre>
|
||||
* <pre>{@code
|
||||
* int hashCode = 1;
|
||||
* for (E e : list)
|
||||
* hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
|
||||
* }</pre>
|
||||
* This ensures that <tt>list1.equals(list2)</tt> implies that
|
||||
* <tt>list1.hashCode()==list2.hashCode()</tt> for any two lists,
|
||||
* <tt>list1</tt> and <tt>list2</tt>, as required by the general
|
||||
@ -640,9 +640,9 @@ public interface List<E> extends Collection<E> {
|
||||
* a list can be used as a range operation by passing a subList view
|
||||
* instead of a whole list. For example, the following idiom
|
||||
* removes a range of elements from a list:
|
||||
* <pre>
|
||||
* <pre>{@code
|
||||
* list.subList(from, to).clear();
|
||||
* </pre>
|
||||
* }</pre>
|
||||
* Similar idioms may be constructed for <tt>indexOf</tt> and
|
||||
* <tt>lastIndexOf</tt>, and all of the algorithms in the
|
||||
* <tt>Collections</tt> class can be applied to a subList.<p>
|
||||
|
@ -1248,7 +1248,7 @@ public final class Locale implements Cloneable, Serializable {
|
||||
* Returns a string representation of this <code>Locale</code>
|
||||
* object, consisting of language, country, variant, script,
|
||||
* and extensions as below:
|
||||
* <p><blockquote>
|
||||
* <blockquote>
|
||||
* language + "_" + country + "_" + (variant + "_#" | "#") + script + "-" + extensions
|
||||
* </blockquote>
|
||||
*
|
||||
@ -2199,7 +2199,7 @@ public final class Locale implements Cloneable, Serializable {
|
||||
* are exactly "ja", "JP", "JP" or "th", "TH", "TH" and script/extensions
|
||||
* fields are empty, this method supplies <code>UNICODE_LOCALE_EXTENSION</code>
|
||||
* "ca"/"japanese" (calendar type is "japanese") or "nu"/"thai" (number script
|
||||
* type is "thai"). See <a href="Locale.html#special_cases_constructor"/>Special Cases</a>
|
||||
* type is "thai"). See <a href="Locale.html#special_cases_constructor">Special Cases</a>
|
||||
* for more information.
|
||||
*
|
||||
* @return an instance of <code>Locale</code> equivalent to
|
||||
|
@ -562,9 +562,8 @@ public interface Map<K,V> {
|
||||
// Defaultable methods
|
||||
|
||||
/**
|
||||
* Returns the value to which the specified key is mapped,
|
||||
* or {@code defaultValue} if this map contains no mapping
|
||||
* for the key.
|
||||
* Returns the value to which the specified key is mapped, or
|
||||
* {@code defaultValue} if this map contains no mapping for the key.
|
||||
*
|
||||
* <p>The default implementation makes no guarantees about synchronization
|
||||
* or atomicity properties of this method. Any implementation providing
|
||||
@ -591,9 +590,10 @@ public interface Map<K,V> {
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the given action on each entry in this map, in the order entries
|
||||
* are returned by an entry set iterator (which may be unspecified), until
|
||||
* all entries have been processed or the action throws an {@code Exception}.
|
||||
* Performs the given action for each entry in this map until all entries
|
||||
* have been processed or the action throws an exception. Unless
|
||||
* otherwise specified by the implementing class, actions are performed in
|
||||
* the order of entry set iteration (if an iteration order is specified.)
|
||||
* Exceptions thrown by the action are relayed to the caller.
|
||||
*
|
||||
* <p>The default implementation should be overridden by implementations if
|
||||
@ -636,9 +636,9 @@ public interface Map<K,V> {
|
||||
|
||||
/**
|
||||
* Replaces each entry's value with the result of invoking the given
|
||||
* function on that entry, in the order entries are returned by an entry
|
||||
* set iterator, until all entries have been processed or the function
|
||||
* throws an exception.
|
||||
* function on that entry until all entries have been processed or the
|
||||
* function throws an exception. Exceptions thrown by the function are
|
||||
* relayed to the caller.
|
||||
*
|
||||
* <p>The default implementation makes no guarantees about synchronization
|
||||
* or atomicity properties of this method. Any implementation providing
|
||||
|
@ -76,6 +76,7 @@ public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
|
||||
* @param action The action to be performed for each element
|
||||
* @throws NullPointerException if the specified action is null
|
||||
*/
|
||||
@SuppressWarnings("overloads")
|
||||
void forEachRemaining(T_CONS action);
|
||||
|
||||
/**
|
||||
@ -93,10 +94,10 @@ public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
|
||||
int nextInt();
|
||||
|
||||
/**
|
||||
* Performs the given action for each remaining element, in the order
|
||||
* elements occur when iterating, until all elements have been processed
|
||||
* or the action throws an exception. Errors or runtime exceptions
|
||||
* thrown by the action are relayed to the caller.
|
||||
* Performs the given action for each remaining element until all elements
|
||||
* have been processed or the action throws an exception. Actions are
|
||||
* performed in the order of iteration, if that order is specified.
|
||||
* Exceptions thrown by the action are relayed to the caller.
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
@ -167,10 +168,10 @@ public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
|
||||
long nextLong();
|
||||
|
||||
/**
|
||||
* Performs the given action for each remaining element, in the order
|
||||
* elements occur when iterating, until all elements have been processed
|
||||
* or the action throws an exception. Errors or runtime exceptions
|
||||
* thrown by the action are relayed to the caller.
|
||||
* Performs the given action for each remaining element until all elements
|
||||
* have been processed or the action throws an exception. Actions are
|
||||
* performed in the order of iteration, if that order is specified.
|
||||
* Exceptions thrown by the action are relayed to the caller.
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
@ -240,10 +241,10 @@ public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
|
||||
double nextDouble();
|
||||
|
||||
/**
|
||||
* Performs the given action for each remaining element, in the order
|
||||
* elements occur when iterating, until all elements have been processed
|
||||
* or the action throws an exception. Errors or runtime exceptions
|
||||
* thrown by the action are relayed to the caller.
|
||||
* Performs the given action for each remaining element until all elements
|
||||
* have been processed or the action throws an exception. Actions are
|
||||
* performed in the order of iteration, if that order is specified.
|
||||
* Exceptions thrown by the action are relayed to the caller.
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
|
@ -244,7 +244,6 @@ class Properties extends Hashtable<Object,Object> {
|
||||
* As an example, each of the following three lines specifies the key
|
||||
* {@code "Truth"} and the associated element value
|
||||
* {@code "Beauty"}:
|
||||
* <p>
|
||||
* <pre>
|
||||
* Truth = Beauty
|
||||
* Truth:Beauty
|
||||
@ -252,14 +251,12 @@ class Properties extends Hashtable<Object,Object> {
|
||||
* </pre>
|
||||
* As another example, the following three lines specify a single
|
||||
* property:
|
||||
* <p>
|
||||
* <pre>
|
||||
* fruits apple, banana, pear, \
|
||||
* cantaloupe, watermelon, \
|
||||
* kiwi, mango
|
||||
* </pre>
|
||||
* The key is {@code "fruits"} and the associated element is:
|
||||
* <p>
|
||||
* <pre>"apple, banana, pear, cantaloupe, watermelon, kiwi, mango"</pre>
|
||||
* Note that a space appears before each {@code \} so that a space
|
||||
* will appear after each comma in the final result; the {@code \},
|
||||
@ -268,13 +265,11 @@ class Properties extends Hashtable<Object,Object> {
|
||||
* characters.
|
||||
* <p>
|
||||
* As a third example, the line:
|
||||
* <p>
|
||||
* <pre>cheeses
|
||||
* </pre>
|
||||
* specifies that the key is {@code "cheeses"} and the associated
|
||||
* element is the empty string {@code ""}.<p>
|
||||
* element is the empty string {@code ""}.
|
||||
* <p>
|
||||
*
|
||||
* <a name="unicodeescapes"></a>
|
||||
* Characters in keys and elements can be represented in escape
|
||||
* sequences similar to those used for character and string literals
|
||||
|
@ -51,11 +51,10 @@ import sun.security.util.SecurityConstants;
|
||||
* signify a wildcard match. For example: "java.*" and "*" signify a wildcard
|
||||
* match, while "*java" and "a*b" do not.
|
||||
* <P>
|
||||
* <P>
|
||||
* The actions to be granted are passed to the constructor in a string containing
|
||||
* a list of one or more comma-separated keywords. The possible keywords are
|
||||
* "read" and "write". Their meaning is defined as follows:
|
||||
* <P>
|
||||
*
|
||||
* <DL>
|
||||
* <DT> read
|
||||
* <DD> read permission. Allows <code>System.getProperty</code> to
|
||||
@ -166,11 +165,11 @@ public final class PropertyPermission extends BasicPermission {
|
||||
* Checks if this PropertyPermission object "implies" the specified
|
||||
* permission.
|
||||
* <P>
|
||||
* More specifically, this method returns true if:<p>
|
||||
* More specifically, this method returns true if:
|
||||
* <ul>
|
||||
* <li> <i>p</i> is an instanceof PropertyPermission,<p>
|
||||
* <li> <i>p</i> is an instanceof PropertyPermission,
|
||||
* <li> <i>p</i>'s actions are a subset of this
|
||||
* object's actions, and <p>
|
||||
* object's actions, and
|
||||
* <li> <i>p</i>'s name is implied by this object's
|
||||
* name. For example, "java.*" implies "java.home".
|
||||
* </ul>
|
||||
|
@ -47,7 +47,6 @@ package java.util;
|
||||
* implementations; in most implementations, insert operations cannot
|
||||
* fail.
|
||||
*
|
||||
* <p>
|
||||
* <table BORDER CELLPADDING=3 CELLSPACING=1>
|
||||
* <caption>Summary of Queue methods</caption>
|
||||
* <tr>
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user