Files

Public methods
static Path!	`copy(source: Path!, target: Path!, vararg options: CopyOption!)` Copy a file to a target file.
static Long	`copy(in: InputStream!, target: Path!, vararg options: CopyOption!)` Copies all bytes from an input stream to a file.
static Long	`copy(source: Path!, out: OutputStream!)` Copies all bytes from a file to an output stream.
static Path!	`createDirectories(dir: Path!, vararg attrs: FileAttribute<*>!)` Creates a directory by creating all nonexistent parent directories first.
static Path!	`createDirectory(dir: Path!, vararg attrs: FileAttribute<*>!)` Creates a new directory.
static Path!	`createFile(path: Path!, vararg attrs: FileAttribute<*>!)` Creates a new and empty file, failing if the file already exists.
static Path!	`createLink(link: Path!, existing: Path!)` Creates a new link (directory entry) for an existing file (optional operation).
static Path!	`createSymbolicLink(link: Path!, target: Path!, vararg attrs: FileAttribute<>!)` Creates a symbolic link to a target (optional operation)*.
static Path!	`createTempDirectory(dir: Path!, prefix: String!, vararg attrs: FileAttribute<*>!)` Creates a new directory in the specified directory, using the given prefix to generate its name.
static Path!	`createTempDirectory(prefix: String!, vararg attrs: FileAttribute<*>!)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name.
static Path!	`createTempFile(dir: Path!, prefix: String!, suffix: String!, vararg attrs: FileAttribute<*>!)` Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
static Path!	`createTempFile(prefix: String!, suffix: String!, vararg attrs: FileAttribute<*>!)` Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name.
static Unit	`delete(path: Path!)` Deletes a file.
static Boolean	`deleteIfExists(path: Path!)` Deletes a file if it exists.
static Boolean	`exists(path: Path!, vararg options: LinkOption!)` Tests whether a file exists.
static Stream<Path!>!	`find(start: Path!, maxDepth: Int, matcher: BiPredicate<Path!, BasicFileAttributes!>!, vararg options: FileVisitOption!)` Return a `Stream` that is lazily populated with `Path` by searching for files in a file tree rooted at a given starting file.
static Any!	`getAttribute(path: Path!, attribute: String!, vararg options: LinkOption!)` Reads the value of a file attribute.
static V	`getFileAttributeView(path: Path!, type: Class<V>!, vararg options: LinkOption!)` 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!, vararg options: LinkOption!)` Returns a file's last modified time.
static UserPrincipal!	`getOwner(path: Path!, vararg options: LinkOption!)` Returns the owner of a file.
static MutableSet<PosixFilePermission!>!	`getPosixFilePermissions(path: Path!, vararg options: LinkOption!)` Returns a file's POSIX file permissions.
static Boolean	`isDirectory(path: Path!, vararg options: LinkOption!)` 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!, vararg options: LinkOption!)` Tests whether a file is a regular file with opaque content.
static Boolean	`isSameFile(path: Path!, path2: Path!)` 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!, cs: Charset!)` Read all lines from a file as a `Stream`.
static Stream<String!>!	`lines(path: Path!)` Read all lines from a file as a `Stream`.
static Stream<Path!>!	`list(dir: Path!)` Return a lazily populated `Stream`, the elements of which are the entries in the directory.
static Path!	`move(source: Path!, target: Path!, vararg options: CopyOption!)` Move or rename a file to a target file.
static BufferedReader!	`newBufferedReader(path: Path!, cs: Charset!)` 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!, cs: Charset!, vararg options: OpenOption!)` 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 BufferedWriter!	`newBufferedWriter(path: Path!, vararg options: OpenOption!)` Opens or creates a file for writing, returning a `BufferedWriter` to write text to the file in an efficient manner.
static SeekableByteChannel!	`newByteChannel(path: Path!, options: MutableSet<out OpenOption!>!, vararg attrs: FileAttribute<*>!)` Opens or creates a file, returning a seekable byte channel to access the file.
static SeekableByteChannel!	`newByteChannel(path: Path!, vararg options: OpenOption!)` Opens or creates a file, returning a seekable byte channel to access the file.
static DirectoryStream<Path!>!	`newDirectoryStream(dir: Path!)` Opens a directory, returning a `DirectoryStream` to iterate over all entries in the directory.
static DirectoryStream<Path!>!	`newDirectoryStream(dir: Path!, glob: String!)` Opens a directory, returning a `DirectoryStream` to iterate over the entries in the directory.
static DirectoryStream<Path!>!	`newDirectoryStream(dir: Path!, filter: DirectoryStream.Filter<in Path!>!)` Opens a directory, returning a `DirectoryStream` to iterate over the entries in the directory.
static InputStream!	`newInputStream(path: Path!, vararg options: OpenOption!)` Opens a file, returning an input stream to read from the file.
static OutputStream!	`newOutputStream(path: Path!, vararg options: OpenOption!)` Opens or creates a file, returning an output stream that may be used to write bytes to the file.
static Boolean	`notExists(path: Path!, vararg options: LinkOption!)` Tests whether the file located by this path does not exist.
static String!	`probeContentType(path: Path!)` Probes the content type of a file.
static ByteArray!	`readAllBytes(path: Path!)` Reads all the bytes from a file.
static MutableList<String!>!	`readAllLines(path: Path!, cs: Charset!)` Read all lines from a file.
static MutableList<String!>!	`readAllLines(path: Path!)` Read all lines from a file.
static A	`readAttributes(path: Path!, type: Class<A>!, vararg options: LinkOption!)` Reads a file's attributes as a bulk operation.
static MutableMap<String!, Any!>!	`readAttributes(path: Path!, attributes: String!, vararg options: LinkOption!)` Reads a set of file attributes as a bulk operation.
static Path!	`readSymbolicLink(link: Path!)` Reads the target of a symbolic link (optional operation).
static Path!	`setAttribute(path: Path!, attribute: String!, value: Any!, vararg options: LinkOption!)` Sets the value of a file attribute.
static Path!	`setLastModifiedTime(path: Path!, time: FileTime!)` Updates a file's last modified time attribute.
static Path!	`setOwner(path: Path!, owner: UserPrincipal!)` Updates the file owner.
static Path!	`setPosixFilePermissions(path: Path!, perms: MutableSet<PosixFilePermission!>!)` Sets a file's POSIX permissions.
static Long	`size(path: Path!)` Returns the size of a file (in bytes).
static Stream<Path!>!	`walk(start: Path!, maxDepth: Int, vararg options: FileVisitOption!)` Return a `Stream` that is lazily populated with `Path` by walking the file tree rooted at a given starting file.
static Stream<Path!>!	`walk(start: Path!, vararg options: FileVisitOption!)` Return a `Stream` that is lazily populated with `Path` by walking the file tree rooted at a given starting file.
static Path!	`walkFileTree(start: Path!, options: MutableSet<FileVisitOption!>!, maxDepth: Int, visitor: FileVisitor<in Path!>!)` Walks a file tree.
static Path!	`walkFileTree(start: Path!, visitor: FileVisitor<in Path!>!)` Walks a file tree.
static Path!	`write(path: Path!, bytes: ByteArray!, vararg options: OpenOption!)` Writes bytes to a file.
static Path!	`write(path: Path!, lines: MutableIterable<CharSequence!>!, cs: Charset!, vararg options: OpenOption!)` Write lines of text to a file.
static Path!	`write(path: Path!, lines: MutableIterable<CharSequence!>!, vararg options: OpenOption!)` Write lines of text to a file.

copy

static fun copy(
    source: Path!, 
    target: Path!, 
    vararg options: CopyOption!
): Path!

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`	Path!: the path to the file to copy
`target`	Path!: the path to the target file (may be associated with a different provider to the source path)
`options`	CopyOption!: options specifying how the copy should be done

