GenericPath (java7-fs-base 0.0.1 API)

java.lang.Object
- com.github.fge.filesystem.path.GenericPath

All Implemented Interfaces:

Comparable<Path>, Iterable<Path>, Path, Watchable
```
@ParametersAreNonnullByDefault
public final class GenericPath
extends Object
implements Path
```
A generic Path implementation
Most of the heavy lifting of path manipulation (resolution, parent etc) is delegated to the PathElementsFactory provided as an argument to the constructor, which is why this class can be made final.

You won't want to create instances of this class directly; use FileSystem.getPath(String, String...) instead.

See Also:
PathElementsFactory, PathElements

Constructor Summary

Constructors
Constructor and Description

GenericPath(GenericFileSystem fs, PathElementsFactory factory, PathElements elements)
Constructor

Constructors
Constructor and Description
`GenericPath(GenericFileSystem fs, PathElementsFactory factory, PathElements elements)` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`compareTo(Path other)` Compares two abstract paths lexicographically.
`boolean`	`endsWith(Path other)` Tests if this path ends with the given path.
`boolean`	`endsWith(String other)` Tests if this path ends with a `Path`, constructed by converting the given path string, in exactly the manner specified by the `endsWith(Path)` method.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`Path`	`getFileName()` Returns the name of the file or directory denoted by this path as a `Path` object.
`FileSystem`	`getFileSystem()` Returns the file system that created this object.
`Path`	`getName(int index)` Returns a name element of this path as a `Path` object.
`int`	`getNameCount()` Returns the number of name elements in the path.
`Path`	`getParent()` Returns the parent path, or `null` if this path does not have a parent.
`Path`	`getRoot()` Returns the root component of this path as a `Path` object, or `null` if this path does not have a root component.
`int`	`hashCode()` Returns a hash code value for the object.
`boolean`	`isAbsolute()` Tells whether or not this path is absolute.
`Iterator<Path>`	`iterator()` Returns an iterator over the name elements of this path.
`Path`	`normalize()` Returns a path that is this path with redundant name elements eliminated.
`WatchKey`	`register(WatchService watcher, WatchEvent.Kind<?>... events)` Registers the file located by this path with a watch service.
`WatchKey`	`register(WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers)` Registers the file located by this path with a watch service.
`Path`	`relativize(Path other)` Constructs a relative path between this path and a given path.
`Path`	`resolve(Path other)` Resolve the given path against this path.
`Path`	`resolve(String other)` Converts a given path string to a `Path` and resolves it against this `Path` in exactly the manner specified by the `resolve` method.
`Path`	`resolveSibling(Path other)` Resolves the given path against this path's `parent` path.
`Path`	`resolveSibling(String other)` Converts a given path string to a `Path` and resolves it against this path's `parent` path in exactly the manner specified by the `resolveSibling` method.
`boolean`	`startsWith(Path other)` Tests if this path starts with the given path.
`boolean`	`startsWith(String other)` Tests if this path starts with a `Path`, constructed by converting the given path string, in exactly the manner specified by the `startsWith(Path)` method.
`Path`	`subpath(int beginIndex, int endIndex)` Returns a relative `Path` that is a subsequence of the name elements of this path.
`Path`	`toAbsolutePath()` Returns a `Path` object representing the absolute path of this path.
`File`	`toFile()` Returns a `File` object representing this path.
`Path`	`toRealPath(LinkOption... options)` Returns the real path of an existing file.
`String`	`toString()` Returns a string representation of the object.
`URI`	`toUri()` Returns a URI to represent this path.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - GenericPath
```
public GenericPath(GenericFileSystem fs,
           PathElementsFactory factory,
           PathElements elements)
```
    Constructor
    
    Parameters:
    fs - the file system this path is issued from
    factory - the path elements factory
    elements - the path elements
- Method Detail
  - getFileSystem
```
public FileSystem getFileSystem()
```
    Returns the file system that created this object.
    
    Specified by:
    
    getFileSystem in interface Path
    
    Returns:
    the file system that created this object
  - isAbsolute
