Files

public final class Files extends Object

This class consists exclusively of static methods that operate on files, directories, or other types of files.

In most cases, the methods defined here will delegate to the associated file system provider to perform the file operations.

Public Method Summary

static Path	copy(Path source, Path target, CopyOption... options) Copy a file to a target file.
static long	copy(Path source, OutputStream out) Copies all bytes from a file to an output stream.
static long	copy(InputStream in, Path target, CopyOption... options) Copies all bytes from an input stream to a file.
static Path	createDirectories(Path dir, FileAttribute...<?> attrs) Creates a directory by creating all nonexistent parent directories first.
static Path	createDirectory(Path dir, FileAttribute...<?> attrs) Creates a new directory.
static Path	createFile(Path path, FileAttribute...<?> attrs) Creates a new and empty file, failing if the file already exists.
static Path	createLink(Path link, Path existing) Creates a new link (directory entry) for an existing file (optional operation).
static Path	createSymbolicLink(Path link, Path target, FileAttribute...<?> attrs) Creates a symbolic link to a target (optional operation).
static Path	createTempDirectory(String prefix, FileAttribute...<?> attrs) Creates a new directory in the default temporary-file directory, using the given prefix to generate its name.
static Path	createTempDirectory(Path dir, String prefix, FileAttribute...<?> attrs) Creates a new directory in the specified directory, using the given prefix to generate its name.
static Path	createTempFile(Path dir, String prefix, String suffix, FileAttribute...<?> attrs) Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
static Path	createTempFile(String prefix, String suffix, FileAttribute...<?> attrs) Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name.
static void	delete(Path path) Deletes a file.
static boolean	deleteIfExists(Path path) Deletes a file if it exists.
static boolean	exists(Path path, LinkOption... options) Tests whether a file exists.
static Stream<Path>	find(Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher, FileVisitOption... options) Return a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.
static Object	getAttribute(Path path, String attribute, LinkOption... options) Reads the value of a file attribute.
static <V extends FileAttributeView> V	getFileAttributeView(Path path, Class<V> type, LinkOption... options) Returns a file attribute view of a given type.
static FileStore	getFileStore(Path path) Returns the FileStore representing the file store where a file is located.
static FileTime	getLastModifiedTime(Path path, LinkOption... options) Returns a file's last modified time.
static UserPrincipal	getOwner(Path path, LinkOption... options) Returns the owner of a file.
static Set<PosixFilePermission>	getPosixFilePermissions(Path path, LinkOption... options) Returns a file's POSIX file permissions.
static boolean	isDirectory(Path path, LinkOption... options) Tests whether a file is a directory.
static boolean	isExecutable(Path path) Tests whether a file is executable.
static boolean	isHidden(Path path) Tells whether or not a file is considered hidden.
static boolean	isReadable(Path path) Tests whether a file is readable.
static boolean	isRegularFile(Path path, LinkOption... options) Tests whether a file is a regular file with opaque content.
static boolean	isSameFile(Path path, Path path2) Tests if two paths locate the same file.
static boolean	isSymbolicLink(Path path) Tests whether a file is a symbolic link.
static boolean	isWritable(Path path) Tests whether a file is writable.
static Stream<String>	lines(Path path) Read all lines from a file as a Stream.
static Stream<String>	lines(Path path, Charset cs) Read all lines from a file as a Stream.
static Stream<Path>	list(Path dir) Return a lazily populated Stream, the elements of which are the entries in the directory.
static Path	move(Path source, Path target, CopyOption... options) Move or rename a file to a target file.
static BufferedReader	newBufferedReader(Path path, Charset cs) Opens a file for reading, returning a BufferedReader that may be used to read text from the file in an efficient manner.
static BufferedReader	newBufferedReader(Path path) Opens a file for reading, returning a BufferedReader to read text from the file in an efficient manner.
static BufferedWriter	newBufferedWriter(Path path, OpenOption... options) Opens or creates a file for writing, returning a BufferedWriter to write text to the file in an efficient manner.
static BufferedWriter	newBufferedWriter(Path path, Charset cs, OpenOption... options) Opens or creates a file for writing, returning a BufferedWriter that may be used to write text to the file in an efficient manner.
static SeekableByteChannel	newByteChannel(Path path, OpenOption... options) Opens or creates a file, returning a seekable byte channel to access the file.
static SeekableByteChannel	newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute...<?> attrs) Opens or creates a file, returning a seekable byte channel to access the file.
static DirectoryStream<Path>	newDirectoryStream(Path dir, String glob) Opens a directory, returning a DirectoryStream to iterate over the entries in the directory.
static DirectoryStream<Path>	newDirectoryStream(Path dir, Filter<? super Path> filter) Opens a directory, returning a DirectoryStream to iterate over the entries in the directory.
static DirectoryStream<Path>	newDirectoryStream(Path dir) Opens a directory, returning a DirectoryStream to iterate over all entries in the directory.
static InputStream	newInputStream(Path path, OpenOption... options) Opens a file, returning an input stream to read from the file.
static OutputStream	newOutputStream(Path path, OpenOption... options) Opens or creates a file, returning an output stream that may be used to write bytes to the file.
static boolean	notExists(Path path, LinkOption... options) Tests whether the file located by this path does not exist.
static String	probeContentType(Path path) Probes the content type of a file.
static byte[]	readAllBytes(Path path) Reads all the bytes from a file.
static List<String>	readAllLines(Path path, Charset cs) Read all lines from a file.
static List<String>	readAllLines(Path path) Read all lines from a file.
static Map<String, Object>	readAttributes(Path path, String attributes, LinkOption... options) Reads a set of file attributes as a bulk operation.
static <A extends BasicFileAttributes> A	readAttributes(Path path, Class<A> type, LinkOption... options) Reads a file's attributes as a bulk operation.
static Path	readSymbolicLink(Path link) Reads the target of a symbolic link (optional operation).
static Path	setAttribute(Path path, String attribute, Object value, LinkOption... options) Sets the value of a file attribute.
static Path	setLastModifiedTime(Path path, FileTime time) Updates a file's last modified time attribute.
static Path	setOwner(Path path, UserPrincipal owner) Updates the file owner.
static Path	setPosixFilePermissions(Path path, Set<PosixFilePermission> perms) Sets a file's POSIX permissions.
static long	size(Path path) Returns the size of a file (in bytes).
static Stream<Path>	walk(Path start, FileVisitOption... options) Return a Stream that is lazily populated with Path by walking the file tree rooted at a given starting file.
static Stream<Path>	walk(Path start, int maxDepth, FileVisitOption... options) Return a Stream that is lazily populated with Path by walking the file tree rooted at a given starting file.
static Path	walkFileTree(Path start, FileVisitor<? super Path> visitor) Walks a file tree.
static Path	walkFileTree(Path start, Set<FileVisitOption> options, int maxDepth, FileVisitor<? super Path> visitor) Walks a file tree.
static Path	write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options) Write lines of text to a file.
static Path	write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options) Write lines of text to a file.
static Path	write(Path path, byte[] bytes, OpenOption... options) Writes bytes to a file.