Return
`Path!`	the path to the target file

Exceptions
`java.lang.UnsupportedOperationException`	if the array contains a copy option that is not supported
`java.nio.file.FileAlreadyExistsException`	if the target file exists but cannot be replaced because the `REPLACE_EXISTING` option is not specified (optional specific exception)
`java.nio.file.DirectoryNotEmptyException`	the `REPLACE_EXISTING` option is specified but the file cannot be replaced because it is a non-empty directory (optional specific exception)
`java.io.IOException`	if an I/O error occurs
`java.lang.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")`.

Parameters
`in`	InputStream!: the input stream to read from
`target`	Path!: the path to the file
`options`	CopyOption!: options specifying how the copy should be done

Exceptions
`java.io.IOException`	if an I/O error occurs when reading or writing
`java.nio.file.FileAlreadyExistsException`	if the target file exists but cannot be replaced because the `REPLACE_EXISTING` option is not specified (optional specific exception)
`java.nio.file.DirectoryNotEmptyException`	the `REPLACE_EXISTING` option is specified but the file cannot be replaced because it is a non-empty directory (optional specific exception) *
`java.lang.UnsupportedOperationException`	if `options` contains a copy option that is not supported
`java.lang.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.

Parameters
`source`	Path!: the path to the file
`out`	OutputStream!: the output stream to write to

Parameters
`dir`	Path!: the directory to create
`attrs`	FileAttribute<*>!: an optional list of file attributes to set atomically when creating the directory

Exceptions
`java.lang.UnsupportedOperationException`	if the array contains an attribute that cannot be set atomically when creating the directory
`java.nio.file.FileAlreadyExistsException`	if `dir` exists but is not a directory (optional specific exception)
`java.io.IOException`	if an I/O error occurs
`java.lang.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`

Parameters
`path`	Path!: the path to the file to create
`attrs`	FileAttribute<*>!: an optional list of file attributes to set atomically when creating the file

Parameters
`link`	Path!: the link (directory entry) to create
`existing`	Path!: a path to an existing file

Exceptions
`java.lang.UnsupportedOperationException`	if the implementation does not support adding an existing file to a directory
`java.nio.file.FileAlreadyExistsException`	if the entry could not otherwise be created because a file of that name already exists (optional specific exception)
`java.io.IOException`	if an I/O error occurs
`java.lang.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.

