[JAVA_NIO_FILE_SUMMARY] Java NIO.2 File package summary [PATH_OPERATIONS] Path operations

A java.nio.file.Path object is somewhat analogous to a java.io.File object as it can represent a file or directory on the file system. A Path object is more abstract though, in that it is a sequence of names that represent a directory hierarchy (that may or may not include a file) on the file system. There are no methods in the Path interface that allow working with directories or files. The defined methods are for working with or manipulating Path objects only, resolving one Path to another. (There is one method that can be used to obtain a java.io.File object from a java.nio.file.Path, toFile. Likewise the java.io.File class now contains a toPath method.) To work with files and directories, Path objects are used in conjunction with the java.nio.file.Files class. The java.nio.file.Files class consists entirely of static methods for manipulating directories and files, including copy, move and functions for working with symbolic links.

	Implementations of java.nio.file.Path interface are immutable and safe for use by multiple concurrent threads.

In Java 6.0 and earlier you do that:

File file = new File("README.TXT");
					

Since Java 7.0 you do that:

// Paths class consists exclusively of static methods that return a Path by
// converting a path string or URI

Path path = Paths.get("README.TXT");
					

To make the migration to Java 7.0 (or later) easier, the File class has a new method toPath() that allows you to transform File to Path:

Path path = new File("README.TXT").toPath();
					

Like File, a Path can also refer to a not existing file. That is only file path, NOT the data containing in a file.

The following code snippet defines a Path instance and then invoke several methods to obtain information about the path. Assume we have following folders structure on Windows platform:

C:\home\zaikin\foo
					

	NOTE: None of listed below methods requires that the file corresponding to the Path existed. If the path does not exist physically on the disk, no runtime exception is thrown.

Removing redundancies from a Path

Given the following code:

Path path = Paths.get("C:\\home\\zaikin\\..\\..\\foo");
Path p = path.normalize();
System.out.println(path);
System.out.println(path.getNameCount());
System.out.println(p);
System.out.println(p.getNameCount());
					

it prints (NOTE: implementations of Path interface are immutable by design)

C:\home\zaikin\..\..\foo
5
C:\foo
1
					

The normalize() method 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).

NOTE: 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.

Creating a path between two paths

A common requirement when you are writing file I/O code is the capability to construct a path from one location in the file system to another location. You can meet this using the relativize() method. This method constructs a path originating from the original path and ending at the location specified by the passed-in path. The new path is relative to the original path. Relativization is the inverse of resolution.

For example, consider two relative paths:

Path p1 = Paths.get("home");
Path p2 = Paths.get("home/zaikin/foo");
					

the folowing code:

Path p1_p2 = p1.relativize(p2);
System.out.println(p1_p2);

Path p2_p1 = p2.relativize(p1);
System.out.println(p2_p1);
					

will produce the following output:

zaikin\foo
..\..
					

In this example, the two paths share the same node, home. To navigate from home to foo, you first navigate one level down to zaikin and then one more level down to foo. Navigating from foo to home requires moving up two levels.

A relative path CANNOT be constructed if only one of the paths includes a root element. If both paths include a root element, the capability to construct a relative path is system dependent.

Joining two Paths

You can combine paths by using the Path.resolve(Path other) and Path.resolve(String other) methods. You pass in a partial path, which is a path that does not include a root element, and that partial path is appended to the original 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.

For example, consider the following code snippet:

Path p3 = Paths.get("C:\\home\\zaikin\\foo");
System.out.format("%s%n", p3.resolve("bar"));
					

the result is:

C:\home\zaikin\foo\bar
					

Passing an absolute path to the resolve method returns the passed-in path:

Path p4 = Paths.get("bar");
System.out.format("%s%n", p4.resolve("C:\\home\\zaikin\\foo"));
					

the result is:

C:\home\zaikin\foo
					

Factory methods

Java 11.0 added two new overloaded static methods to java.nio.file.Path interface to conveniently create an instance of the interface:

public static Path of(String first, String... more)

public static Path of(URI uri) 
					

Assuming we have a hierarchy:

C:\home
└───zaikin
    └───foo
            test.txt
					

Then we can create Path instances as follows:

Path path = Path.of("C:", "home", "zaikin", "foo", "test.txt");
System.out.println(path);
boolean exists = Files.exists(path);
System.out.println(exists);
					

C:\home\zaikin\foo\test.txt
true
					

 URI uri = URI.create("file:///C:/home/zaikin/bar/test.txt"); // does NOT exist !
 System.out.println(uri);
 Path path = Path.of(uri);
 System.out.println(path);
 System.out.println(Files.exists(path));
					

file:///C:/home/zaikin/bar/test.txt
C:\home\zaikin\bar\test.txt
false
					

	Most of the Path interface methods (including of(...)) do not throw exception when the file does not exist.