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

equal deleted inserted replaced

-:22badc53802f
+:bf24e33c7919
 * <p> The conversion of a pathname string to or from an abstract pathname is
 * inherently system-dependent.  When an abstract pathname is converted into a
 * pathname string, each name is separated from the next by a single copy of
 * the default <em>separator character</em>.  The default name-separator
 * character is defined by the system property <code>file.separator</code>, and
-* is made available in the public static fields <code>{@link
+* is made available in the public static fields {@link
-* #separator}</code> and <code>{@link #separatorChar}</code> of this class.
+* #separator} and {@link #separatorChar} of this class.
 * When a pathname string is converted into an abstract pathname, the names
 * within it may be separated by the default name-separator character or by any
 * other name-separator character that is supported by the underlying system.
 *
 * <p> A pathname, whether abstract or in string form, may be either
 * virtual machine was invoked.
 *
 * <p> The <em>parent</em> of an abstract pathname may be obtained by invoking
 * the {@link #getParent} method of this class and consists of the pathname's
 * prefix and each name in the pathname's name sequence except for the last.
-* Each directory's absolute pathname is an ancestor of any <tt>File</tt>
+* Each directory's absolute pathname is an ancestor of any {@code File}
 * object with an absolute abstract pathname which begins with the directory's
 * absolute pathname.  For example, the directory denoted by the abstract
-* pathname <tt>"/usr"</tt> is an ancestor of the directory denoted by the
+* pathname {@code "/usr"} is an ancestor of the directory denoted by the
-* pathname <tt>"/usr/local/bin"</tt>.
+* pathname {@code "/usr/local/bin"}.
 *
 * <p> The prefix concept is used to handle root directories on UNIX platforms,
 * and drive specifiers, root directories and UNC pathnames on Microsoft Windows platforms,
 * as follows:
 *
 public static final char separatorChar = fs.getSeparator();
 /**
 * The system-dependent default name-separator character, represented as a
 * string for convenience.  This string contains a single character, namely
-* <code>{@link #separatorChar}</code>.
+* {@link #separatorChar}.
 */
 public static final String separator = "" + separatorChar;
 /**
 * The system-dependent path-separator character.  This field is
 public static final char pathSeparatorChar = fs.getPathSeparator();
 /**
 * The system-dependent path-separator character, represented as a string
 * for convenience.  This string contains a single character, namely
-* <code>{@link #pathSeparatorChar}</code>.
+* {@link #pathSeparatorChar}.
 */
 public static final String pathSeparator = "" + pathSeparatorChar;
 /* -- Constructors -- */
 }
 this.prefixLength = fs.prefixLength(this.path);
 }
 /**
-* Creates a new <tt>File</tt> instance by converting the given
+* Creates a new {@code File} instance by converting the given
-* <tt>file:</tt> URI into an abstract pathname.
+* {@code file:} URI into an abstract pathname.
 *
-* <p> The exact form of a <tt>file:</tt> URI is system-dependent, hence
+* <p> The exact form of a {@code file:} URI is system-dependent, hence
 * the transformation performed by this constructor is also
 * system-dependent.
 *
 * <p> For a given abstract pathname <i>f</i> it is guaranteed that
 *
-* <blockquote><tt>
+* <blockquote><code>
-* new File(</tt><i>&nbsp;f</i><tt>.{@link #toURI() toURI}()).equals(</tt><i>&nbsp;f</i><tt>.{@link #getAbsoluteFile() getAbsoluteFile}())
+* new File(</code><i>&nbsp;f</i><code>.{@link #toURI()
-* </tt></blockquote>
+* toURI}()).equals(</code><i>&nbsp;f</i><code>.{@link #getAbsoluteFile() getAbsoluteFile}())
+* </code></blockquote>
 *
 * so long as the original abstract pathname, the URI, and the new abstract
 * pathname are all created in (possibly different invocations of) the same
 * Java virtual machine.  This relationship typically does not hold,
-* however, when a <tt>file:</tt> URI that is created in a virtual machine
+* however, when a {@code file:} URI that is created in a virtual machine
 * on one operating system is converted into an abstract pathname in a
 * virtual machine on a different operating system.
 *
 * @param  uri
 *         An absolute, hierarchical URI with a scheme equal to
-*         <tt>"file"</tt>, a non-empty path component, and undefined
+*         {@code "file"}, a non-empty path component, and undefined
 *         authority, query, and fragment components
 *
 * @throws  NullPointerException
-*          If <tt>uri</tt> is <tt>null</tt>
+*          If {@code uri} is {@code null}
 *
 * @throws  IllegalArgumentException
 *          If the preconditions on the parameter do not hold
 *
 * @see #toURI()
 /**
 * Returns the absolute pathname string of this abstract pathname.
 *
 * <p> If this abstract pathname is already absolute, then the pathname
-* string is simply returned as if by the <code>{@link #getPath}</code>
+* string is simply returned as if by the {@link #getPath}
 * method.  If this abstract pathname is the empty abstract pathname then
 * the pathname string of the current user directory, which is named by the
 * system property <code>user.dir</code>, is returned.  Otherwise this
 * pathname is resolved in a system-dependent way.  On UNIX systems, a
 * relative pathname is made absolute by resolving it against the current
 * <p> A canonical pathname is both absolute and unique.  The precise
 * definition of canonical form is system-dependent.  This method first
 * converts this pathname to absolute form if necessary, as if by invoking the
 * {@link #getAbsolutePath} method, and then maps it to its unique form in a
 * system-dependent way.  This typically involves removing redundant names
-* such as <tt>"."</tt> and <tt>".."</tt> from the pathname, resolving
+* such as {@code "."} and {@code ".."} from the pathname, resolving
 * symbolic links (on UNIX platforms), and converting drive letters to a
 * standard case (on Microsoft Windows platforms).
 *
 * <p> Every pathname that denotes an existing file or directory has a
 * unique canonical form.  Every pathname that denotes a nonexistent file
 *          construction of the canonical pathname may require
 *          filesystem queries
 *
 * @throws  SecurityException
 *          If a required system property value cannot be accessed, or
-*          if a security manager exists and its <code>{@link
+*          if a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead}</code> method denies
+*          java.lang.SecurityManager#checkRead} method denies
 *          read access to the file
 *
 * @since   1.1
 * @see     Path#toRealPath
 */
 *          construction of the canonical pathname may require
 *          filesystem queries
 *
 * @throws  SecurityException
 *          If a required system property value cannot be accessed, or
-*          if a security manager exists and its <code>{@link
+*          if a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead}</code> method denies
+*          java.lang.SecurityManager#checkRead} method denies
 *          read access to the file
 *
 * @since 1.2
 * @see     Path#toRealPath
 */
 }
 return new URL("file", "", slashify(getAbsolutePath(), isDirectory()));
 }
 /**
-* Constructs a <tt>file:</tt> URI that represents this abstract pathname.
+* Constructs a {@code file:} URI that represents this abstract pathname.
 *
 * <p> The exact form of the URI is system-dependent.  If it can be
 * determined that the file denoted by this abstract pathname is a
 * directory, then the resulting URI will end with a slash.
 *
 * <p> For a given abstract pathname <i>f</i>, it is guaranteed that
 *
-* <blockquote><tt>
+* <blockquote><code>
-* new {@link #File(java.net.URI) File}(</tt><i>&nbsp;f</i><tt>.toURI()).equals(</tt><i>&nbsp;f</i><tt>.{@link #getAbsoluteFile() getAbsoluteFile}())
+* new {@link #File(java.net.URI) File}(</code><i>&nbsp;f</i><code>.toURI()).equals(
-* </tt></blockquote>
+* </code><i>&nbsp;f</i><code>.{@link #getAbsoluteFile() getAbsoluteFile}())
+* </code></blockquote>
 *
 * so long as the original abstract pathname, the URI, and the new abstract
 * pathname are all created in (possibly different invocations of) the same
 * Java virtual machine.  Due to the system-dependent nature of abstract
 * pathnames, however, this relationship typically does not hold when a
-* <tt>file:</tt> URI that is created in a virtual machine on one operating
+* {@code file:} URI that is created in a virtual machine on one operating
 * system is converted into an abstract pathname in a virtual machine on a
 * different operating system.
 *
 * <p> Note that when this abstract pathname represents a UNC pathname then
 * all components of the UNC (including the server name component) are encoded
 * {@link Path#toUri toUri} method to encode the server name in the authority
 * component of the resulting {@code URI}. The {@link #toPath toPath} method
 * may be used to obtain a {@code Path} representing this abstract pathname.
 *
 * @return  An absolute, hierarchical URI with a scheme equal to
-*          <tt>"file"</tt>, a path representing this abstract pathname,
+*          {@code "file"}, a path representing this abstract pathname,
 *          and undefined authority, query, and fragment components
 * @throws SecurityException If a required system property value cannot
 * be accessed.
 *
 * @see #File(java.net.URI)
 * @return  <code>true</code> if and only if the file specified by this
 *          abstract pathname exists <em>and</em> can be read by the
 *          application; <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 */
 public boolean canRead() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 *          contains a file denoted by this abstract pathname <em>and</em>
 *          the application is allowed to write to the file;
 *          <code>false</code> otherwise.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 */
 public boolean canWrite() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 *
 * @return  <code>true</code> if and only if the file or directory denoted
 *          by this abstract pathname exists; <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file or directory
 */
 public boolean exists() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 * @return <code>true</code> if and only if the file denoted by this
 *          abstract pathname exists <em>and</em> is a directory;
 *          <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 */
 public boolean isDirectory() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 * @return  <code>true</code> if and only if the file denoted by this
 *          abstract pathname exists <em>and</em> is a normal file;
 *          <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 */
 public boolean isFile() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 * @return  <code>true</code> if and only if the file denoted by this
 *          abstract pathname is hidden according to the conventions of the
 *          underlying platform
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 *
 * @since 1.2
 */
 public boolean isHidden() {
 *          last modified, measured in milliseconds since the epoch
 *          (00:00:00 GMT, January 1, 1970), or <code>0L</code> if the
 *          file does not exist or if an I/O error occurs
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 */
 public long lastModified() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 *          pathname, or <code>0L</code> if the file does not exist.  Some
 *          operating systems may return <code>0L</code> for pathnames
 *          denoting system-dependent entities such as devices or pipes.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method denies read access to the file
 */
 public long length() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 *
 * @throws  IOException
 *          If an I/O error occurred
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.2
 */
 public boolean createNewFile() throws IOException {
 *
 * @return  <code>true</code> if and only if the file or directory is
 *          successfully deleted; <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkDelete}</code> method denies
+*          java.lang.SecurityManager#checkDelete} method denies
 *          delete access to the file
 */
 public boolean delete() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 * the resulting protocol cannot be made to work reliably. The
 * {@link java.nio.channels.FileLock FileLock}
 * facility should be used instead.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkDelete}</code> method denies