Parameters
`link`	Path!: the path of the symbolic link to create
`target`	Path!: the target of the symbolic link
`attrs`	FileAttribute<*>!: the array of attributes to set atomically when creating the symbolic link

Exceptions
`java.lang.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
`java.nio.file.FileAlreadyExistsException`	if a file with the name already exists (optional specific exception)
`java.io.IOException`	if an I/O error occurs
`java.lang.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.

Parameters
`dir`	Path!: the path to directory in which to create the directory
`prefix`	String!: the prefix string to be used in generating the directory's name; may be `null`
`attrs`	FileAttribute<*>!: an optional list of file attributes to set atomically when creating the directory

Exceptions
`java.lang.IllegalArgumentException`	if the prefix cannot be used to generate a candidate directory name
`java.lang.UnsupportedOperationException`	if the array contains an attribute that cannot be set atomically when creating the directory
`java.io.IOException`	if an I/O error occurs or `dir` does not exist
`java.lang.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.

Exceptions
`java.lang.IllegalArgumentException`	if the prefix or suffix parameters cannot be used to generate a candidate file name
`java.lang.UnsupportedOperationException`	if the array contains an attribute that cannot be set atomically when creating the directory
`java.io.IOException`	if an I/O error occurs or `dir` does not exist
`java.lang.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.

Parameters
`prefix`	String!: the prefix string to be used in generating the file's name; may be `null`
`suffix`	String!: the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used
`attrs`	FileAttribute<*>!: an optional list of file attributes to set atomically when creating the file

Exceptions
`java.nio.file.NoSuchFileException`	if the file does not exist (optional specific exception)
`java.nio.file.DirectoryNotEmptyException`	if the file is a directory and could not otherwise be deleted because the directory is not empty (optional specific exception)
`java.io.IOException`	if an I/O error occurs
`java.lang.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

Parameters
`path`	Path!: the path to the file to test
`options`	LinkOption!: options indicating how symbolic links are handled .

Parameters
`start`	Path!: the starting file
`maxDepth`	Int: the maximum number of directory levels to search
`matcher`	BiPredicate<Path!, BasicFileAttributes!>!: the function used to decide whether a file should be included in the returned stream
`options`	FileVisitOption!: options to configure the traversal

Exceptions
`java.lang.IllegalArgumentException`	if the `maxDepth` parameter is negative
`java.lang.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.
`java.io.IOException`	if an I/O error is thrown when accessing the starting file.

Parameters
`path`	Path!: the path to the file
`attribute`	String!: the attribute to read
`options`	LinkOption!: options indicating how symbolic links are handled

