java.io.File Maven / Gradle / Ivy
/*
* Copyright (c) 1994, 2011, 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;
/**
* An abstract representation of file and directory pathnames.
*
* User 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 property file.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 named by some ancestor of the absolute
* form of this pathname.
*
*
A file system may implement restrictions to certain operations on the
* actual file-system object, such as reading, writing, and executing. These
* restrictions are collectively known as access permissions. The file
* system may have multiple sets of access permissions on a single object.
* For example, one set may apply to the object's owner, and another
* may apply to all other users. The access permissions on an object may
* cause some methods in this class to fail.
*
*
Instances of the File class are immutable; that is, once
* created, the abstract pathname represented by a File object
* will never change.
*
*
Interoperability with {@code java.nio.file} package
*
* The {@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.
*/
static private FileSystem fs = new FileSystem();
private static class FileSystem {
private char getSeparator() {
return '/';
}
private String resolve(String path, String child) {
return path + '/' + child;
}
private String normalize(String pathname) {
return pathname;
}
private int prefixLength(String path) {
return 0;
}
private String getDefaultParent() {
return "/";
}
private String fromURIPath(String p) {
return p;
}
private boolean isAbsolute(File aThis) {
return aThis.getPath().startsWith("/");
}
private int compare(File one, File two) {
return one.getPath().compareTo(two.getPath());
}
private int hashCode(File aThis) {
return aThis.getPath().hashCode();
}
private char getPathSeparator() {
return ':';
}
}
/**
* 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 String path;
/**
* The length of this abstract pathname's prefix, or zero if it has no
* prefix.
*/
private 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
* property file.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
* property path.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 new File 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 the pathname argument is null
*/
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 new File instance from a parent pathname string
* and a child pathname string.
*
* If parent is null then the new
* File instance is created as if by invoking the
* single-argument File constructor on the given
* child pathname string.
*
*
Otherwise the parent pathname string is taken to denote
* a directory, and the child pathname string is taken to
* denote either a directory or a file. If the child pathname
* string is absolute then it is converted into a relative pathname in a
* system-dependent way. If parent is the empty string then
* the new File 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
* If child is null
*/
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 new File instance from a parent abstract
* pathname and a child pathname string.
*
*
If parent is null then the new
* File instance is created as if by invoking the
* single-argument File constructor on the given
* child pathname string.
*
*
Otherwise the parent abstract pathname is taken to
* denote a directory, and the child pathname string is taken
* to denote either a directory or a file. If the child
* pathname string is absolute then it is converted into a relative
* pathname in a system-dependent way. If parent is the empty
* abstract pathname then the new File 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 abstract pathname
* @param child The child pathname string
* @throws NullPointerException
* If child is null
*/
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, or null 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,
* 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 abstract pathname of the parent directory named by this
* abstract pathname, or null 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 "\\\\".
*
* @return true 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 property user.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() {
throw new SecurityException();
}
/**
* 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 {
throw new SecurityException();
}
/**
* 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 a file: 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 {
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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* Tests whether the application can modify the file denoted by this
* abstract pathname.
*
* @return true 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() {
throw new SecurityException();
}
/**
* Tests whether the file or directory denoted by this abstract pathname
* exists.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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 A long value representing the time the file was
* last modified, measured in milliseconds since the epoch
* (00:00:00 GMT, January 1, 1970), or 0L 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() {
throw new SecurityException();
}
/**
* 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, or 0L if the file does not exist. Some
* operating systems may return 0L 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() {
throw new SecurityException();
}
/* -- 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.
*
* @return true 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 {
throw new SecurityException();
}
/**
* 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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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() {
throw new SecurityException();
}
/**
* 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() {
throw new SecurityException();
}
/**
* 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) {
throw new SecurityException();
}
/**
* 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() {
throw new SecurityException();
}
/**
* 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) {
throw new SecurityException();
}
/**
* 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) {
throw new SecurityException();
}
/**
* Creates the directory named by this abstract pathname.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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.
*
* @return true 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() {
throw new SecurityException();
}
/**
* 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
*
* @return true 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 parameter dest is null
*/
public boolean renameTo(File dest) {
throw new SecurityException();
}
/**
* 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)
*
* @return true 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) {
throw new SecurityException();
}
/**
* 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 is guaranteed not to change until it is either deleted or
* marked to allow write access. Whether or not a read-only file or
* directory may be deleted depends upon the underlying system.
*
* @return true 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() {
throw new SecurityException();
}
/**
* Sets the owner's or everybody's write permission for this abstract
* pathname.
*
*
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
* If true, sets the access permission to allow write
* operations; if false to disallow write operations
*
* @param ownerOnly
* If true, 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.
*
* @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 named file
*
* @since 1.6
*/
public boolean setWritable(boolean writable, boolean ownerOnly) {
throw new SecurityException();
}
/**
* A convenience method to set the owner's write permission for this abstract
* pathname.
*
*
An invocation of this method of the form file.setWritable(arg)
* behaves in exactly the same way as the invocation
*
*
* file.setWritable(arg, true)
*
* @param writable
* If 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.
*
* 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
* If true, 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) {
throw new SecurityException();
}
/**
* A convenience method to set the owner's read permission for this abstract
* pathname.
*
*
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
* If true, 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.
*
* 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
* If true, 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) {
throw new SecurityException();
}
/**
* A convenience method to set the owner's execute permission for this abstract
* pathname.
*
*
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
* If true, 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 excute 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.
*
* @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() {
throw new SecurityException();
}
/* -- 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() {
throw new SecurityException();
}
/* -- 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() {
throw new SecurityException();
}
/**
* 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 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() {
throw new SecurityException();
}
/**
* 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() {
throw new SecurityException();
}
/* -- Temporary files -- */
/**
*
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:
*
*
* - The file denoted by the returned abstract pathname did not exist
* before this method was invoked, and
*
- Neither this method nor any of its variants will return the same
* abstract pathname again in the current invocation of the virtual
* machine.
*
*
* 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
* {@link #deleteOnExit} method.
*
* The prefix argument must be at least three characters
* long. It is recommended that the prefix be a short, meaningful string
* such as "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
* system-dependent default temporary-file directory will be used. The
* default temporary-file directory is specified by the system property
* 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
{
throw new SecurityException();
}
/**
* 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 be null, 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(this.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);
this.path = fs.normalize(pathField);
this.prefixLength = fs.prefixLength(this.path);
}
/** 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;
// }
}