Constructor Summary

Method Summary

Constructor Details

• FileSystem

  protected FileSystem()

  Initializes a new instance of this class.

Method Details

• provider

  public abstract FileSystemProvider provider()

  Returns the provider that created this file system.

  Returns:

  The provider that created this file system.

• close

  public abstract void close() throwsIOException

  Closes this file system.

  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, throwClosedFileSystemException. If the file system is already closed then invoking this method has no effect.

  Closing a file system will close all openchannels,directory-streams,watch-service, and other closeable objects associated with this file system. Thedefault file system cannot be closed.

  Specified by:

  close in interface AutoCloseable

  Specified by:

  close in interface Closeable

  Throws:

  IOException - If an I/O error occurs

  UnsupportedOperationException - Thrown in the case of the default file system

• isOpen

  public abstract boolean isOpen()

  Tells whether or not this file system is open.

  File systems created by the default provider are always open.

  Returns:

  true if, and only if, this file system is open

• isReadOnly

  public abstract boolean isReadOnly()

  Tells whether or not this file system allows only read-only access to its file stores.

  Returns:

  true if, and only if, this file system provides read-only access

• getSeparator

  public abstract String getSeparator()

  Returns the name separator, represented as a string.

  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 specificdefault name separator. This separator is used when creating path strings by invoking thetoString() method.

  In the case of the default provider, this method returns the same separator asFile.separator.

  Returns:

  The name separator

• getRootDirectories

  public abstract Iterable<Path> getRootDirectories()

  Returns an object to iterate over the paths of the root directories.

  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. 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 ava 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. There is no guarantee that a root directory can be accessed.

  Returns:

  An object to iterate over the root directories

• getFileStores

  public abstract Iterable<FileStore> getFileStores()

  Returns an object to iterate over the underlying file stores.

  The elements of the returned iterator are theFileStores 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.

  Usage Example: Suppose we want to print the space usage for all file stores:

  Copy

      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);    }

  Returns:

  An object to iterate over the backing file stores

• supportedFileAttributeViews

  public abstract Set<String> supportedFileAttributeViews()

  Returns the set of thenames of the file attribute views supported by thisFileSystem.

  TheBasicFileAttributeView is required to be supported and therefore the set contains at least one element, "basic".

  ThesupportsFileAttributeView(String) method may be used to test if an underlyingFileStore supports the file attributes identified by a file attribute view.

  Returns:

  An unmodifiable set of the names of the supported file attribute views

• getPath

  public abstract Path getPath(String first,String... more)

  Converts a path string, or a sequence of strings that when joined form a path string, to aPath. Ifmore does not specify any elements then the value of thefirst parameter is the path string to convert. Ifmore specifies one or more elements then each non-empty string, includingfirst, is considered to be a sequence of name elements (seePath) 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 thename-separator as the separator. For example, if the name separator is "/" andgetPath("/foo","bar","gus") is invoked, then the path string"/foo/bar/gus" is converted to aPath. APath representing an empty path is returned iffirst is the empty string andmore 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, andInvalidPathException thrown, if the path string contains characters that cannot be converted to characters that arelegal 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 arebadly 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 throwsInvalidPathException when the path string cannot be converted to a path. Where possible, and where applicable, the exception is created with anindex value indicating the first position in thepath parameter that caused the path string to be rejected.

  Parameters:

  first - the path string or initial part of the path string

  more - additional strings to be joined to form the path string

  Returns:

  the resultingPath

  Throws:

  InvalidPathException - If the path string cannot be converted