Exceptions
`java.lang.UnsupportedOperationException`	if the attribute view is not available
`java.lang.IllegalArgumentException`	if the attribute name is not specified or is not recognized
`java.io.IOException`	if an I/O error occurs
`java.lang.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.

Summary

Public methods

copy

copy

copy

createDirectories

createDirectory

createFile

createLink

createSymbolicLink

createTempDirectory

createTempDirectory

createTempFile

createTempFile

delete

deleteIfExists

exists

find

getAttribute

getFileAttributeView

getFileStore

getLastModifiedTime

getOwner

getPosixFilePermissions

isDirectory

isExecutable

isHidden

isReadable

isRegularFile

isSameFile

isSymbolicLink

isWritable

lines

lines

list

move

newBufferedReader

newBufferedReader

newBufferedWriter

newBufferedWriter

newByteChannel

newByteChannel

newDirectoryStream

newDirectoryStream

newDirectoryStream

newInputStream

newOutputStream

notExists

probeContentType

readAllBytes

readAllLines

readAllLines

readAttributes

readAttributes

readSymbolicLink

setAttribute

setLastModifiedTime

setOwner

setPosixFilePermissions

size

walk

walk

walkFileTree

walkFileTree

write

write

write

Parameters
`<V>`	The `FileAttributeView` type
`path`	Path!: the path to the file
`type`	Class<V>!: the `Class` object corresponding to the file attribute view
`options`	LinkOption!: options indicating how symbolic links are handled

Exceptions
`java.lang.UnsupportedOperationException`	if the associated file system does not support the `FileOwnerAttributeView`
`java.io.IOException`	if an I/O error occurs
`java.lang.SecurityException`	In the case of the default provider, and a security manager is installed, it denies `RuntimePermission`("accessUserInformation") or its `checkRead` method denies read access to the file.

Parameters
`path`	Path!: one path to the file
`path2`	Path!: the other path

Parameters
`path`	Path!: the path to the file
`cs`	Charset!: the charset to use for decoding

Exceptions
`java.io.IOException`	if an I/O error occurs opening the file
`java.lang.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.

Exceptions
`java.nio.file.NotDirectoryException`	if the file could not otherwise be opened because it is not a directory (optional specific exception)
`java.io.IOException`	if an I/O error occurs when opening the directory
`java.lang.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 directory.

Parameters
`source`	Path!: the path to the file to move
`target`	Path!: the path to the target file (may be associated with a different provider to the source path)
`options`	CopyOption!: options specifying how the move should be done

Exceptions
`java.io.IOException`	if an I/O error occurs opening or creating the file
`java.lang.UnsupportedOperationException`	if an unsupported option is specified
`java.lang.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.

Option	Description
`APPEND`	If this option is present then the file is opened for writing and each invocation of the channel's `write` method first advances the position to the end of the file and then writes the requested data. Whether the advancement of the position and the writing of the data are done in a single atomic operation is system-dependent and therefore unspecified. This option may not be used in conjunction with the `READ` or `TRUNCATE_EXISTING` options.
`TRUNCATE_EXISTING`	If this option is present then the existing file is truncated to a size of 0 bytes. This option is ignored when the file is opened only for reading.
`CREATE_NEW`	If this option is present then a new file is created, failing if the file already exists or is a symbolic link. When creating a file the check for the existence of the file and the creation of the file if it does not exist is atomic with respect to other file system operations. This option is ignored when the file is opened only for reading.
`CREATE`	If this option is present then an existing file is opened if it exists, otherwise a new file is created. This option is ignored if the `CREATE_NEW` option is also present or the file is opened only for reading.
`DELETE_ON_CLOSE`	When this option is present then the implementation makes a best effort attempt to delete the file when closed by the java.nio.channels.SeekableByteChannel#close method. If the `close` method is not invoked then a best effort attempt is made to delete the file when the Java virtual machine terminates.
`SPARSE`	When creating a new file this option is a hint that the new file will be sparse. This option is ignored when not creating a new file.
`SYNC`	Requires that every update to the file's content or metadata be written synchronously to the underlying storage device. (see Synchronized I/O file integrity).
`DSYNC`	Requires that every update to the file's content be written synchronously to the underlying storage device. (see Synchronized I/O file integrity).

Parameters
`path`	Path!: the path to the file to open or create
`options`	MutableSet<out OpenOption!>!: options specifying how the file is opened
`attrs`	FileAttribute<*>!: an optional list of file attributes to set atomically when creating the file