```
public boolean isAbsolute()
```
    Tells whether or not this path is absolute.
    An absolute path is complete in that it doesn't need to be combined with other path information in order to locate a file.
    
    Specified by:
    
    isAbsolute in interface Path
    
    Returns:
    true if, and only if, this path is absolute
    See Also:
    PathElementsFactory.isAbsolute(PathElements)
  - getRoot
```
public Path getRoot()
```
    Returns the root component of this path as a Path object, or null if this path does not have a root component.
    
    Specified by:
    
    getRoot in interface Path
    
    Returns:
    a path representing the root component of this path, or null
    See Also:
    PathElements.rootPathElement()
  - getFileName
```
public Path getFileName()
```
    Returns the name of the file or directory denoted by this path as a Path object. The file name is the farthest element from the root in the directory hierarchy.
    
    Specified by:
    
    getFileName in interface Path
    
    Returns:
    a path representing the name of the file or directory, or null if this path has zero elements
    See Also:
    PathElements.lastName()
  - getParent
```
public Path getParent()
```
    Returns the parent path, or null if this path does not have a parent.
    The parent of this path object consists of this path's root component, if any, and each element in the path except for the farthest from the root in the directory hierarchy. This method does not access the file system; the path or its parent may not exist. Furthermore, this method does not eliminate special names such as "." and ".." that may be used in some implementations. On UNIX for example, the parent of "/a/b/c" is "/a/b", and the parent of "x/y/." is "x/y". This method may be used with the normalize method, to eliminate redundant names, for cases where shell-like navigation is required.
    If this path has one or more elements, and no root component, then this method is equivalent to evaluating the expression:
    subpath(0, getNameCount()-1);
    Specified by:
    
    getParent in interface Path
    
    Returns:
    a path representing the path's parent
  - getNameCount
```
public int getNameCount()
```
    Returns the number of name elements in the path.
    
    Specified by:
    
    getNameCount in interface Path
    
    Returns:
    the number of elements in the path, or 0 if this path only represents a root component
  - getName
```
public Path getName(int index)
```
    Returns a name element of this path as a Path object.
    The index parameter is the index of the name element to return. The element that is closest to the root in the directory hierarchy has index 0. The element that is farthest from the root has index count-1.
    
    Specified by:
    
    getName in interface Path
    
    Parameters:
    index - the index of the element
    
    Returns:
    the name element
    
    Throws:
    
    IllegalArgumentException - if index is negative, index is greater than or equal to the number of elements, or this path has zero name elements
  - subpath
```
public Path subpath(int beginIndex,
           int endIndex)
```
    Returns a relative Path that is a subsequence of the name elements of this path.
    The beginIndex and endIndex parameters specify the subsequence of name elements. The name that is closest to the root in the directory hierarchy has index 0. The name that is farthest from the root has index count-1. The returned Path object has the name elements that begin at beginIndex and extend to the element at index endIndex-1.
    
    Specified by:
    
    subpath in interface Path
    
    Parameters:
    beginIndex - the index of the first element, inclusive
    endIndex - the index of the last element, exclusive
    
    Returns:
    a new Path object that is a subsequence of the name elements in this Path
    
    Throws:
    
    IllegalArgumentException - if beginIndex is negative, or greater than or equal to the number of elements. If endIndex is less than or equal to beginIndex, or larger than the number of elements.
  - startsWith
```
public boolean startsWith(Path other)
```
    Tests if this path starts with the given path.
    This path starts with the given path if this path's root component starts with the root component of the given path, and this path starts with the same name elements as the given path. If the given path has more name elements than this path then false is returned.
    Whether or not the root component of this path starts with the root component of the given path is file system specific. If this path does not have a root component and the given path has a root component then this path does not start with the given path.
    If the given path is associated with a different FileSystem to this path then false is returned.
    
    Specified by:
    
    startsWith in interface Path
    
    Parameters:
    other - the given path
    
    Returns:
    true if this path starts with the given path; otherwise false
  - startsWith
