line wrap: on
line source
/* * Copyright [c] 1994, 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 * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details [a copy is included in the LICENSE file that * accompanied this code]. * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.io; import java.net.URI; import java.net.URL; import java.net.MalformedURLException; import java.net.URISyntaxException; import java.util.List; import java.util.ArrayList; import java.security.AccessController; import java.security.SecureRandom; import java.nio.file.Path; import java.nio.file.FileSystems; import sun.security.action.GetPropertyAction; /** * An abstract representation of file and directory pathnames. * ** * @param writable * IfUser interfaces and operating systems use system-dependent pathname
* strings to name files and directories. This class presents an * abstract, system-independent view of hierarchical pathnames. An * abstract pathname has two components: * **
An optional system-dependent prefix string, * such as a disk-drive specifier,"/"
for the UNIX root * directory, or"\\\\"
for a Microsoft Windows UNC pathname, and *A sequence of zero or more string names. * * * The first name in an abstract pathname may be a directory name or, in the * case of Microsoft Windows UNC pathnames, a hostname. Each subsequent name * in an abstract pathname denotes a directory; the last name may denote * either a directory or a file. The empty abstract pathname has no * prefix and an empty name sequence. * *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 separator character. The default name-separator * character is defined by the system propertyfile.separator
, and * is made available in the public static fields{@link
* #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. * *A pathname, whether abstract or in string form, may be either
* absolute or relative. An absolute pathname is complete in * that no other information is required in order to locate the file that it * denotes. A relative pathname, in contrast, must be interpreted in terms of * information taken from some other pathname. By default the classes in the *java.io
package always resolve relative pathnames against the * current user directory. This directory is named by the system property *user.dir
, and is typically the directory in which the Java * virtual machine was invoked. * *The parent 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 File * object with an absolute abstract pathname which begins with the directory's * absolute pathname. For example, the directory denoted by the abstract * pathname "/usr" is an ancestor of the directory denoted by the * pathname "/usr/local/bin". * *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: * ** *
For UNIX platforms, the prefix of an absolute pathname is always *"/"
. Relative pathnames have no prefix. The abstract pathname * denoting the root directory has the prefix"/"
and an empty * name sequence. * *For Microsoft Windows platforms, the prefix of a pathname that contains a drive * specifier consists of the drive letter followed by":"
and * possibly followed by"\\"
if the pathname is absolute. The * prefix of a UNC pathname is"\\\\"
; the hostname and the share * name are the first two names in the name sequence. A relative pathname that * does not specify a drive has no prefix. * * * *Instances of this class may or may not denote an actual file-system
* object such as a file or a directory. If it does denote such an object * then that object resides in a partition. A partition is an * operating system-specific portion of storage for a file system. A single * storage device [e.g. a physical disk-drive, flash memory, CD-ROM] may * contain multiple partitions. The object, if any, will reside on the * partition {@code java.nio.file} * package defines interfaces and classes for the Java virtual machine to access * files, file attributes, and file systems. This API may be used to overcome * many of the limitations of the {@code java.io.File} class. * The {@link #toPath toPath} method may be used to obtain a {@link * Path} that uses the abstract path represented by a {@code File} object to * locate a file. The resulting {@code Path} may be used with the {@link * java.nio.file.Files} class to provide more efficient and extensive access to * additional file operations, file attributes, and I/O exceptions to help * diagnose errors when an operation on a file fails. * * @author unascribed * @since JDK1.0 */ public class File implements Serializable, Comparable { /** * The FileSystem object representing the platform's local file system. */ private static final FileSystem fs = DefaultFileSystem.getFileSystem[]; /** * This abstract pathname's normalized pathname string. A normalized * pathname string uses the default name-separator character and does not * contain any duplicate or redundant separators. * * @serial */ private final String path; /** * Enum type that indicates the status of a file path. */ private static enum PathStatus { INVALID, CHECKED }; /** * The flag indicating whether the file path is invalid. */ private transient PathStatus status = null; /** * Check if the file has an invalid path. Currently, the inspection of * a file path is very limited, and it only covers Nul character check. * Returning true means the path is definitely invalid/garbage. But * returning false does not guarantee that the path is valid. * * @return true if the file path is invalid. */ final boolean isInvalid[] { if [status == null] { status = [this.path.indexOf['\u0000'] < 0] ? PathStatus.CHECKED : PathStatus.INVALID; } return status == PathStatus.INVALID; } /** * The length of this abstract pathname's prefix, or zero if it has no * prefix. */ private final transient int prefixLength; /** * Returns the length of this abstract pathname's prefix. * For use by FileSystem classes. */ int getPrefixLength[] { return prefixLength; } /** * The system-dependent default name-separator character. This field is * initialized to contain the first character of the value of the system * propertyfile.separator
. On UNIX systems the value of this * field is'/'
; on Microsoft Windows systems it is'\\'
. * * @see java.lang.System#getProperty[java.lang.String] */ 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 *{@link #separatorChar}
. */ public static final String separator = "" + separatorChar; /** * The system-dependent path-separator character. This field is * initialized to contain the first character of the value of the system * propertypath.separator
. This character is used to * separate filenames in a sequence of files given as a path list. * On UNIX systems, this character is':'
; on Microsoft Windows systems it * is';'
. * * @see java.lang.System#getProperty[java.lang.String] */ 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 *{@link #pathSeparatorChar}
. */ public static final String pathSeparator = "" + pathSeparatorChar; /* -- Constructors -- */ /** * Internal constructor for already-normalized pathname strings. */ private File[String pathname, int prefixLength] { this.path = pathname; this.prefixLength = prefixLength; } /** * Internal constructor for already-normalized pathname strings. * The parameter order is used to disambiguate this method from the * public[File, String] constructor. */ private File[String child, File parent] { assert parent.path != null; assert [!parent.path.equals[""]]; this.path = fs.resolve[parent.path, child]; this.prefixLength = parent.prefixLength; } /** * Creates a newFile
instance by converting the given * pathname string into an abstract pathname. If the given string is * the empty string, then the result is the empty abstract pathname. * * @param pathname A pathname string * @throws NullPointerException * If thepathname
argument isnull
*/ public File[String pathname] { if [pathname == null] { throw new NullPointerException[]; } this.path = fs.normalize[pathname]; this.prefixLength = fs.prefixLength[this.path]; } /* Note: The two-argument File constructors do not interpret an empty parent abstract pathname as the current user directory. An empty parent instead causes the child to be resolved against the system-dependent directory defined by the FileSystem.getDefaultParent method. On Unix this default is "/", while on Microsoft Windows it is "\\". This is required for compatibility with the original behavior of this class. */ /** * Creates a newFile
instance from a parent pathname string * and a child pathname string. * *If
*parent
isnull
then the newFile
instance is created as if by invoking the * single-argumentFile
constructor on the given *child
pathname string. * *Otherwise the
* a directory, and theparent
pathname string is taken to denotechild
pathname string is taken to * denote either a directory or a file. If thechild
pathname * string is absolute then it is converted into a relative pathname in a * system-dependent way. Ifparent
is the empty string then * the newFile
instance is created by converting *child
into an abstract pathname and resolving the result * against a system-dependent default directory. Otherwise each pathname * string is converted into an abstract pathname and the child abstract * pathname is resolved against the parent. * * @param parent The parent pathname string * @param child The child pathname string * @throws NullPointerException * Ifchild
isnull
*/ public File[String parent, String child] { if [child == null] { throw new NullPointerException[]; } if [parent != null] { if [parent.equals[""]] { this.path = fs.resolve[fs.getDefaultParent[], fs.normalize[child]]; } else { this.path = fs.resolve[fs.normalize[parent], fs.normalize[child]]; } } else { this.path = fs.normalize[child]; } this.prefixLength = fs.prefixLength[this.path]; } /** * Creates a newFile
instance from a parent abstract * pathname and a child pathname string. * *If
*parent
isnull
then the newFile
instance is created as if by invoking the * single-argumentFile
constructor on the given *child
pathname string. * *Otherwise the
* denote a directory, and theparent
abstract pathname is taken tochild
pathname string is taken * to denote either a directory or a file. If thechild
* pathname string is absolute then it is converted into a relative * pathname in a system-dependent way. Ifparent
is the empty * abstract pathname then the newFile
instance is created by * convertingchild
into an abstract pathname and resolving * the result against a system-dependent default directory. Otherwise each * pathname string is converted into an abstract pathname and the child * abstract pathname is resolved against the parent. * * @param parent The parent abstract pathname * @param child The child pathname string * @throws NullPointerException * Ifchild
isnull
*/ public File[File parent, String child] { if [child == null] { throw new NullPointerException[]; } if [parent != null] { if [parent.path.equals[""]] { this.path = fs.resolve[fs.getDefaultParent[], fs.normalize[child]]; } else { this.path = fs.resolve[parent.path, fs.normalize[child]]; } } else { this.path = fs.normalize[child]; } this.prefixLength = fs.prefixLength[this.path]; } /** * Creates a new File instance by converting the given * file: URI into an abstract pathname. * *The exact form of a file: URI is system-dependent, hence
* the transformation performed by this constructor is also * system-dependent. * *For a given abstract pathname f it is guaranteed that
* * * new File[ f.{@link #toURI[] toURI}[]].equals[ f.{@link #getAbsoluteFile[] getAbsoluteFile}[]] * * * 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 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 * "file", a non-empty path component, and undefined * authority, query, and fragment components * * @throws NullPointerException * If uri is null * * @throws IllegalArgumentException * If the preconditions on the parameter do not hold * * @see #toURI[] * @see java.net.URI * @since 1.4 */ public File[URI uri] { // Check our many preconditions if [!uri.isAbsolute[]] throw new IllegalArgumentException["URI is not absolute"]; if [uri.isOpaque[]] throw new IllegalArgumentException["URI is not hierarchical"]; String scheme = uri.getScheme[]; if [[scheme == null] || !scheme.equalsIgnoreCase["file"]] throw new IllegalArgumentException["URI scheme is not \"file\""]; if [uri.getAuthority[] != null] throw new IllegalArgumentException["URI has an authority component"]; if [uri.getFragment[] != null] throw new IllegalArgumentException["URI has a fragment component"]; if [uri.getQuery[] != null] throw new IllegalArgumentException["URI has a query component"]; String p = uri.getPath[]; if [p.equals[""]] throw new IllegalArgumentException["URI path component is empty"]; // Okay, now initialize p = fs.fromURIPath[p]; if [File.separatorChar != '/'] p = p.replace['/', File.separatorChar]; this.path = fs.normalize[p]; this.prefixLength = fs.prefixLength[this.path]; } /* -- Path-component accessors -- */ /** * Returns the name of the file or directory denoted by this abstract * pathname. This is just the last name in the pathname's name * sequence. If the pathname's name sequence is empty, then the empty * string is returned. * * @return The name of the file or directory denoted by this abstract * pathname, or the empty string if this pathname's name sequence * is empty */ public String getName[] { int index = path.lastIndexOf[separatorChar]; if [index < prefixLength] return path.substring[prefixLength]; return path.substring[index + 1]; } /** * Returns the pathname string of this abstract pathname's parent, or *null
if this pathname does not name a parent directory. * *The parent of an abstract pathname consists of the
* pathname's prefix, if any, and each name in the pathname's name * sequence except for the last. If the name sequence is empty then * the pathname does not name a parent directory. * * @return The pathname string of the parent directory named by this * abstract pathname, ornull
if this pathname * does not name a parent */ public String getParent[] { int index = path.lastIndexOf[separatorChar]; if [index < prefixLength] { if [[prefixLength > 0] && [path.length[] > prefixLength]] return path.substring[0, prefixLength]; return null; } return path.substring[0, index]; } /** * Returns the abstract pathname of this abstract pathname's parent, * ornull
if this pathname does not name a parent * directory. * *The parent of an abstract pathname consists of the
* pathname's prefix, if any, and each name in the pathname's name * sequence except for the last. If the name sequence is empty then * the pathname does not name a parent directory. * * @return The abstract pathname of the parent directory named by this * abstract pathname, ornull
if this pathname * does not name a parent * * @since 1.2 */ public File getParentFile[] { String p = this.getParent[]; if [p == null] return null; return new File[p, this.prefixLength]; } /** * Converts this abstract pathname into a pathname string. The resulting * string uses the {@link #separator default name-separator character} to * separate the names in the name sequence. * * @return The string form of this abstract pathname */ public String getPath[] { return path; } /* -- Path operations -- */ /** * Tests whether this abstract pathname is absolute. The definition of * absolute pathname is system dependent. On UNIX systems, a pathname is * absolute if its prefix is"/"
. On Microsoft Windows systems, a * pathname is absolute if its prefix is a drive specifier followed by *"\\"
, or if its prefix is"\\\\"
. * * @returntrue
if this abstract pathname is absolute, *false
otherwise */ public boolean isAbsolute[] { return fs.isAbsolute[this]; } /** * Returns the absolute pathname string of this abstract pathname. * *If this abstract pathname is already absolute, then the pathname
* 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 propertyuser.dir
, 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 * user directory. On Microsoft Windows systems, a relative pathname is made absolute * by resolving it against the current directory of the drive named by the * pathname, if any; if not, it is resolved against the current user * directory. * * @return The absolute pathname string denoting the same file or * directory as this abstract pathname * * @throws SecurityException * If a required system property value cannot be accessed. * * @see java.io.File#isAbsolute[] */ public String getAbsolutePath[] { return fs.resolve[this]; } /** * Returns the absolute form of this abstract pathname. Equivalent to *new File[this.{@link #getAbsolutePath}]
. * * @return The absolute abstract pathname denoting the same file or * directory as this abstract pathname * * @throws SecurityException * If a required system property value cannot be accessed. * * @since 1.2 */ public File getAbsoluteFile[] { String absPath = getAbsolutePath[]; return new File[absPath, fs.prefixLength[absPath]]; } /** * Returns the canonical pathname string of this abstract pathname. * *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 "." and ".." from the pathname, resolving * symbolic links [on UNIX platforms], and converting drive letters to a * standard case [on Microsoft Windows platforms]. * *Every pathname that denotes an existing file or directory has a
* unique canonical form. Every pathname that denotes a nonexistent file * or directory also has a unique canonical form. The canonical form of * the pathname of a nonexistent file or directory may be different from * the canonical form of the same pathname after the file or directory is * created. Similarly, the canonical form of the pathname of an existing * file or directory may be different from the canonical form of the same * pathname after the file or directory is deleted. * * @return The canonical pathname string denoting the same file or * directory as this abstract pathname * * @throws IOException * If an I/O error occurs, which is possible because the * 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{@link
* java.lang.SecurityManager#checkRead} method denies * read access to the file * * @since JDK1.1 * @see Path#toRealPath */ public String getCanonicalPath[] throws IOException { if [isInvalid[]] { throw new IOException["Invalid file path"]; } return fs.canonicalize[fs.resolve[this]]; } /** * Returns the canonical form of this abstract pathname. Equivalent to *new File[this.{@link #getCanonicalPath}]
. * * @return The canonical pathname string denoting the same file or * directory as this abstract pathname * * @throws IOException * If an I/O error occurs, which is possible because the * 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{@link
* java.lang.SecurityManager#checkRead} method denies * read access to the file * * @since 1.2 * @see Path#toRealPath */ public File getCanonicalFile[] throws IOException { String canonPath = getCanonicalPath[]; return new File[canonPath, fs.prefixLength[canonPath]]; } private static String slashify[String path, boolean isDirectory] { String p = path; if [File.separatorChar != '/'] p = p.replace[File.separatorChar, '/']; if [!p.startsWith["/"]] p = "/" + p; if [!p.endsWith["/"] && isDirectory] p = p + "/"; return p; } /** * Converts this abstract pathname into afile:
URL. The * exact form of the URL is system-dependent. If it can be determined that * the file denoted by this abstract pathname is a directory, then the * resulting URL will end with a slash. * * @return A URL object representing the equivalent file URL * * @throws MalformedURLException * If the path cannot be parsed as a URL * * @see #toURI[] * @see java.net.URI * @see java.net.URI#toURL[] * @see java.net.URL * @since 1.2 * * @deprecated This method does not automatically escape characters that * are illegal in URLs. It is recommended that new code convert an * abstract pathname into a URL by first converting it into a URI, via the * {@link #toURI[] toURI} method, and then converting the URI into a URL * via the {@link java.net.URI#toURL[] URI.toURL} method. */ @Deprecated public URL toURL[] throws MalformedURLException { if [isInvalid[]] { throw new MalformedURLException["Invalid file path"]; } return new URL["file", "", slashify[getAbsolutePath[], isDirectory[]]]; } /** * Constructs a file: URI that represents this abstract pathname. * *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. * *For a given abstract pathname f, it is guaranteed that
* * * new {@link #File[java.net.URI] File}[ f.toURI[]].equals[ f.{@link #getAbsoluteFile[] getAbsoluteFile}[]] * * * 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 * 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. * *Note that when this abstract pathname represents a UNC pathname then
* all components of the UNC [including the server name component] are encoded * in the {@code URI} path. The authority component is undefined, meaning * that it is represented as {@code null}. The {@link Path} class defines the * {@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 * "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] * @see java.net.URI * @see java.net.URI#toURL[] * @since 1.4 */ public URI toURI[] { try { File f = getAbsoluteFile[]; String sp = slashify[f.getPath[], f.isDirectory[]]; if [sp.startsWith["//"]] sp = "//" + sp; return new URI["file", null, sp, null]; } catch [URISyntaxException x] { throw new Error[x]; // Can't happen } } /* -- Attribute accessors -- */ /** * Tests whether the application can read the file denoted by 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. Consequently this method may return * {@code true} even though the file does not have read permissions. * * @returntrue
if and only if the file specified by this * abstract pathname exists and can be read by the * application;false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file */ public boolean canRead[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return false; } return fs.checkAccess[this, FileSystem.ACCESS_READ]; } /** * Tests whether the application can modify the file denoted by 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 are marked read-only. Consequently this method may return * {@code true} even though the file is marked read-only. * * @returntrue
if and only if the file system actually * contains a file denoted by this abstract pathname and * the application is allowed to write to the file; *false
otherwise. * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkWrite[java.lang.String]} * method denies write access to the file */ public boolean canWrite[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkWrite[path]; } if [isInvalid[]] { return false; } return fs.checkAccess[this, FileSystem.ACCESS_WRITE]; } /** * Tests whether the file or directory denoted by this abstract pathname * exists. * * @returntrue
if and only if the file or directory denoted * by this abstract pathname exists;false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* 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] { security.checkRead[path]; } if [isInvalid[]] { return false; } return [[fs.getBooleanAttributes[this] & FileSystem.BA_EXISTS] != 0]; } /** * Tests whether the file denoted by this abstract pathname is a * directory. * *Where it is required to distinguish an I/O exception from the case
* that the file is not a directory, or where several attributes of the * same file are required at the same time, then the {@link * java.nio.file.Files#readAttributes[Path,Class,LinkOption[]] * Files.readAttributes} method may be used. * * @returntrue
if and only if the file denoted by this * abstract pathname exists and is a directory; *false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file */ public boolean isDirectory[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return false; } return [[fs.getBooleanAttributes[this] & FileSystem.BA_DIRECTORY] != 0]; } /** * Tests whether the file denoted by this abstract pathname is a normal * file. A file is normal if it is not a directory and, in * addition, satisfies other system-dependent criteria. Any non-directory * file created by a Java application is guaranteed to be a normal file. * *Where it is required to distinguish an I/O exception from the case
* that the file is not a normal file, or where several attributes of the * same file are required at the same time, then the {@link * java.nio.file.Files#readAttributes[Path,Class,LinkOption[]] * Files.readAttributes} method may be used. * * @returntrue
if and only if the file denoted by this * abstract pathname exists and is a normal file; *false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file */ public boolean isFile[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return false; } return [[fs.getBooleanAttributes[this] & FileSystem.BA_REGULAR] != 0]; } /** * Tests whether the file named by this abstract pathname is a hidden * file. The exact definition of hidden is system-dependent. On * UNIX systems, a file is considered to be hidden if its name begins with * a period character ['.'
]. On Microsoft Windows systems, a file is * considered to be hidden if it has been marked as such in the filesystem. * * @returntrue
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{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file * * @since 1.2 */ public boolean isHidden[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return false; } return [[fs.getBooleanAttributes[this] & FileSystem.BA_HIDDEN] != 0]; } /** * Returns the time that the file denoted by this abstract pathname was * last modified. * *Where it is required to distinguish an I/O exception from the case
* where {@code 0L} is returned, or where several attributes of the * same file are required at the same time, or where the time of last * access or the creation time are required, then the {@link * java.nio.file.Files#readAttributes[Path,Class,LinkOption[]] * Files.readAttributes} method may be used. * * @return Along
value representing the time the file was * last modified, measured in milliseconds since the epoch * [00:00:00 GMT, January 1, 1970], or0L
if the * file does not exist or if an I/O error occurs * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file */ public long lastModified[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return 0L; } return fs.getLastModifiedTime[this]; } /** * Returns the length of the file denoted by this abstract pathname. * The return value is unspecified if this pathname denotes a directory. * *Where it is required to distinguish an I/O exception from the case
* that {@code 0L} is returned, or where several attributes of the same file * are required at the same time, then the {@link * java.nio.file.Files#readAttributes[Path,Class,LinkOption[]] * Files.readAttributes} method may be used. * * @return The length, in bytes, of the file denoted by this abstract * pathname, or0L
if the file does not exist. Some * operating systems may return0L
for pathnames * denoting system-dependent entities such as devices or pipes. * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkRead[java.lang.String]} * method denies read access to the file */ public long length[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return 0L; } return fs.getLength[this]; } /* -- File operations -- */ /** * Atomically creates a new, empty file named by this abstract pathname if * and only if a file with this name does not yet exist. The check for the * existence of the file and the creation of the file if it does not exist * are a single operation that is atomic with respect to all other * filesystem activities that might affect the file. * * Note: this method should not be used for file-locking, as * the resulting protocol cannot be made to work reliably. The * {@link java.nio.channels.FileLock FileLock} * facility should be used instead. * * @returntrue
if the named file does not exist and was * successfully created;false
if the named file * already exists * * @throws IOException * If an I/O error occurred * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkWrite[java.lang.String]} * method denies write access to the file * * @since 1.2 */ public boolean createNewFile[] throws IOException { SecurityManager security = System.getSecurityManager[]; if [security != null] security.checkWrite[path]; if [isInvalid[]] { throw new IOException["Invalid file path"]; } return fs.createFileExclusively[path]; } /** * Deletes the file or directory denoted by this abstract pathname. If * this pathname denotes a directory, then the directory must be empty in * order to be deleted. * *Note that the {@link java.nio.file.Files} class defines the {@link
* java.nio.file.Files#delete[Path] delete} method to throw an {@link IOException} * when a file cannot be deleted. This is useful for error reporting and to * diagnose why a file cannot be deleted. * * @returntrue
if and only if the file or directory is * successfully deleted;false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkDelete} method denies * delete access to the file */ public boolean delete[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkDelete[path]; } if [isInvalid[]] { return false; } return fs.delete[this]; } /** * Requests that the file or directory denoted by this abstract * pathname be deleted when the virtual machine terminates. * Files [or directories] are deleted in the reverse order that * they are registered. Invoking this method to delete a file or * directory that is already registered for deletion has no effect. * Deletion will be attempted only for normal termination of the * virtual machine, as defined by the Java Language Specification. * *Once deletion has been requested, it is not possible to cancel the
* request. This method should therefore be used with care. * * * Note: this method should not be used for file-locking, as * 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{@link
* java.lang.SecurityManager#checkDelete} method denies * delete access to the file * * @see #delete * * @since 1.2 */ public void deleteOnExit[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkDelete[path]; } if [isInvalid[]] { return; } DeleteOnExitHook.add[path]; } /** * Returns an array of strings naming the files and directories in the * directory denoted by this abstract pathname. * *If this abstract pathname does not denote a directory, then this
* method returns {@code null}. Otherwise an array of strings is * returned, one for each file or directory in the directory. Names * denoting the directory itself and the directory's parent directory are * not included in the result. Each string is a file name rather than a * complete path. * *There is no guarantee that the name strings in the resulting array
* will appear in any specific order; they are not, in particular, * guaranteed to appear in alphabetical order. * *Note that the {@link java.nio.file.Files} class defines the {@link
* java.nio.file.Files#newDirectoryStream[Path] newDirectoryStream} method to * open a directory and iterate over the names of the files in the directory. * This may use less resources when working with very large directories, and * may be more responsive when working with remote directories. * * @return An array of strings naming the files and directories in the * directory denoted by this abstract pathname. The array will be * empty if the directory is empty. Returns {@code null} if * this abstract pathname does not denote a directory, or if an * I/O error occurs. * * @throws SecurityException * If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to * the directory */ public String[] list[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkRead[path]; } if [isInvalid[]] { return null; } return fs.list[this]; } /** * Returns an array of strings naming the files and directories in the * directory denoted by this abstract pathname that satisfy the specified * filter. The behavior of this method is the same as that of the * {@link #list[]} method, except that the strings in the returned array * must satisfy the filter. If the given {@code filter} is {@code null} * then all names are accepted. Otherwise, a name satisfies the filter if * and only if the value {@code true} results when the {@link * FilenameFilter#accept FilenameFilter.accept[File, String]} method * of the filter is invoked on this abstract pathname and the name of a * file or directory in the directory that it denotes. * * @param filter * A filename filter * * @return An array of strings naming the files and directories in the * directory denoted by this abstract pathname that were accepted * by the given {@code filter}. The array will be empty if the * directory is empty or if no names were accepted by the filter. * Returns {@code null} if this abstract pathname does not denote * a directory, or if an I/O error occurs. * * @throws SecurityException * If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to * the directory * * @see java.nio.file.Files#newDirectoryStream[Path,String] */ public String[] list[FilenameFilter filter] { String names[] = list[]; if [[names == null] || [filter == null]] { return names; } List v = new ArrayList[]; for [int i = 0 ; i < names.length ; i++] { if [filter.accept[this, names[i]]] { v.add[names[i]]; } } return v.toArray[new String[v.size[]]]; } /** * Returns an array of abstract pathnames denoting the files in the * directory denoted by this abstract pathname. * *If this abstract pathname does not denote a directory, then this
* method returns {@code null}. Otherwise an array of {@code File} objects * is returned, one for each file or directory in the directory. Pathnames * denoting the directory itself and the directory's parent directory are * not included in the result. Each resulting abstract pathname is * constructed from this abstract pathname using the {@link #File[File, * String] File[File, String]} constructor. Therefore if this * pathname is absolute then each resulting pathname is absolute; if this * pathname is relative then each resulting pathname will be relative to * the same directory. * *There is no guarantee that the name strings in the resulting array
* will appear in any specific order; they are not, in particular, * guaranteed to appear in alphabetical order. * *Note that the {@link java.nio.file.Files} class defines the {@link
* java.nio.file.Files#newDirectoryStream[Path] newDirectoryStream} method * to open a directory and iterate over the names of the files in the * directory. This may use less resources when working with very large * directories. * * @return An array of abstract pathnames denoting the files and * directories in the directory denoted by this abstract pathname. * The array will be empty if the directory is empty. Returns * {@code null} if this abstract pathname does not denote a * directory, or if an I/O error occurs. * * @throws SecurityException * If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to * the directory * * @since 1.2 */ public File[] listFiles[] { String[] ss = list[]; if [ss == null] return null; int n = ss.length; File[] fs = new File[n]; for [int i = 0; i < n; i++] { fs[i] = new File[ss[i], this]; } return fs; } /** * Returns an array of abstract pathnames denoting the files and * directories in the directory denoted by this abstract pathname that * satisfy the specified filter. The behavior of this method is the same * as that of the {@link #listFiles[]} method, except that the pathnames in * the returned array must satisfy the filter. If the given {@code filter} * is {@code null} then all pathnames are accepted. Otherwise, a pathname * satisfies the filter if and only if the value {@code true} results when * the {@link FilenameFilter#accept * FilenameFilter.accept[File, String]} method of the filter is * invoked on this abstract pathname and the name of a file or directory in * the directory that it denotes. * * @param filter * A filename filter * * @return An array of abstract pathnames denoting the files and * directories in the directory denoted by this abstract pathname. * The array will be empty if the directory is empty. Returns * {@code null} if this abstract pathname does not denote a * directory, or if an I/O error occurs. * * @throws SecurityException * If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to * the directory * * @since 1.2 * @see java.nio.file.Files#newDirectoryStream[Path,String] */ public File[] listFiles[FilenameFilter filter] { String ss[] = list[]; if [ss == null] return null; ArrayList files = new ArrayList[]; for [String s : ss] if [[filter == null] || filter.accept[this, s]] files.add[new File[s, this]]; return files.toArray[new File[files.size[]]]; } /** * Returns an array of abstract pathnames denoting the files and * directories in the directory denoted by this abstract pathname that * satisfy the specified filter. The behavior of this method is the same * as that of the {@link #listFiles[]} method, except that the pathnames in * the returned array must satisfy the filter. If the given {@code filter} * is {@code null} then all pathnames are accepted. Otherwise, a pathname * satisfies the filter if and only if the value {@code true} results when * the {@link FileFilter#accept FileFilter.accept[File]} method of the * filter is invoked on the pathname. * * @param filter * A file filter * * @return An array of abstract pathnames denoting the files and * directories in the directory denoted by this abstract pathname. * The array will be empty if the directory is empty. Returns * {@code null} if this abstract pathname does not denote a * directory, or if an I/O error occurs. * * @throws SecurityException * If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to * the directory * * @since 1.2 * @see java.nio.file.Files#newDirectoryStream[Path,java.nio.file.DirectoryStream.Filter] */ public File[] listFiles[FileFilter filter] { String ss[] = list[]; if [ss == null] return null; ArrayList files = new ArrayList[]; for [String s : ss] { File f = new File[s, this]; if [[filter == null] || filter.accept[f]] files.add[f]; } return files.toArray[new File[files.size[]]]; } /** * Creates the directory named by this abstract pathname. * * @returntrue
if and only if the directory was * created;false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* 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] { security.checkWrite[path]; } if [isInvalid[]] { return false; } return fs.createDirectory[this]; } /** * Creates the directory named by this abstract pathname, including any * necessary but nonexistent parent directories. Note that if this * operation fails it may have succeeded in creating some of the necessary * parent directories. * * @returntrue
if and only if the directory was created, * along with all necessary parent directories;false
* otherwise * * @throws SecurityException * If a security manager exists and its{@link
* 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{@link
* 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 false; } if [mkdir[]] { return true; } File canonFile = null; try { canonFile = getCanonicalFile[]; } catch [IOException e] { return false; } File parent = canonFile.getParentFile[]; return [parent != null && [parent.mkdirs[] || parent.exists[]] && canonFile.mkdir[]]; } /** * Renames the file denoted by this abstract pathname. * *Many aspects of the behavior of this method are inherently
* platform-dependent: The rename operation might not be able to move a * file from one filesystem to another, it might not be atomic, and it * might not succeed if a file with the destination abstract pathname * already exists. The return value should always be checked to make sure * that the rename operation was successful. * *Note that the {@link java.nio.file.Files} class defines the {@link
* java.nio.file.Files#move move} method to move or rename a file in a * platform independent manner. * * @param dest The new abstract pathname for the named file * * @returntrue
if and only if the renaming succeeded; *false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkWrite[java.lang.String]} * method denies write access to either the old or new pathnames * * @throws NullPointerException * If parameterdest
isnull
*/ public boolean renameTo[File dest] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkWrite[path]; security.checkWrite[dest.path]; } if [dest == null] { throw new NullPointerException[]; } if [this.isInvalid[] || dest.isInvalid[]] { return false; } return fs.rename[this, dest]; } /** * Sets the last-modified time of the file or directory named by this * abstract pathname. * *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 *{@link #lastModified}
method will return the [possibly * truncated]time
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] * * @returntrue
if and only if the operation succeeded; *false
otherwise * * @throws IllegalArgumentException If the argument is negative * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkWrite[java.lang.String]} * method denies write access to the named file * * @since 1.2 */ public boolean setLastModified[long time] { if [time < 0] throw new IllegalArgumentException["Negative time"]; SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkWrite[path]; } if [isInvalid[]] { return false; } return fs.setLastModifiedTime[this, time]; } /** * Marks the file or directory named by this abstract pathname so that * only read operations are allowed. After invoking this method the file * or directory will not change until it is either deleted or marked * to allow write access. On some platforms it may be possible to start the * Java virtual machine with special privileges that allow it to modify * files that are marked read-only. Whether or not a read-only file or * directory may be deleted depends upon the underlying system. * * @returntrue
if and only if the operation succeeded; *false
otherwise * * @throws SecurityException * If a security manager exists and its{@link
* java.lang.SecurityManager#checkWrite[java.lang.String]} * method denies write access to the named file * * @since 1.2 */ public boolean setReadOnly[] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkWrite[path]; } if [isInvalid[]] { return false; } return fs.setReadOnly[this]; } /** * Sets the owner's or everybody'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. * *The {@link java.nio.file.Files} class defines methods that operate on
* file attributes including file permissions. This may be used when finer * manipulation of file permissions is required. * * @param writable * Iftrue
, sets the access permission to allow write * operations; iffalse
to disallow write operations * * @param ownerOnly * Iftrue
, the write permission applies only to the * owner's write permission; otherwise, it applies to everybody. If * the underlying file system can not distinguish the owner's write * permission from that of others, then the permission will apply to * everybody, regardless of this value. * * @returntrue
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{@link
* 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] { SecurityManager security = System.getSecurityManager[]; if [security != null] { security.checkWrite[path]; } if [isInvalid[]] { return false; } return fs.setPermission[this, FileSystem.ACCESS_WRITE, writable, 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. * *An invocation of this method of the form file.setWritable[arg]
* behaves in exactly the same way as the invocation * * * file.setWritable[arg, true]
true
, sets the access permission to allow write
* operations; if false
to disallow write operations
*
* @return true
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 {@link
* java.lang.SecurityManager#checkWrite[java.lang.String]}
* method denies write access to the file
*
* @since 1.6
*/
public boolean setWritable[boolean writable] {
return setWritable[writable, true];
}
/**
* Sets the owner's or everybody'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.
*
* The {@link java.nio.file.Files} class defines methods that operate on
* file attributes including file permissions. This may be used when finer * manipulation of file permissions is required. * * @param readable * Iftrue
, sets the access permission to allow read
* operations; if false
to disallow read operations
*
* @param ownerOnly
* If true
, the read permission applies only to the
* owner's read permission; otherwise, it applies to everybody. If
* the underlying file system can not distinguish the owner's read
* permission from that of others, then the permission will apply to
* everybody, regardless of this value.
*
* @return true
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. If
* readable
is false
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 {@link
* java.lang.SecurityManager#checkWrite[java.lang.String]}
* method denies write access to the file
*
* @since 1.6
*/
public boolean setReadable[boolean readable, boolean ownerOnly] {
SecurityManager security = System.getSecurityManager[];
if [security != null] {
security.checkWrite[path];
}
if [isInvalid[]] {
return false;
}
return fs.setPermission[this, FileSystem.ACCESS_READ, readable, 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 that are
* marked as unreadable.
*
* An invocation of this method of the form file.setReadable[arg]
* behaves in exactly the same way as the invocation * * * file.setReadable[arg, true] * * @param readable * Iftrue
, sets the access permission to allow read
* operations; if false
to disallow read operations
*
* @return true
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. If
* readable
is false
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 {@link
* java.lang.SecurityManager#checkWrite[java.lang.String]}
* method denies write access to the file
*
* @since 1.6
*/
public boolean setReadable[boolean readable] {
return setReadable[readable, true];
}
/**
* Sets the owner's or everybody'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.
*
* The {@link java.nio.file.Files} class defines methods that operate on
* file attributes including file permissions. This may be used when finer * manipulation of file permissions is required. * * @param executable * Iftrue
, sets the access permission to allow execute
* operations; if false
to disallow execute operations
*
* @param ownerOnly
* If true
, the execute permission applies only to the
* owner's execute permission; otherwise, it applies to everybody.
* If the underlying file system can not distinguish the owner's
* execute permission from that of others, then the permission will
* apply to everybody, regardless of this value.
*
* @return true
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. If
* executable
is false
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 {@link
* java.lang.SecurityManager#checkWrite[java.lang.String]}
* method denies write access to the file
*
* @since 1.6
*/
public boolean setExecutable[boolean executable, boolean ownerOnly] {
SecurityManager security = System.getSecurityManager[];
if [security != null] {
security.checkWrite[path];
}
if [isInvalid[]] {
return false;
}
return fs.setPermission[this, FileSystem.ACCESS_EXECUTE, executable, 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.
*
* An invocation of this method of the form file.setExcutable[arg]
* behaves in exactly the same way as the invocation * * * file.setExecutable[arg, true] * * @param executable * Iftrue
, sets the access permission to allow execute
* operations; if false
to disallow execute operations
*
* @return true
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. If
* executable
is false
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 {@link
* java.lang.SecurityManager#checkWrite[java.lang.String]}
* method denies write access to the file
*
* @since 1.6
*/
public boolean setExecutable[boolean executable] {
return setExecutable[executable, true];
}
/**
* Tests whether the application can execute the file denoted by 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. Consequently this method may return
* {@code true} even though the file does not have execute permissions.
*
* @return true
if and only if the abstract pathname exists
* and the application is allowed to execute the file
*
* @throws SecurityException
* If a security manager exists and its {@link
* java.lang.SecurityManager#checkExec[java.lang.String]}
* method denies execute access to the file
*
* @since 1.6
*/
public boolean canExecute[] {
SecurityManager security = System.getSecurityManager[];
if [security != null] {
security.checkExec[path];
}
if [isInvalid[]] {
return false;
}
return fs.checkAccess[this, FileSystem.ACCESS_EXECUTE];
}
/* -- Filesystem interface -- */
/**
* List the available filesystem roots.
*
* A particular Java platform may support zero or more
* hierarchically-organized file systems. Each file system has a * {@code root} directory from which all other files in that file system * can be reached. Windows platforms, for example, have a root directory * for each active drive; UNIX platforms have a single root directory, * namely {@code "/"}. The set of available filesystem roots is affected * by various system-level operations such as the insertion or ejection of * removable media and the disconnecting or unmounting of physical or * virtual disk drives. * *This method returns an array of {@code File} objects that denote the
* root directories of the available filesystem roots. It is guaranteed * that the canonical pathname of any file physically present on the local * machine will begin with one of the roots returned by this method. * *The canonical pathname of a file that resides on some other machine
* and is accessed via a remote-filesystem protocol such as SMB or NFS may * or may not begin with one of the roots returned by this method. If the * pathname of a remote file is syntactically indistinguishable from the * pathname of a local file then it will begin with one of the roots * returned by this method. Thus, for example, {@code File} objects * denoting the root directories of the mapped network drives of a Windows * platform will be returned by this method, while {@code File} objects * containing UNC pathnames will not be returned by this method. * *Unlike most methods in this class, this method does not throw
* security exceptions. If a security manager exists and its {@link * SecurityManager#checkRead[String]} method denies read access to a * particular root directory, then that directory will not appear in the * result. * * @return An array of {@code File} objects denoting the available * filesystem roots, or {@code null} if the set of roots could not * be determined. The array will be empty if there are no * filesystem roots. * * @since 1.2 * @see java.nio.file.FileStore */ public static File[] listRoots[] { return fs.listRoots[]; } /* -- Disk usage -- */ /** * Returns the size of the partition named by this * abstract pathname. * * @return The size, in bytes, of the partition or 0L if this * abstract pathname does not name a partition * * @throws SecurityException * If a security manager has been installed and it denies * {@link RuntimePermission}["getFileSystemAttributes"] * or its {@link SecurityManager#checkRead[String]} method denies * read access to the file named by this abstract pathname * * @since 1.6 */ public long getTotalSpace[] { SecurityManager sm = System.getSecurityManager[]; if [sm != null] { sm.checkPermission[new RuntimePermission["getFileSystemAttributes"]]; sm.checkRead[path]; } if [isInvalid[]] { return 0L; } return fs.getSpace[this, FileSystem.SPACE_TOTAL]; } /** * Returns the number of unallocated bytes in the partition named by this abstract path name. * *The returned number of unallocated bytes is a hint, but not
* a guarantee, that it is possible to use most or any of these * bytes. The number of unallocated bytes is most likely to be * accurate immediately 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 unallocated bytes on the partition or 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}["getFileSystemAttributes"] * or its {@link SecurityManager#checkRead[String]} method denies * read access to the file named by this abstract pathname * * @since 1.6 */ public long getFreeSpace[] { SecurityManager sm = System.getSecurityManager[]; if [sm != null] { sm.checkPermission[new RuntimePermission["getFileSystemAttributes"]]; sm.checkRead[path]; } if [isInvalid[]] { return 0L; } return fs.getSpace[this, FileSystem.SPACE_FREE]; } /** * Returns the number of bytes available to this virtual machine on the * partition named by this abstract pathname. When * possible, this method checks for write permissions and other operating * system restrictions and will therefore usually provide a more accurate * estimate of how much new data can actually be written than {@link * #getFreeSpace}. * *The returned number of available bytes is a hint, but not a
* guarantee, that it is possible to use most or any of these bytes. The * number of unallocated bytes is most likely to be accurate immediately * 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 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}["getFileSystemAttributes"] * or its {@link SecurityManager#checkRead[String]} method denies * read access to the file named by this abstract pathname * * @since 1.6 */ public long getUsableSpace[] { SecurityManager sm = System.getSecurityManager[]; if [sm != null] { sm.checkPermission[new RuntimePermission["getFileSystemAttributes"]]; sm.checkRead[path]; } if [isInvalid[]] { return 0L; } return fs.getSpace[this, FileSystem.SPACE_USABLE]; } /* -- Temporary files -- */ private static class TempDirectory { private TempDirectory[] { } // temporary directory location private static final File tmpdir = new File[AccessController .doPrivileged[new GetPropertyAction["java.io.tmpdir"]]]; static File location[] { return tmpdir; } // file name generation private static final SecureRandom random = new SecureRandom[]; static File generateFile[String prefix, String suffix, File dir] throws IOException { long n = random.nextLong[]; if [n == Long.MIN_VALUE] { n = 0; // corner case } else { n = Math.abs[n]; } // Use only the file name from the supplied prefix prefix = [new File[prefix]].getName[]; String name = prefix + Long.toString[n] + suffix; File f = new File[dir, name]; if [!name.equals[f.getName[]] || f.isInvalid[]] { if [System.getSecurityManager[] != null] throw new IOException["Unable to create temporary file"]; else throw new IOException["Unable to create temporary file, " + f]; } return f; } } /** *Creates a new empty file in the specified directory, using the
* given prefix and suffix strings to generate its name. If this method * returns successfully then it is guaranteed that: * *{@link #deleteOnExit}
method.
*
* The prefix
argument must be at least three characters
"hjb"
or "mail"
. The
* suffix
argument may be null
, in which case the
* suffix ".tmp"
will be used.
*
* To create the new file, the prefix and the suffix may first be
* adjusted to fit the limitations of the underlying platform. If the * prefix is too long then it will be truncated, but its first three * characters will always be preserved. If the suffix is too long then it * too will be truncated, but if it begins with a period character * ['.'
] then the period and the first three characters
* following it will always be preserved. Once these adjustments have been
* made the name of the new file will be generated by concatenating the
* prefix, five or more internally-generated characters, and the suffix.
*
* If the directory
argument is null
then the
java.io.tmpdir
. On UNIX systems the default value of this
* property is typically "/tmp"
or "/var/tmp"
; on
* Microsoft Windows systems it is typically "C:\\WINNT\\TEMP"
. A different
* value may be given to this system property when the Java virtual machine
* is invoked, but programmatic changes to this property are not guaranteed
* to have any effect upon the temporary directory used by this method.
*
* @param prefix The prefix string to be used in generating the file's
* name; must be at least three characters long
*
* @param suffix The suffix string to be used in generating the file's
* name; may be null
, in which case the
* suffix ".tmp"
will be used
*
* @param directory The directory in which the file is to be created, or
* null
if the default temporary-file
* directory is to be used
*
* @return An abstract pathname denoting a newly-created empty file
*
* @throws IllegalArgumentException
* If the prefix
argument contains fewer than three
* characters
*
* @throws IOException If a file could not be created
*
* @throws SecurityException
* If a security manager exists and its {@link
* 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,
File directory]
throws IOException
{
if [prefix.length[] < 3]
throw new IllegalArgumentException["Prefix string too short"];
if [suffix == null]
suffix = ".tmp";
File tmpdir = [directory != null] ? directory
: TempDirectory.location[];
SecurityManager sm = System.getSecurityManager[];
File f;
do {
f = TempDirectory.generateFile[prefix, suffix, tmpdir];
if [sm != null] {
try {
sm.checkWrite[f.getPath[]];
} catch [SecurityException se] {
// don't reveal temporary directory location
if [directory == null]
throw new SecurityException["Unable to create temporary file"];
throw se;
}
}
} while [[fs.getBooleanAttributes[f] & FileSystem.BA_EXISTS] != 0];
if [!fs.createFileExclusively[f.getPath[]]]
throw new IOException["Unable to create temporary file"];
return f;
}
/**
* 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 {@link #createTempFile[java.lang.String,
* java.lang.String, java.io.File]
* createTempFile[prefix, suffix, null]}.
*
* 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 * may have more restrictive access permissions to files created by this * method and so may be more suited to security-sensitive applications. * * @param prefix The prefix string to be used in generating the file's * name; must be at least three characters long * * @param suffix The suffix string to be used in generating the file's * name; may benull
, in which case the
* suffix ".tmp"
will be used
*
* @return An abstract pathname denoting a newly-created empty file
*
* @throws IllegalArgumentException
* If the prefix
argument contains fewer than three
* characters
*
* @throws IOException If a file could not be created
*
* @throws SecurityException
* If a security manager exists and its {@link
* 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[]]
*/
public static File createTempFile[String prefix, String suffix]
throws IOException
{
return createTempFile[prefix, suffix, null];
}
/* -- Basic infrastructure -- */
/**
* Compares two abstract pathnames lexicographically. The ordering
* defined by this method depends upon the underlying system. On UNIX
* systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
* systems it is not.
*
* @param pathname The abstract pathname to be compared to this abstract
* pathname
*
* @return Zero if the argument is equal to this abstract pathname, a
* value less than zero if this abstract pathname is
* lexicographically less than the argument, or a value greater
* than zero if this abstract pathname is lexicographically
* greater than the argument
*
* @since 1.2
*/
public int compareTo[File pathname] {
return fs.compare[this, pathname];
}
/**
* Tests this abstract pathname for equality with the given object.
* Returns true
if and only if the argument is not
* null
and is an abstract pathname that denotes the same file
* or directory as this abstract pathname. Whether or not two abstract
* pathnames are equal depends upon the underlying system. On UNIX
* systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
* systems it is not.
*
* @param obj The object to be compared with this abstract pathname
*
* @return true
if and only if the objects are the same;
* false
otherwise
*/
public boolean equals[Object obj] {
if [[obj != null] && [obj instanceof File]] {
return compareTo[[File]obj] == 0;
}
return false;
}
/**
* Computes a hash code for this abstract pathname. Because equality of
* abstract pathnames is inherently system-dependent, so is the computation
* of their hash codes. On UNIX systems, the hash code of an abstract
* pathname is equal to the exclusive or of the hash code
* of its pathname string and the decimal value
* 1234321
. On Microsoft Windows systems, the hash
* code is equal to the exclusive or of the hash code of
* its pathname string converted to lower case and the decimal
* value 1234321
. Locale is not taken into account on
* lowercasing the pathname string.
*
* @return A hash code for this abstract pathname
*/
public int hashCode[] {
return fs.hashCode[this];
}
/**
* Returns the pathname string of this abstract pathname. This is just the
* string returned by the {@link #getPath}
method.
*
* @return The string form of this abstract pathname
*/
public String toString[] {
return getPath[];
}
/**
* WriteObject is called to save this filename.
* The separator character is saved also so it can be replaced
* in case the path is reconstituted on a different host type.
*
* @serialData Default fields followed by separator character.
*/
private synchronized void writeObject[java.io.ObjectOutputStream s]
throws IOException
{
s.defaultWriteObject[];
s.writeChar[separatorChar]; // Add the separator character
}
/**
* readObject is called to restore this filename.
* The original separator character is read. If it is different
* than the separator character on this system, then the old separator
* is replaced by the local separator.
*/
private synchronized void readObject[java.io.ObjectInputStream s]
throws IOException, ClassNotFoundException
{
ObjectInputStream.GetField fields = s.readFields[];
String pathField = [String]fields.get["path", null];
char sep = s.readChar[]; // read the previous separator char
if [sep != separatorChar]
pathField = pathField.replace[sep, separatorChar];
String path = fs.normalize[pathField];
UNSAFE.putObject[this, PATH_OFFSET, path];
UNSAFE.putIntVolatile[this, PREFIX_LENGTH_OFFSET, fs.prefixLength[path]];
}
private static final long PATH_OFFSET;
private static final long PREFIX_LENGTH_OFFSET;
private static final sun.misc.Unsafe UNSAFE;
static {
try {
sun.misc.Unsafe unsafe = sun.misc.Unsafe.getUnsafe[];
PATH_OFFSET = unsafe.objectFieldOffset[
File.class.getDeclaredField["path"]];
PREFIX_LENGTH_OFFSET = unsafe.objectFieldOffset[
File.class.getDeclaredField["prefixLength"]];
UNSAFE = unsafe;
} catch [ReflectiveOperationException e] {
throw new Error[e];
}
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = 301077366599181567L;
// -- Integration with java.nio.file --
private volatile transient Path filePath;
/**
* Returns a {@link Path java.nio.file.Path} object constructed from the
* this abstract path. The resulting {@code Path} is associated with the
* {@link java.nio.file.FileSystems#getDefault default-filesystem}.
*
* The first invocation of this method works as if invoking it were
* equivalent to evaluating the expression: ** {@link java.nio.file.FileSystems#getDefault FileSystems.getDefault}[].{@link * java.nio.file.FileSystem#getPath getPath}[this.{@link #getPath getPath}[]]; * * Subsequent invocations of this method return the same {@code Path}. * *
If this abstract pathname is the empty abstract pathname then this
* method returns a {@code Path} that may be used to access the current * user directory. * * @return a {@code Path} constructed from this abstract path * * @throws java.nio.file.InvalidPathException * if a {@code Path} object cannot be constructed from the abstract * path [see {@link java.nio.file.FileSystem#getPath FileSystem.getPath}] * * @since 1.7 * @see Path#toFile */ public Path toPath[] { Path result = filePath; if [result == null] { synchronized [this] { result = filePath; if [result == null] { result = FileSystems.getDefault[].getPath[path]; filePath = result; } } } return result; } }