public abstract class FileSystem extends Object implements Closeable
The default file system, obtained by invoking the FileSystems.getDefault
method, provides access to the file system that is
accessible to the Java virtual machine.
A file system is the factory for several types of objects:
The getPath
method converts a system dependent
path string, returning a Path
object that may be used
to locate and access a file.
The getFileStores
method returns an iterator
over the underlying file-stores
.
File systems vary greatly. In some cases the file system is a single
hierarchy of files with one top-level root directory. In other cases it may
have several distinct file hierarchies, each with its own top-level root
directory. The getRootDirectories
method may be
used to iterate over the root directories in the file system. A file system
is typically composed of one or more underlying file-stores
that provide the storage for the files. Theses file stores can also vary in
the features they support, and the file attributes or meta-data that
they associate with files.
A file system is open upon creation and can be closed by invoking its
close
method. Once closed, any further attempt to access
objects in the file system cause ClosedFileSystemException
to be
thrown. The Default File systems cannot be closed.
A FileSystem
can provide read-only or read-write access to the
file system. Whether or not a file system provides read-only access is
established when the FileSystem
is created and can be tested by invoking
its isReadOnly
method. Attempts to write to file stores
by means of an object associated with a read-only file system throws ReadOnlyFileSystemException
.
File systems are safe for use by multiple concurrent threads. The close
method may be invoked at any time to close a file system but
whether a file system is asynchronously closeable is provider specific
and therefore unspecified. In other words, if a thread is accessing an
object in a file system, and another thread invokes the close
method
then it may require to block until the first operation is complete. Closing
a file system causes all open channels, and other closeable
objects associated with the file system to be closed.
Modifier | Constructor and Description |
---|---|
protected |
FileSystem()
Initializes a new instance of this class.
|
Modifier and Type | Method and Description |
---|---|
abstract void |
close()
Closes this file system.
|
abstract Iterable<FileStore> |
getFileStores()
Returns an object to iterate over the underlying file stores.
|
abstract Path |
getPath(String first,
String... more)
Converts a path string, or a sequence of strings that when joined form
a path string, to a
Path . |
abstract Iterable<Path> |
getRootDirectories()
Returns an object to iterate over the paths of the root directories.
|
abstract String |
getSeparator()
Returns the name separator, represented as a string.
|
abstract boolean |
isOpen()
Tells whether or not this file system is open.
|
abstract boolean |
isReadOnly()
Tells whether or not this file system allows only read-only access to
its file stores.
|
abstract Set<String> |
supportedFileAttributeViews()
Returns the set of the file attribute view names of the file
attribute views supported by this
FileSystem . |
public abstract void close() throws IOException
After a file system is closed then all subsequent access to the file
system, either by methods defined by this class or on objects associated
with this file system, throw ClosedFileSystemException
. If the
file system is already closed then invoking this method has no effect.
Closing a file system will close all open channels
, directory-streams
,
and other closeable objects associated
with this file system. The default
file
system cannot be closed.
close
in interface Closeable
close
in interface AutoCloseable
IOException
- If an I/O error occursUnsupportedOperationException
- Thrown in the case of the default file systempublic abstract Iterable<FileStore> getFileStores()
The elements of the returned iterator are the FileStores
for this file system. The order of the elements is
not defined and the file stores may change during the lifetime of the
Java virtual machine. When an I/O error occurs, perhaps because a file
store is not accessible, then it is not returned by the iterator.
In the case of the default provider, and a security manager is
installed, the security manager is invoked to check RuntimePermission
("getFileStoreAttributes"). If denied, then
no file stores are returned by the iterator. In addition, the security
manager's SecurityManager.checkRead(String)
method is invoked to
check read access to the file store's top-most directory. If
denied, the file store is not returned by the iterator. It is system
dependent if the permission checks are done when the iterator is obtained
or during iteration.
Usage Example: Suppose we want to print the space usage for all file stores:
for (FileStore store: FileSystems.getDefault().getFileStores()) { long total = store.getTotalSpace() / 1024; long used = (store.getTotalSpace() - store.getUnallocatedSpace()) / 1024; long avail = store.getUsableSpace() / 1024; System.out.format("%-20s %12d %12d %12d%n", store, total, used, avail); }
public abstract Path getPath(String first, String... more)
Path
. If more
does not specify any
elements then the value of the first
parameter is the path string
to convert. If more
specifies one or more elements then each
non-empty string, including first
, is considered to be a sequence
of name elements (see Path
) and is joined to form a path string.
The details as to how the Strings are joined is provider specific but
typically they will be joined using the name-separator
as the separator. For example, if the name separator is
"/
" and getPath("/foo","bar","gus")
is invoked, then the
path string "/foo/bar/gus"
is converted to a Path
.
A Path
representing an empty path is returned if first
is the empty string and more
does not contain any non-empty
strings.
The parsing and conversion to a path object is inherently
implementation dependent. In the simplest case, the path string is rejected,
and InvalidPathException
thrown, if the path string contains
characters that cannot be converted to characters that are legal
to the file store. For example, on UNIX systems, the NUL (\u0000)
character is not allowed to be present in a path. An implementation may
choose to reject path strings that contain names that are longer than those
allowed by any file store, and where an implementation supports a complex
path syntax, it may choose to reject path strings that are badly
formed.
In the case of the default provider, path strings are parsed based on the definition of paths at the platform or virtual file system level. For example, an operating system may not allow specific characters to be present in a file name, but a specific underlying file store may impose different or additional restrictions on the set of legal characters.
This method throws InvalidPathException
when the path string
cannot be converted to a path. Where possible, and where applicable,
the exception is created with an index
value indicating the first position in the path
parameter
that caused the path string to be rejected.
first
- the path string or initial part of the path stringmore
- additional strings to be joined to form the path stringPath
InvalidPathException
- If the path string cannot be convertedpublic abstract Iterable<Path> getRootDirectories()
A file system provides access to a file store that may be composed of a number of distinct file hierarchies, each with its own top-level root directory. Unless denied by the security manager, each element in the returned iterator corresponds to the root directory of a distinct file hierarchy. The order of the elements is not defined. The file hierarchies may change during the lifetime of the Java virtual machine. For example, in some implementations, the insertion of removable media may result in the creation of a new file hierarchy with its own top-level directory.
When a security manager is installed, it is invoked to check access
to the each root directory. If denied, the root directory is not returned
by the iterator. In the case of the default provider, the SecurityManager.checkRead(String)
method is invoked to check read access
to each root directory. It is system dependent if the permission checks
are done when the iterator is obtained or during iteration.
public abstract String getSeparator()
The name separator is used to separate names in a path string. An
implementation may support multiple name separators in which case this
method returns an implementation specific default name separator.
This separator is used when creating path strings by invoking the toString()
method.
public abstract boolean isOpen()
File systems created by the default provider are always open.
true
if, and only if, this file system is openpublic abstract boolean isReadOnly()
true
if, and only if, this file system provides
read-only accesspublic abstract Set<String> supportedFileAttributeViews()
FileSystem
.
The Basic File AttributeView is required to be supported and therefore the set contains at least one element, "basic".
The supportsFileAttributeView(String)
method may be used to test if an
underlying FileStore
supports the file attributes identified by a
file attribute view.
Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. Use of this specification is subject to license terms.