```
public boolean startsWith(String other)
```
    Tests if this path starts with a Path, constructed by converting the given path string, in exactly the manner specified by the startsWith(Path) method. On UNIX for example, the path "foo/bar" starts with "foo" and "foo/bar". It does not start with "f" or "fo".
    
    Specified by:
    
    startsWith in interface Path
    
    Parameters:
    other - the given path string
    
    Returns:
    true if this path starts with the given path; otherwise false
    
    Throws:
    
    InvalidPathException - If the path string cannot be converted to a Path.
  - endsWith
```
public boolean endsWith(Path other)
```
    Tests if this path ends with the given path.
    If the given path has N elements, and no root component, and this path has N or more elements, then this path ends with the given path if the last N elements of each path, starting at the element farthest from the root, are equal.
    If the given path has a root component then this path ends with the given path if the root component of this path ends with the root component of the given path, and the corresponding elements of both paths are equal. Whether or not the root component of this path ends with the root component of the given path is file system specific. If this path does not have a root component and the given path has a root component then this path does not end with the given path.
    If the given path is associated with a different FileSystem to this path then false is returned.
    
    Specified by:
    
    endsWith in interface Path
    
    Parameters:
    other - the given path
    
    Returns:
    true if this path ends with the given path; otherwise false
  - endsWith
```
public boolean endsWith(String other)
```
    Tests if this path ends with a Path, constructed by converting the given path string, in exactly the manner specified by the endsWith(Path) method. On UNIX for example, the path "foo/bar" ends with "foo/bar" and "bar". It does not end with "r" or "/bar". Note that trailing separators are not taken into account, and so invoking this method on the Path"foo/bar" with the String "bar/" returns true.
    
    Specified by:
    
    endsWith in interface Path
    
    Parameters:
    other - the given path string
    
    Returns:
    true if this path starts with the given path; otherwise false
    
    Throws:
    
    InvalidPathException - If the path string cannot be converted to a Path.
  - normalize
```
public Path normalize()
```
    Returns a path that is this path with redundant name elements eliminated.
    The precise definition of this method is implementation dependent but in general it derives from this path, a path that does not contain redundant name elements. In many file systems, the "." and ".." are special names used to indicate the current directory and parent directory. In such file systems all occurrences of "." are considered redundant. If a ".." is preceded by a non-".." name then both names are considered redundant (the process to identify such names is repeated until is it no longer applicable).
    This method does not access the file system; the path may not locate a file that exists. Eliminating ".." and a preceding name from a path may result in the path that locates a different file than the original path. This can arise when the preceding name is a symbolic link.
    
    Specified by:
    
    normalize in interface Path
    
    Returns:
    the resulting path or this path if it does not contain redundant name elements; an empty path is returned if this path does have a root component and all name elements are redundant
    See Also:
    getParent(), toRealPath(java.nio.file.LinkOption...)
  - resolve
```
public Path resolve(Path other)
```
    Resolve the given path against this path.
    If the other parameter is an absolute path then this method trivially returns other. If other is an empty path then this method trivially returns this path. Otherwise this method considers this path to be a directory and resolves the given path against this path. In the simplest case, the given path does not have a root component, in which case this method joins the given path to this path and returns a resulting path that ends with the given path. Where the given path has a root component then resolution is highly implementation dependent and therefore unspecified.
    
    Specified by:
    
    resolve in interface Path
    
    Parameters:
    other - the path to resolve against this path
    
    Returns:
    the resulting path
    See Also:
    relativize(java.nio.file.Path)
  - resolve
```
public Path resolve(String other)
```
    Converts a given path string to a Path and resolves it against this Path in exactly the manner specified by the resolve method. For example, suppose that the name separator is "/" and a path represents "foo/bar", then invoking this method with the path string "gus" will result in the Path "foo/bar/gus".
    
    Specified by:
    
    resolve in interface Path
    
    Parameters:
    other - the path string to resolve against this path
    
    Returns:
    the resulting path
    
    Throws:
    
    InvalidPathException - if the path string cannot be converted to a Path.
    See Also:
    FileSystem.getPath(java.lang.String, java.lang.String...)
  - resolveSibling