+*          java.lang.SecurityManager#checkDelete} method denies
 *          delete access to the file
 *
 * @see #delete
 *
 * @since 1.2
 *
 * @return  <code>true</code> if and only if the directory was
 *          created; <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method does not permit the named directory to be created
 */
 public boolean mkdir() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 * @return  <code>true</code> if and only if the directory was created,
 *          along with all necessary parent directories; <code>false</code>
 *          otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkRead(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkRead(java.lang.String)}
 *          method does not permit verification of the existence of the
 *          named directory and all necessary parent directories; or if
-*          the <code>{@link
+*          the {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method does not permit the named directory and all necessary
 *          parent directories to be created
 */
 public boolean mkdirs() {
 if (exists()) {
 *
 * @return  <code>true</code> if and only if the renaming succeeded;
 *          <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to either the old or new pathnames
 *
 * @throws  NullPointerException
 *          If parameter <code>dest</code> is <code>null</code>
 */
 *
 * <p> All platforms support file-modification times to the nearest second,
 * but some provide more precision.  The argument will be truncated to fit
 * the supported precision.  If the operation succeeds and no intervening
 * operations on the file take place, then the next invocation of the
-* <code>{@link #lastModified}</code> method will return the (possibly
+* {@link #lastModified} method will return the (possibly
 * truncated) <code>time</code> argument that was passed to this method.
 *
 * @param  time  The new last-modified time, measured in milliseconds since
 *               the epoch (00:00:00 GMT, January 1, 1970)
 *
 *          <code>false</code> otherwise
 *
 * @throws  IllegalArgumentException  If the argument is negative
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the named file
 *
 * @since 1.2
 */
 public boolean setLastModified(long time) {
 *
 * @return <code>true</code> if and only if the operation succeeded;
 *          <code>false</code> otherwise
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the named file
 *
 * @since 1.2
 */
 public boolean setReadOnly() {
 * @return  <code>true</code> if and only if the operation succeeded. The
 *          operation will fail if the user does not have permission to change
 *          the access permissions of this abstract pathname.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the named file
 *
 * @since 1.6
 */
 public boolean setWritable(boolean writable, boolean ownerOnly) {
 * A convenience method to set the owner's write permission for this abstract
 * pathname. On some platforms it may be possible to start the Java virtual
 * machine with special privileges that allow it to modify files that
 * disallow write operations.
 *
-* <p> An invocation of this method of the form <tt>file.setWritable(arg)</tt>
+* <p> An invocation of this method of the form {@code file.setWritable(arg)}
 * behaves in exactly the same way as the invocation
 *
-* <pre>
+* <pre>{@code
-*     file.setWritable(arg, true) </pre>
+*     file.setWritable(arg, true)
+* }</pre>
 *
 * @param   writable
 *          If <code>true</code>, sets the access permission to allow write
 *          operations; if <code>false</code> to disallow write operations
 *
 * @return  <code>true</code> if and only if the operation succeeded.  The
 *          operation will fail if the user does not have permission to
 *          change the access permissions of this abstract pathname.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setWritable(boolean writable) {
 *          <code>readable</code> is <code>false</code> and the underlying
 *          file system does not implement a read permission, then the
 *          operation will fail.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setReadable(boolean readable, boolean ownerOnly) {
 * A convenience method to set the owner's read permission for this abstract
 * pathname. On some platforms it may be possible to start the Java virtual
 * machine with special privileges that allow it to read files that are
 * marked as unreadable.
 *
-* <p>An invocation of this method of the form <tt>file.setReadable(arg)</tt>
+* <p>An invocation of this method of the form {@code file.setReadable(arg)}
 * behaves in exactly the same way as the invocation
 *
-* <pre>
+* <pre>{@code
-*     file.setReadable(arg, true) </pre>
+*     file.setReadable(arg, true)
+* }</pre>
 *
 * @param  readable
 *          If <code>true</code>, sets the access permission to allow read
 *          operations; if <code>false</code> to disallow read operations
 *
 *          <code>readable</code> is <code>false</code> and the underlying
 *          file system does not implement a read permission, then the
 *          operation will fail.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setReadable(boolean readable) {
 *          <code>executable</code> is <code>false</code> and the underlying
 *          file system does not implement an execute permission, then the
 *          operation will fail.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setExecutable(boolean executable, boolean ownerOnly) {
 * A convenience method to set the owner's execute permission for this
 * abstract pathname. On some platforms it may be possible to start the Java
 * virtual machine with special privileges that allow it to execute files
 * that are not marked executable.
 *
-* <p>An invocation of this method of the form <tt>file.setExcutable(arg)</tt>
+* <p>An invocation of this method of the form {@code file.setExcutable(arg)}
 * behaves in exactly the same way as the invocation
 *
-* <pre>
+* <pre>{@code
-*     file.setExecutable(arg, true) </pre>
+*     file.setExecutable(arg, true)
+* }</pre>
 *
 * @param   executable
 *          If <code>true</code>, sets the access permission to allow execute
 *          operations; if <code>false</code> to disallow execute operations
 *
 *           <code>executable</code> is <code>false</code> and the underlying
 *           file system does not implement an execute permission, then the
 *           operation will fail.
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method denies write access to the file
 *
 * @since 1.6
 */
 public boolean setExecutable(boolean executable) {
 *
 * @return  <code>true</code> if and only if the abstract pathname exists
 *          <em>and</em> the application is allowed to execute the file
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkExec(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkExec(java.lang.String)}
 *          method denies execute access to the file
 *
 * @since 1.6
 */
 public boolean canExecute() {
 /**
 * Returns the size of the partition <a href="#partName">named</a> by this
 * abstract pathname.
 *
-* @return  The size, in bytes, of the partition or <tt>0L</tt> if this
+* @return  The size, in bytes, of the partition or {@code 0L} if this
 *          abstract pathname does not name a partition
 *
 * @throws  SecurityException
 *          If a security manager has been installed and it denies
-*          {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
+*          {@link RuntimePermission}{@code ("getFileSystemAttributes")}
 *          or its {@link SecurityManager#checkRead(String)} method denies
 *          read access to the file named by this abstract pathname
 *
 * @since  1.6
 */
 * inaccurate by any external I/O operations including those made
 * on the system outside of this virtual machine.  This method
 * makes no guarantee that write operations to this file system
 * will succeed.
 *
-* @return  The number of unallocated bytes on the partition or <tt>0L</tt>
+* @return  The number of unallocated bytes on the partition or {@code 0L}
 *          if the abstract pathname does not name a partition.  This
 *          value will be less than or equal to the total file system size
 *          returned by {@link #getTotalSpace}.
 *
 * @throws  SecurityException
 *          If a security manager has been installed and it denies
-*          {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
+*          {@link RuntimePermission}{@code ("getFileSystemAttributes")}
 *          or its {@link SecurityManager#checkRead(String)} method denies
 *          read access to the file named by this abstract pathname
 *
 * @since  1.6
 */
 * after this call.  It is likely to be made inaccurate by any external
 * I/O operations including those made on the system outside of this
 * virtual machine.  This method makes no guarantee that write operations
 * to this file system will succeed.
 *
-* @return  The number of available bytes on the partition or <tt>0L</tt>
+* @return  The number of available bytes on the partition or {@code 0L}
 *          if the abstract pathname does not name a partition.  On
 *          systems where this information is not available, this method
 *          will be equivalent to a call to {@link #getFreeSpace}.
 *
 * @throws  SecurityException
 *          If a security manager has been installed and it denies
-*          {@link RuntimePermission}<tt>("getFileSystemAttributes")</tt>
+*          {@link RuntimePermission}{@code ("getFileSystemAttributes")}
 *          or its {@link SecurityManager#checkRead(String)} method denies
 *          read access to the file named by this abstract pathname
 *
 * @since  1.6
 */
 *      machine.
 * </ol>
 *
 * This method provides only part of a temporary-file facility.  To arrange
 * for a file created by this method to be deleted automatically, use the
-* <code>{@link #deleteOnExit}</code> method.
+* {@link #deleteOnExit} method.
 *
 * <p> The <code>prefix</code> argument must be at least three characters
 * long.  It is recommended that the prefix be a short, meaningful string
 * such as <code>"hjb"</code> or <code>"mail"</code>.  The
 * <code>suffix</code> argument may be <code>null</code>, in which case the
 *          characters
 *
 * @throws  IOException  If a file could not be created
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method does not allow a file to be created
 *
 * @since 1.2
 */
 public static File createTempFile(String prefix, String suffix,
 }
 /**
 * Creates an empty file in the default temporary-file directory, using
 * the given prefix and suffix to generate its name. Invoking this method
-* is equivalent to invoking <code>{@link #createTempFile(java.lang.String,
+* is equivalent to invoking {@link #createTempFile(java.lang.String,
 * java.lang.String, java.io.File)
-* createTempFile(prefix,&nbsp;suffix,&nbsp;null)}</code>.
+* createTempFile(prefix,&nbsp;suffix,&nbsp;null)}.
 *
 * <p> The {@link
 * java.nio.file.Files#createTempFile(String,String,java.nio.file.attribute.FileAttribute[])
 * Files.createTempFile} method provides an alternative method to create an
 * empty file in the temporary-file directory. Files created by that method
 *          characters
 *
 * @throws  IOException  If a file could not be created
 *
 * @throws  SecurityException
-*          If a security manager exists and its <code>{@link
+*          If a security manager exists and its {@link
-*          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+*          java.lang.SecurityManager#checkWrite(java.lang.String)}
 *          method does not allow a file to be created
 *
 * @since 1.2
 * @see java.nio.file.Files#createTempDirectory(String,FileAttribute[])
 */
 return fs.hashCode(this);
 }
 /**
 * Returns the pathname string of this abstract pathname.  This is just the
-* string returned by the <code>{@link #getPath}</code> method.
+* string returned by the {@link #getPath} method.
 *
 * @return  The string form of this abstract pathname
 */
 public String toString() {
 return getPath();

changeset 32033	bf24e33c7919
parent 31061	fead7d86d75f
child 32649	2ee9017c7597