• getPathMatcher

  public abstract PathMatcher getPathMatcher(String syntaxAndPattern)

  Returns aPathMatcher that performs match operations on theString representation ofPath objects by interpreting a given pattern. ThesyntaxAndPattern parameter identifies the syntax and the pattern and takes the form:

  syntax:pattern

  wheresyntax is the non-empty name of the syntax,pattern is a possibly-empty pattern string, and':' stands for itself.

  AFileSystem implementation supports the "glob" and "regex" syntaxes, and may support others. The value of the syntax component is compared without regard to case.

  When the syntax is "glob" then theString representation of the path is matched using a limited pattern language that resembles regular expressions but with a simpler syntax. For example:

  Pattern Language

  Example	Description
  *.java	Matches a path that represents a file name ending in.java
  *.*	Matches file names containing a dot
  *.{java,class}	Matches file names ending with.java or.class
  foo.?	Matches file names starting withfoo. and a single character extension
  /home/*/*	Matches/home/gus/data on UNIX platforms
  /home/**	Matches/home/gus and/home/gus/data on UNIX platforms
  C:\\*	MatchesC:\foo andC:\bar on the Windows platform (note that the backslash is escaped; as a string literal in the Java Language the pattern would be"C:\\\\*")

  The following rules are used to interpret glob patterns:

  • The* character matches zero or morecharacters of aname component without crossing directory boundaries.

  • The** characters matches zero or morecharacters crossing directory boundaries.

  • The? character matches exactly one character of a name component.

  • The backslash character (\) is used to escape characters that would otherwise be interpreted as special characters. The expression\\ matches a single backslash and "\{" matches a left brace for example.

  • The[ ] characters are abracket expression that match a single character of a name component out of a set of characters. For example,[abc] matches"a","b", or"c". The hyphen (-) may be used to specify a range so[a-z] specifies a range that matches from"a" to"z" (inclusive). These forms can be mixed so [abce-g] matches"a","b","c","e","f" or"g". If the character after the[ is a! then it is used for negation so [!a-c] matches any character except"a","b", or "c".

    Within a bracket expression the*,? and\ characters match themselves. The (-) character matches itself if it is the first character within the brackets, or the first character after the! if negating.

  • The{ } characters are a group of subpatterns, where the group matches if any subpattern in the group matches. The"," character is used to separate the subpatterns. Groups cannot be nested.

  • Leading period/dot characters in file name are treated as regular characters in match operations. For example, the"*" glob pattern matches file name".login". TheFiles.isHidden(java.nio.file.Path) method may be used to test whether a file is considered hidden.

  • All other characters match themselves in an implementation dependent manner. This includes characters representing anyname-separators.

  • The matching ofroot components is highly implementation-dependent and is not specified.

  When the syntax is "regex" then the pattern component is a regular expression as defined by thePattern class.

  For both the glob and regex syntaxes, the matching details, such as whether the matching is case sensitive, are implementation-dependent and therefore not specified.

  Parameters:

  syntaxAndPattern - The syntax and pattern

  Returns:

  A path matcher that may be used to match paths against the pattern

  Throws:

  IllegalArgumentException - If the parameter does not take the form:syntax:pattern

  PatternSyntaxException - If the pattern is invalid

  UnsupportedOperationException - If the pattern syntax is not known to the implementation

  See Also:

  • Files.newDirectoryStream(Path,String)

• getUserPrincipalLookupService

  public abstract UserPrincipalLookupService getUserPrincipalLookupService()

  Returns theUserPrincipalLookupService for this file system(optional operation). The resulting lookup service may be used to lookup user or group names.

  Usage Example: Suppose we want to make "joe" the owner of a file:

  Copy

      UserPrincipalLookupService lookupService = FileSystems.getDefault().getUserPrincipalLookupService();    Files.setOwner(path, lookupService.lookupPrincipalByName("joe"));

  Returns:

  TheUserPrincipalLookupService for this file system

  Throws:

  UnsupportedOperationException - If thisFileSystem does not does have a lookup service

• newWatchService

  public abstract WatchService newWatchService() throwsIOException

  Constructs a newWatchService(optional operation).

  This method constructs a new watch service that may be used to watch registered objects for changes and events.

  Returns:

  a new watch service

  Throws:

  UnsupportedOperationException - If thisFileSystem does not support watching file system objects for changes and events. This exception is not thrown byFileSystems created by the default provider.

  IOException - If an I/O error occurs