```
public Path resolveSibling(Path other)
```
    Resolves the given path against this path's parent path. This is useful where a file name needs to be replaced with another file name. For example, suppose that the name separator is "/" and a path represents "dir1/dir2/foo", then invoking this method with the Path "bar" will result in the Path "dir1/dir2/bar". If this path does not have a parent path, or other is absolute, then this method returns other. If other is an empty path then this method returns this path's parent, or where this path doesn't have a parent, the empty path.
    
    Specified by:
    
    resolveSibling in interface Path
    
    Parameters:
    other - the path to resolve against this path's parent
    
    Returns:
    the resulting path
    See Also:
    resolve(Path)
  - resolveSibling
```
public Path resolveSibling(String other)
```
    Converts a given path string to a Path and resolves it against this path's parent path in exactly the manner specified by the resolveSibling method.
    
    Specified by:
    
    resolveSibling in interface Path
    
    Parameters:
    other - the path string to resolve against this path's parent
    
    Returns:
    the resulting path
    
    Throws:
    
    InvalidPathException - if the path string cannot be converted to a Path.
    See Also:
    FileSystem.getPath(java.lang.String, java.lang.String...)
  - relativize
```
public Path relativize(Path other)
```
    Constructs a relative path between this path and a given path.
    Relativization is the inverse of resolution. This method attempts to construct a relative path that when resolved against this path, yields a path that locates the same file as the given path. For example, on UNIX, if this path is "/a/b" and the given path is "/a/b/c/d" then the resulting relative path would be "c/d". Where this path and the given path do not have a root component, then a relative path can be constructed. A relative path cannot be constructed if only one of the paths have a root component. Where both paths have a root component then it is implementation dependent if a relative path can be constructed. If this path and the given path are equal then an empty path is returned.
    For any two normalized paths p and q, where q does not have a root component,
    p.relativize(p.resolve(q)) .equals(q)
    
    When symbolic links are supported, then whether the resulting path, when resolved against this path, yields a path that can be used to locate the same file as other is implementation dependent. For example, if this path is "/a/b" and the given path is "/a/x" then the resulting relative path may be "../x". If "b" is a symbolic link then is implementation dependent if "a/b/../x" would locate the same file as "/a/x".
    
    Specified by:
    
    relativize in interface Path
    
    Parameters:
    other - the path to relativize against this path
    
    Returns:
    the resulting relative path, or an empty path if both paths are equal
    
    Throws:
    
    IllegalArgumentException - if other is not a Path that can be relativized against this path
  - toUri
```
public URI toUri()
```
    Returns a URI to represent this path.
    This method constructs an absolute URI with a scheme equal to the URI scheme that identifies the provider. The exact form of the scheme specific part is highly provider dependent.
    In the case of the default provider, the URI is hierarchical with a path component that is absolute. The query and fragment components are undefined. Whether the authority component is defined or not is implementation dependent. There is no guarantee that the URI may be used to construct a java.io.File. In particular, if this path represents a Universal Naming Convention (UNC) path, then the UNC server name may be encoded in the authority component of the resulting URI. In the case of the default provider, and the file exists, and it can be determined that the file is a directory, then the resulting URI will end with a slash.
    The default provider provides a similar round-trip guarantee to the File class. For a given Path p it is guaranteed that
    Paths.get(p.toUri()).equals (p .toAbsolutePath())
    so long as the original Path, the URI, and the new Path are all created in (possibly different invocations of) the same Java virtual machine. Whether other providers make any guarantees is provider specific and therefore unspecified.
    When a file system is constructed to access the contents of a file as a file system then it is highly implementation specific if the returned URI represents the given path in the file system or it represents a compound URI that encodes the URI of the enclosing file system. A format for compound URIs is not defined in this release; such a scheme may be added in a future release.
    
    Specified by:
    
    toUri in interface Path
    
    Returns:
    the URI representing this path
    
    Throws:
    
    IOError - if an I/O error occurs obtaining the absolute path, or where a file system is constructed to access the contents of a file as a file system, and the URI of the enclosing file system cannot be obtained
    
    SecurityException - In the case of the default provider, and a security manager is installed, the toAbsolutePath method throws a security exception.
  - toAbsolutePath