Inherited Method Summary

From class java.lang.Object

Object	clone() Creates and returns a copy of this Object.
boolean	equals(Object obj) Compares this instance with the specified object and indicates if they are equal.
void	finalize() Invoked when the garbage collector has detected that this instance is no longer reachable.
final Class<?>	getClass() Returns the unique instance of Class that represents this object's class.
int	hashCode() Returns an integer hash code for this object.
final void	notify() Causes a thread which is waiting on this object's monitor (by means of calling one of the wait() methods) to be woken up.
final void	notifyAll() Causes all threads which are waiting on this object's monitor (by means of calling one of the wait() methods) to be woken up.
String	toString() Returns a string containing a concise, human-readable description of this object.
final void	wait(long timeout, int nanos) Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object or until the specified timeout expires.
final void	wait(long timeout) Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object or until the specified timeout expires.
final void	wait() Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object.

Public Methods

public static Path copy (Path source, Path target, CopyOption... options)

Copy a file to a target file.

This method copies a file to the target file with the options parameter specifying how the copy is performed. By default, the copy fails if the target file already exists or is a symbolic link, except if the source and target are the same file, in which case the method completes without copying the file. File attributes are not required to be copied to the target file. If symbolic links are supported, and the file is a symbolic link, then the final target of the link is copied. If the file is a directory then it creates an empty directory in the target location (entries in the directory are not copied). This method can be used with the walkFileTree method to copy a directory and all entries in the directory, or an entire file-tree where required.

