Files

Public methods
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!	`copy(source: Path!, target: Path!, vararg options: CopyOption!)` Copy a file to a target file.
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(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!	`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!	`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 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 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!)` Read all lines from a file as a `Stream`.
static Stream<String!>!	`lines(path: Path!, cs: Charset!)` 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!)` Opens a file for reading, returning a `BufferedReader` to read text from the file in an efficient manner.
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 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!, vararg options: OpenOption!)` Opens or creates a file, returning a seekable byte channel to access the file.
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 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!)` Read all lines from a file.
static MutableList<String!>!	`readAllLines(path: Path!, cs: Charset!)` 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!, visitor: FileVisitor<in Path!>!)` Walks a file tree.
static Path!	`walkFileTree(start: Path!, options: MutableSet<FileVisitOption!>!, maxDepth: Int, 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(
    in: InputStream!, 
    target: Path!, 
    vararg options: CopyOption!
): Long

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`	InputStream!: the input stream to read from
`target`	Path!: the path to the file
`options`	CopyOption!: options specifying how the copy should be done

Return
`Long`	the number of bytes read or written

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

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.

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

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
`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
`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 the temporary-file directory 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.

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

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.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 the temporary-file directory 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.

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.

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
`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.

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

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.

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

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.