```
public Path toAbsolutePath()
```
    Returns a Path object representing the absolute path of this path.
    If this path is already absolute then this method simply returns this path. Otherwise, this method resolves the path in an implementation dependent manner, typically by resolving the path against a file system default directory. Depending on the implementation, this method may throw an I/O error if the file system is not accessible.
    
    Specified by:
    
    toAbsolutePath in interface Path
    
    Returns:
    a Path object representing the absolute path
    
    Throws:
    
    IOError - if an I/O error occurs
    
    SecurityException - In the case of the default provider, a security manager is installed, and this path is not absolute, then the security manager's checkPropertyAccess method is invoked to check access to the system property user.dir
  - toRealPath
```
public Path toRealPath(LinkOption... options)
                throws IOException
```
    Returns the real path of an existing file.
    The precise definition of this method is implementation dependent but in general it derives from this path, an absolute path that locates the same file as this path, but with name elements that represent the actual name of the directories and the file. For example, where filename comparisons on a file system are case insensitive then the name elements represent the names in their actual case. Additionally, the resulting path has redundant name elements removed.
    If this path is relative then its absolute path is first obtained, as if by invoking the toAbsolutePath method.
    The options array may be used to indicate how symbolic links are handled. By default, symbolic links are resolved to their final target. If the option NOFOLLOW_LINKS is present then this method does not resolve symbolic links. Some implementations allow special names such as ".." to refer to the parent directory. When deriving the real path, and a ".." (or equivalent) is preceded by a non-".." name then an implementation will typically cause both names to be removed. When not resolving symbolic links and the preceding name is a symbolic link then the names are only removed if it guaranteed that the resulting path will locate the same file as this path.
    
    Specified by:
    
    toRealPath in interface Path
    
    Parameters:
    options - options indicating how symbolic links are handled
    
    Returns:
    an absolute path represent the real path of the file located by this object
    
    Throws:
    
    IOException - if the file does not exist or an I/O error occurs
    
    SecurityException - In the case of the default provider, and a security manager is installed, its checkRead method is invoked to check read access to the file, and where this path is not absolute, its checkPropertyAccess method is invoked to check access to the system property user.dir
  - toFile
```
public File toFile()
```
    Returns a File object representing this path. Where this Path is associated with the default provider, then this method is equivalent to returning a File object constructed with the String representation of this path.
    If this path was created by invoking the File toPath method then there is no guarantee that the File object returned by this method is equal to the original File.
    
    Specified by:
    
    toFile in interface Path
    
    Returns:
    a File object representing this path
    
    Throws:
    
    UnsupportedOperationException - if this Path is not associated with the default provider
  - register
```
public WatchKey register(WatchService watcher,
                WatchEvent.Kind<?>[] events,
                WatchEvent.Modifier... modifiers)
                  throws IOException
```
    Registers the file located by this path with a watch service.
    In this release, this path locates a directory that exists. The directory is registered with the watch service so that entries in the directory can be watched. The events parameter is the events to register and may contain the following events:
    - ENTRY_CREATE - entry created or moved into the directory
    - ENTRY_DELETE - entry deleted or moved out of the directory
    - ENTRY_MODIFY - entry in directory was modified
    The context for these events is the relative path between the directory located by this path, and the path that locates the directory entry that is created, deleted, or modified.
    The set of events may include additional implementation specific event that are not defined by the enum StandardWatchEventKinds
    The modifiers parameter specifies modifiers that qualify how the directory is registered. This release does not define any standard modifiers. It may contain implementation specific modifiers.
    Where a file is registered with a watch service by means of a symbolic link then it is implementation specific if the watch continues to depend on the existence of the symbolic link after it is registered.
    Specified by:
    
    register in interface Path
    
    Specified by:
    
    register in interface Watchable
    
    Parameters:
    watcher - the watch service to which this object is to be registered
    events - the events for which this object should be registered
    modifiers - the modifiers, if any, that modify how the object is registered
    
    Returns:
    a key representing the registration of this object with the given watch service
    
    Throws:
    
    UnsupportedOperationException - if unsupported events or modifiers are specified
    
    IllegalArgumentException - if an invalid combination of events or modifiers is specified
    
    ClosedWatchServiceException - if the watch service is closed
    
    NotDirectoryException - if the file is registered to watch the entries in a directory and the file 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 checkRead method is invoked to check read access to the file.
  - register