The options parameter may include any of the following:

Option	Description
REPLACE_EXISTING	If the target file exists, then the target file is replaced if it is not a non-empty directory. If the target file exists and is a symbolic link, then the symbolic link itself, not the target of the link, is replaced.
COPY_ATTRIBUTES	Attempts to copy the file attributes associated with this file to the target file. The exact file attributes that are copied is platform and file system dependent and therefore unspecified. Minimally, the last-modified-time is copied to the target file if supported by both the source and target file stores. Copying of file timestamps may result in precision loss.
NOFOLLOW_LINKS	Symbolic links are not followed. If the file is a symbolic link, then the symbolic link itself, not the target of the link, is copied. It is implementation specific if file attributes can be copied to the new link. In other words, the COPY_ATTRIBUTES option may be ignored when copying a symbolic link.

An implementation of this interface may support additional implementation specific options.

Copying a file is not an atomic operation. If an IOException is thrown, then it is possible that the target file is incomplete or some of its file attributes have not been copied from the source file. When the REPLACE_EXISTING option is specified and the target file exists, then the target file is replaced. The check for the existence of the file and the creation of the new file may not be atomic with respect to other file system activities.

Usage Example: Suppose we want to copy a file into a directory, giving it the same file name as the source file:

     Path source = ...
     Path newdir = ...
     Files.copy(source, newdir.resolve(source.getFileName());
 

Parameters

source	the path to the file to copy
target	the path to the target file (may be associated with a different provider to the source path)
options	options specifying how the copy should be done

Returns

• the path to the target file

Throws

UnsupportedOperationException	if the array contains a copy option that is not supported
FileAlreadyExistsException	if the target file exists but cannot be replaced because the REPLACE_EXISTING option is not specified (optional specific exception)
DirectoryNotEmptyException	the REPLACE_EXISTING option is specified but the file cannot be replaced because it is a non-empty directory (optional specific exception)
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, the checkRead method is invoked to check read access to the source file, the checkWrite is invoked to check write access to the target file. If a symbolic link is copied the security manager is invoked to check LinkPermission("symbolic").

public static long copy (Path source, OutputStream out)

Copies all bytes from a file to an output stream.

If an I/O error occurs reading from the file or writing to the output stream, then it may do so after some bytes have been read or written. Consequently the output stream may be in an inconsistent state. It is strongly recommended that the output stream be promptly closed if an I/O error occurs.

This method may block indefinitely writing to the output stream (or reading from the file). The behavior for the case that the output stream is asynchronously closed or the thread interrupted during the copy is highly output stream and file system provider specific and therefore not specified.

Note that if the given output stream is Flushable then its flush method may need to invoked after this method completes so as to flush any buffered output.

Parameters

source	the path to the file
out	the output stream to write to

Returns

• the number of bytes read or written

Throws

IOException	if an I/O error occurs when reading or writing
SecurityException	In the case of the default provider, and a security manager is installed, the checkRead method is invoked to check read access to the file.

public static long copy (InputStream in, Path target, CopyOption... options)

Copies all bytes from an input stream to a file. On return, the input stream will be at end of stream.

By default, the copy fails if the target file already exists or is a symbolic link. If the REPLACE_EXISTING option is specified, and the target file already exists, then it is replaced if it is not a non-empty directory. If the target file exists and is a symbolic link, then the symbolic link is replaced. In this release, the REPLACE_EXISTING option is the only option required to be supported by this method. Additional options may be supported in future releases.

If an I/O error occurs reading from the input stream or writing to the file, then it may do so after the target file has been created and after some bytes have been read or written. Consequently the input stream may not be at end of stream and may be in an inconsistent state. It is strongly recommended that the input stream be promptly closed if an I/O error occurs.

This method may block indefinitely reading from the input stream (or writing to the file). The behavior for the case that the input stream is asynchronously closed or the thread interrupted during the copy is highly input stream and file system provider specific and therefore not specified.

Usage example: Suppose we want to capture a web page and save it to a file:

     Path path = ...
     URI u = URI.create("http://java.sun.com/");
     try (InputStream in = u.toURL().openStream()) {
         Files.copy(in, path);
     }
 

Parameters

in	the input stream to read from
target	the path to the file
options	options specifying how the copy should be done

Returns

• the number of bytes read or written

Throws

IOException	if an I/O error occurs when reading or writing
FileAlreadyExistsException	if the target file exists but cannot be replaced because the REPLACE_EXISTING option is not specified (optional specific exception)
DirectoryNotEmptyException	the REPLACE_EXISTING option is specified but the file cannot be replaced because it is a non-empty directory (optional specific exception) *
UnsupportedOperationException	if options contains a copy option that is not supported
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access to the file. Where the REPLACE_EXISTING option is specified, the security manager's checkDelete method is invoked to check that an existing file can be deleted.

public static Path createDirectories (Path dir, FileAttribute...<?> attrs)

Creates a directory by creating all nonexistent parent directories first. Unlike the createDirectory method, an exception is not thrown if the directory could not be created because it already exists.

The attrs parameter is optional file-attributes to set atomically when creating the nonexistent directories. Each file attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored.

If this method fails, then it may do so after creating some, but not all, of the parent directories.

Parameters

dir	the directory to create
attrs	an optional list of file attributes to set atomically when creating the directory

Returns

• the directory

Throws

UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
FileAlreadyExistsException	if dir exists but is not a directory (optional specific exception)
IOException	if an I/O error occurs
SecurityException	in the case of the default provider, and a security manager is installed, the checkWrite method is invoked prior to attempting to create a directory and its checkRead is invoked for each parent directory that is checked. If dir is not an absolute path then its toAbsolutePath may need to be invoked to get its absolute path. This may invoke the security manager's checkPropertyAccess method to check access to the system property user.dir

public static Path createDirectory (Path dir, FileAttribute...<?> attrs)

Creates a new directory. The check for the existence of the file and the creation of the directory if it does not exist are a single operation that is atomic with respect to all other filesystem activities that might affect the directory. The createDirectories method should be used where it is required to create all nonexistent parent directories first.

The attrs parameter is optional file-attributes to set atomically when creating the directory. Each attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored.

Parameters

dir	the directory to create
attrs	an optional list of file attributes to set atomically when creating the directory

Returns

• the directory

Throws

UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
FileAlreadyExistsException	if a directory could not otherwise be created because a file of that name already exists (optional specific exception)
IOException	if an I/O error occurs or the parent directory does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access to the new directory.

public static Path createFile (Path path, FileAttribute...<?> attrs)

Creates a new and empty file, failing if the file already exists. The check for the existence of the file and the creation of the new file if it does not exist are a single operation that is atomic with respect to all other filesystem activities that might affect the directory.

The attrs parameter is optional file-attributes to set atomically when creating the file. Each attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored.

Parameters

path	the path to the file to create
attrs	an optional list of file attributes to set atomically when creating the file

Returns

• the file

Throws

UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the file
FileAlreadyExistsException	if a file of that name already exists (optional specific exception)
IOException	if an I/O error occurs or the parent directory does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access to the new file.

public static Path createLink (Path link, Path existing)

Creates a new link (directory entry) for an existing file (optional operation).

The link parameter locates the directory entry to create. The existing parameter is the path to an existing file. This method creates a new directory entry for the file so that it can be accessed using link as the path. On some file systems this is known as creating a "hard link". Whether the file attributes are maintained for the file or for each directory entry is file system specific and therefore not specified. Typically, a file system requires that all links (directory entries) for a file be on the same file system. Furthermore, on some platforms, the Java virtual machine may require to be started with implementation specific privileges to create hard links or to create links to directories.

Parameters

link	the link (directory entry) to create
existing	a path to an existing file

Returns

• the path to the link (directory entry)

Throws

UnsupportedOperationException	if the implementation does not support adding an existing file to a directory
FileAlreadyExistsException	if the entry could not otherwise be created because a file of that name already exists (optional specific exception)
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, it denies LinkPermission("hard") or its checkWrite method denies write access to either the link or the existing file.

public static Path createSymbolicLink (Path link, Path target, FileAttribute...<?> attrs)

Creates a symbolic link to a target (optional operation).

The target parameter is the target of the link. It may be an absolute or relative path and may not exist. When the target is a relative path then file system operations on the resulting link are relative to the path of the link.

The attrs parameter is optional attributes to set atomically when creating the link. Each attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored.

Where symbolic links are supported, but the underlying FileStore does not support symbolic links, then this may fail with an IOException. Additionally, some operating systems may require that the Java virtual machine be started with implementation specific privileges to create symbolic links, in which case this method may throw IOException.

Parameters

link	the path of the symbolic link to create
target	the target of the symbolic link
attrs	the array of attributes to set atomically when creating the symbolic link

Returns

• the path to the symbolic link

Throws

UnsupportedOperationException	if the implementation does not support symbolic links or the array contains an attribute that cannot be set atomically when creating the symbolic link
FileAlreadyExistsException	if a file with the name already exists (optional specific exception)
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, it denies LinkPermission("symbolic") or its checkWrite method denies write access to the path of the symbolic link.

public static Path createTempDirectory (String prefix, FileAttribute...<?> attrs)

Creates a new directory in the default temporary-file directory, using the given prefix to generate its name. The resulting Path is associated with the default FileSystem.

This method works in exactly the manner specified by createTempDirectory(Path, String, FileAttribute[]) method for the case that the dir parameter is the temporary-file directory.

Parameters

prefix	the prefix string to be used in generating the directory's name; may be null
attrs	an optional list of file attributes to set atomically when creating the directory

Returns

• the path to the newly created directory that did not exist before this method was invoked

Throws

IllegalArgumentException	if the prefix cannot be used to generate a candidate directory name
UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
IOException	if an I/O error occurs or the temporary-file directory does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access when creating the directory.

public static Path createTempDirectory (Path dir, String prefix, FileAttribute...<?> attrs)

Creates a new directory in the specified directory, using the given prefix to generate its name. The resulting Path is associated with the same FileSystem as the given directory.

The details as to how the name of the directory is constructed is implementation dependent and therefore not specified. Where possible the prefix is used to construct candidate names.

As with the createTempFile methods, this method is only part of a temporary-file facility. A shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.

The attrs parameter is optional file-attributes to set atomically when creating the directory. Each attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored.

Parameters

dir	the path to directory in which to create the directory
prefix	the prefix string to be used in generating the directory's name; may be null
attrs	an optional list of file attributes to set atomically when creating the directory

Returns

• the path to the newly created directory that did not exist before this method was invoked

Throws

IllegalArgumentException	if the prefix cannot be used to generate a candidate directory name
UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
IOException	if an I/O error occurs or dir does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access when creating the directory.

public static Path createTempFile (Path dir, String prefix, String suffix, FileAttribute...<?> attrs)

Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name. The resulting Path is associated with the same FileSystem as the given directory.

The details as to how the name of the file is constructed is implementation dependent and therefore not specified. Where possible the prefix and suffix are used to construct candidate names in the same manner as the File.createTempFile(String, String, File) method.

As with the File.createTempFile methods, this method is only part of a temporary-file facility. Where used as a work files, the resulting file may be opened using the DELETE_ON_CLOSE option so that the file is deleted when the appropriate close method is invoked. Alternatively, a shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the file automatically.

The attrs parameter is optional file-attributes to set atomically when creating the file. Each attribute is identified by its name. If more than one attribute of the same name is included in the array then all but the last occurrence is ignored. When no file attributes are specified, then the resulting file may have more restrictive access permissions to files created by the File.createTempFile(String, String, File) method.

Parameters

dir	the path to directory in which to create the file
prefix	the prefix string to be used in generating the file's name; may be null
suffix	the suffix string to be used in generating the file's name; may be null, in which case ".tmp" is used
attrs	an optional list of file attributes to set atomically when creating the file

Returns

• the path to the newly created file that did not exist before this method was invoked

Throws

IllegalArgumentException	if the prefix or suffix parameters cannot be used to generate a candidate file name
UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
IOException	if an I/O error occurs or dir does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access to the file.

public static Path createTempFile (String prefix, String suffix, FileAttribute...<?> attrs)

Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name. The resulting Path is associated with the default FileSystem.

This method works in exactly the manner specified by the createTempFile(Path, String, String, FileAttribute[]) method for the case that the dir parameter is the temporary-file directory.

Parameters

prefix	the prefix string to be used in generating the file's name; may be null
suffix	the suffix string to be used in generating the file's name; may be null, in which case ".tmp" is used
attrs	an optional list of file attributes to set atomically when creating the file

Returns

• the path to the newly created file that did not exist before this method was invoked

Throws

IllegalArgumentException	if the prefix or suffix parameters cannot be used to generate a candidate file name
UnsupportedOperationException	if the array contains an attribute that cannot be set atomically when creating the directory
IOException	if an I/O error occurs or the temporary-file directory does not exist
SecurityException	In the case of the default provider, and a security manager is installed, the checkWrite method is invoked to check write access to the file.

public static void delete (Path path)

Deletes a file.

An implementation may require to examine the file to determine if the file is a directory. Consequently this method may not be atomic with respect to other file system operations. If the file is a symbolic link then the symbolic link itself, not the final target of the link, is deleted.

If the file is a directory then the directory must be empty. In some implementations a directory has entries for special files or links that are created when the directory is created. In such implementations a directory is considered empty when only the special entries exist. This method can be used with the walkFileTree method to delete a directory and all entries in the directory, or an entire file-tree where required.

On some operating systems it may not be possible to remove a file when it is open and in use by this Java virtual machine or other programs.

Parameters

path	the path to the file to delete

Throws

NoSuchFileException	if the file does not exist (optional specific exception)
DirectoryNotEmptyException	if the file is a directory and could not otherwise be deleted because the directory is not empty (optional specific exception)
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, the SecurityManager.checkDelete(String) method is invoked to check delete access to the file

public static boolean deleteIfExists (Path path)

Deletes a file if it exists.

As with the delete(Path) method, an implementation may need to examine the file to determine if the file is a directory. Consequently this method may not be atomic with respect to other file system operations. If the file is a symbolic link, then the symbolic link itself, not the final target of the link, is deleted.

If the file is a directory then the directory must be empty. In some implementations a directory has entries for special files or links that are created when the directory is created. In such implementations a directory is considered empty when only the special entries exist.

On some operating systems it may not be possible to remove a file when it is open and in use by this Java virtual machine or other programs.

Parameters

path	the path to the file to delete

Returns

• true if the file was deleted by this method; false if the file could not be deleted because it did not exist

Throws

DirectoryNotEmptyException	if the file is a directory and could not otherwise be deleted because the directory is not empty (optional specific exception)
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, the SecurityManager.checkDelete(String) method is invoked to check delete access to the file.

public static boolean exists (Path path, LinkOption... options)

Tests whether a file exists.

The options parameter may be used to indicate how symbolic links are handled for the case that the file is a symbolic link. By default, symbolic links are followed. If the option NOFOLLOW_LINKS is present then symbolic links are not followed.

Note that the result of this method is immediately outdated. If this method indicates the file exists then there is no guarantee that a subsequence access will succeed. Care should be taken when using this method in security sensitive applications.

Parameters

path	the path to the file to test
options	options indicating how symbolic links are handled .

Returns

• true if the file exists; false if the file does not exist or its existence cannot be determined.

Throws

SecurityException	In the case of the default provider, the SecurityManager.checkRead(String) is invoked to check read access to the file.

See Also

• notExists(Path, LinkOption...)

public static Stream<Path> find (Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher, FileVisitOption... options)

Return a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.

This method walks the file tree in exactly the manner specified by the walk method. For each file encountered, the given BiPredicate is invoked with its Path and BasicFileAttributes. The Path object is obtained as if by resolving the relative path against start and is only included in the returned Stream if the BiPredicate returns true. Compare to calling filter on the Stream returned by walk method, this method may be more efficient by avoiding redundant retrieval of the BasicFileAttributes.

The returned stream encapsulates one or more DirectoryStreams. If timely disposal of file system resources is required, the try-with-resources construct should be used to ensure that the stream's close method is invoked after the stream operations are completed. Operating on a closed stream will result in an IllegalStateException.

If an IOException is thrown when accessing the directory after returned from this method, it is wrapped in an UncheckedIOException which will be thrown from the method that caused the access to take place.

Parameters

start	the starting file
maxDepth	the maximum number of directory levels to search
matcher	the function used to decide whether a file should be included in the returned stream
options	options to configure the traversal

Returns

• the Stream of Path

Throws

IllegalArgumentException	if the maxDepth parameter is negative
SecurityException	If the security manager denies access to the starting file. In the case of the default provider, the checkRead method is invoked to check read access to the directory.
IOException	if an I/O error is thrown when accessing the starting file.

See Also

• walk(Path, int, FileVisitOption)

public static Object getAttribute (Path path, String attribute, LinkOption... options)

Reads the value of a file attribute.

The attribute parameter identifies the attribute to be read and takes the form:

[view-name:]attribute-name

where square brackets [...] delineate an optional component and the character ':' stands for itself.

view-name is the name of a FileAttributeView that identifies a set of file attributes. If not specified then it defaults to "basic", the name of the file attribute view that identifies the basic set of file attributes common to many file systems. attribute-name is the name of the attribute.

The options array may be used to indicate how symbolic links are handled for the case that the file is a symbolic link. By default, symbolic links are followed and the file attribute of the final target of the link is read. If the option NOFOLLOW_LINKS is present then symbolic links are not followed.

Usage Example: Suppose we require the user ID of the file owner on a system that supports a "unix" view:

    Path path = ...
    int uid = (Integer)Files.getAttribute(path, "unix:uid");
 

Parameters

path	the path to the file
attribute	the attribute to read
options	options indicating how symbolic links are handled

Returns

• the attribute value

Throws

UnsupportedOperationException	if the attribute view is not available
IllegalArgumentException	if the attribute name is not specified or is not recognized
IOException	if an I/O error occurs
SecurityException	In the case of the default provider, and a security manager is installed, its checkRead method denies read access to the file. If this method is invoked to read security sensitive attributes then the security manager may be invoked to check for additional permissions.

public static V getFileAttributeView (Path path, Class<V> type, LinkOption... options)

Returns a file attribute view of a given type.

A file attribute view provides a read-only or updatable view of a set of file attributes. This method is intended to be used where the file attribute view defines type-safe methods to read or update the file attributes. The type parameter is the type of the attribute view required and the method returns an instance of that type if supported. The BasicFileAttributeView type supports access to the basic attributes of a file. Invoking this method to select a file attribute view of that type will always return an instance of that class.

The options array may be used to indicate how symbolic links are handled by the resulting file attribute view for the case that the file is a symbolic link. By default, symbolic links are followed. If the option NOFOLLOW_LINKS is present then symbolic links are not followed. This option is ignored by implementations that do not support symbolic links.

Usage Example: Suppose we want read or set a file's ACL, if supported:

     Path path = ...
     AclFileAttributeView view = Files.getFileAttributeView(path, AclFileAttributeView.class);
     if (view != null) {
         List<AclEntry> acl = view.getAcl();
         :
     }
 

Parameters

path	the path to the file
type	the Class object corresponding to the file attribute view
options	options indicating how symbolic links are handled

Returns

• a file attribute view of the specified type, or null if the attribute view type is not available

public static FileStore getFileStore (Path path)

Returns the FileStore representing the file store where a file is located.

Once a reference to the FileStore is obtained it is implementation specific if operations on the returned FileStore, or FileStor