```
public WatchKey register(WatchService watcher,
                WatchEvent.Kind<?>... events)
                  throws IOException
```
    Registers the file located by this path with a watch service.
    An invocation of this method behaves in exactly the same way as the invocation
```
     watchable.register(watcher, events, new WatchEvent
     .Modifier[0]);
 
```
    Usage Example: Suppose we wish to register a directory for entry create, delete, and modify events:
```
     Path dir = ...
     WatchService watcher = ...
     WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE,
     ENTRY_MODIFY);
 
```
    Specified by:
    
    register in interface Path
    
    Specified by:
    
    register in interface Watchable
    
    Parameters:
    watcher - The watch service to which this object is to be registered
    events - The events for which this object should be registered
    
    Returns:
    A key representing the registration of this object with the given watch service
    
    Throws:
    
    UnsupportedOperationException - If unsupported events are specified
    
    IllegalArgumentException - If an invalid combination of events is specified
    
    ClosedWatchServiceException - If the watch service is closed
    
    NotDirectoryException - If the file is registered to watch the entries in a directory and the file 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 checkRead method is invoked to check read access to the file.
  - iterator
```
public Iterator<Path> iterator()
```
    Returns an iterator over the name elements of this path.
    The first element returned by the iterator represents the name element that is closest to the root in the directory hierarchy, the second element is the next closest, and so on. The last element returned is the name of the file or directory denoted by this path. The root component, if present, is not returned by the iterator.
    
    Specified by:
    
    iterator in interface Iterable<Path>
    
    Specified by:
    
    iterator in interface Path
    
    Returns:
    an iterator over the name elements of this path.
  - compareTo
```
public int compareTo(Path other)
```
    Compares two abstract paths lexicographically. The ordering defined by this method is provider specific, and in the case of the default provider, platform specific. This method does not access the file system and neither file is required to exist.
    This method may not be used to compare paths that are associated with different file system providers.
    
    Specified by:
    
    compareTo in interface Comparable<Path>
    
    Specified by:
    
    compareTo in interface Path
    
    Parameters:
    other - the path compared to this path.
    
    Returns:
    zero if the argument is equal to this path, a value less than zero if this path is lexicographically less than the argument, or a value greater than zero if this path is lexicographically greater than the argument
    
    Throws:
    
    ClassCastException - if the paths are associated with different providers
  - hashCode
```
public int hashCode()
```
    Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by HashMap.
    The general contract of hashCode is:
    - Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
    - If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
    - It is not required that if two objects are unequal according to the Object.equals(Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.
    As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java^TM programming language.)
    Specified by:
    
    hashCode in interface Path
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    a hash code value for this object.
    See Also:
    Object.equals(Object), System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(@Nullable
             Object obj)
```
    Indicates whether some other object is "equal to" this one.
    The equals method implements an equivalence relation on non-null object references:
    - It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    - It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    - It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    - It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    - For any non-null reference value x, x.equals(null) should return false.
    The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
    Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
    Specified by:
    
    equals in interface Path
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    obj - the reference object with which to compare.
    
    Returns:
    true if this object is the same as the obj argument; false otherwise.
    See Also:
    hashCode(), HashMap
  - toString
```
@Nonnull
public String toString()
```
    Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
    The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
    getClass().getName() + '@' + Integer.toHexString(hashCode())
    Specified by:
    
    toString in interface Path
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a string representation of the object.

Class GenericPath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GenericPath

Method Detail

getFileSystem

isAbsolute

getRoot

getFileName

getParent

getNameCount

getName

subpath

startsWith

startsWith

endsWith

endsWith

normalize

resolve

resolve

resolveSibling

resolveSibling

relativize

toUri

toAbsolutePath

toRealPath

toFile

register

register

iterator

compareTo

hashCode

equals

toString