chapter 9 ■ Java File I/O (NIO.2)

•The take() method returns a queued key if available; otherwise it waits until a key is available.

•The key difference between the poll() and take() methods is that poll() is a non-blocking call and take() is a blocking call.

•When a key is returned, one or more events might be queued; that’s why you put in another for loop to iterate through all the available events.

•You can get the kind of event using the kind() method and the name of the file for which the event has occurred using the context() method.

•Once you are done with event processing, you need to reset the key using the reset() method on the key.

Points to Remember

Here are the concepts you need to understand in order to pass this section of the OCPJP exam.

•Do not confuse File with Files, Path with Paths, and FileSystem with FileSystems: they are different. File is an old class (Java 4) that represents file/directory path names, while Files was introduced in Java 7 as a utility class with comprehensive support for I/O APIs. The Path interface represents a file/directory path and defines a useful list of methods. However, the Paths class is a utility class that offers only two methods (both to get the Path object). FileSystems offer a list of factory methods for the class FileSystem, whereas FileSystem provides a useful set of methods to get information about a file system.

•The file or directory represented by a Path object might not exist.

•You learned how to perform a copy for files/directories. However, it is not necessary that you perform copy on two files/directories only. You can take input from an InputStream and write to a file, or you can take input from a file and copy to an OutputStream.

Methods copy(InputStream, Path, CopyOptions. . .) and copy(Path, OutputStream, CopyOptions. . .) could be used here.

•You must be careful about performing an operation when walking a file tree. For instance, if you are performing a recursive delete, you should first delete all the containing files before deleting the directory that is holding these containing files.

•The Visitor design pattern is used to enable walking through a file tree.

•In the context of a watch service, a state is associated with a watch key. A watch key might be in ready state (ready to accept events), in signed state (when one or more events are queued), or in invalid state (when the watch key is not valid). If the key is in the signed state, it is required to call the reset() method; otherwise the state of the key will not change to ready state and you will not receive any further event notification.

•Your program may receive an OVERFLOW event even if the program is not registered for this event.

•If you are watching a directory using the watch service offered by Java 7, then only files contained in that directory will be watched—and not the files contained in the subdirectories of that directory. If you intend to watch the whole subtree of the file system, you need to recursively register each directory in the subtree.

276

chapter 9 ■ Java File I/O (NIO.2)

Question Time! 

1. Consider the following program:

while(aFilePath.iterator().hasNext()) {

System.out.println("path element: " + aFilePath.iterator().next());

}

}

}

Assume that the file D:\dir\file.txt exists in the underlying file system. Which one of the following options correctly describes the behavior of this program?

A)The program gives a compiler error in the line marked with the comment FILEPATH because the checked exception FileNotFoundException is not handled.

B)The program gives a compiler error in the line marked with the comment FILEPATH because the checked exception InvalidPathException is not handled.

C)The program gets into an infinite loop printing “path element: dir” forever.

D)The program prints the following: path element: dir

path element: file.txt

Answer: C) The program gets into an infinite loop printing “path element: dir” forever.

(In the while loop, you use iterator() to get a temporary iterator object. So, the call to next() on the temporary variable is lost, so the while loop gets into an infinite loop. In other words, the following loop will terminate after printing the “dir” and “file.txt” parts of the path:

Iterator<Path> paths = aFilePath.iterator(); while(paths.hasNext()) {

System.out.println("path element: " + paths.next());

}

Option A) is wrong because the Paths.get method does not throw FileNotFoundException.

Option B) is wrong because InvalidPathException is a RuntimeException. Also, since the file path exists in the underlying file system, this exception will not be thrown when the program is executed.

Option D) is wrong because the program will get into an infinite loop).

2.Which two of the following statements are correct regarding the SimpleFileVisitor interface?

A)The postVisitDirectory method, declared in SimpleFileVisitor, will be invoked after all the entries (i.e., files and subdirectories) of the directory have been visited.

277

chapter 9 ■ Java File i/O (NiO.2)

B) the visitFile method, declared in SimpleFileVisitor, will be invoked when a file is visited.

c)the visitFileOrDirectory method, declared in SimpleFileVisitor, will be invoked when a file or subdirectory is visited.

D) the walkFileTree method, declared in SimpleFileVisitor, will walk the file tree. Answer: a) and B) are correct statements.

(regarding option c), there is no such method as visitFileOrDirectory in SimpleFileVisitor interface. regarding option D), the walkFileTree method is a static method defined in the Files class that will walk the file tree. the walkFileTree method is not declared in SimpleFileVisitor. in fact, FileVisitor is one of the arguments this method takes for which you can pass a SimpleFileVisitor object as an argument.)

3.consider the following program: import java.nio.file.*;

class Relativize {

public static void main(String []args) { Path javaPath =

Paths.get("D:\\OCPJP7\\programs\\NIO2\\src\\Relativize.java").normalize(); Path classPath =

Paths.get("D:\\OCPJP7\\programs\\NIO2\\src\\Relativize.class").normalize();

Path result = javaPath.relativize(classPath); if(result == null) {

System.out.println("relativize failed"); } else if(result.equals(Paths.get(""))) {

System.out.println("relative paths are same, so relativize returned empty path");

} else {

System.out.println(result);

}

}

}

Which of the following options correctly shows the output of this program? a) the program prints the following: relativize failed.

B) the program prints the following: relative paths are same, so relativize returned empty path. c) the program prints the following: ..\relativize.class.

D) the program prints the following: ..\relativize.java.

Answer: c) the program prints the following: ..\relativize.class.

(the relativize() method constructs a relative path between this path and a given path. in this case, the paths for both the files are the same and they differ only in the file names (Relativize. java and Relativize.class). the relative comparison of paths is performed from the given path to the passed path to the relativize method, so it prints ..\relativize.class.

Note: the normalize() method removes any redundant name elements in a path. in this program, there are no redundant name elements, so it has no impact on the output of this program.)

278

chapter 9 ■ Java File I/O (NIO.2)

4.Consider the following program:

import java.nio.file.*;

class SubPath {

public static void main(String []args) {

Path aPath = Paths.get("D:\\OCPJP7\\programs\\..\\NIO2\\src\\.\\SubPath.java"); aPath = aPath.normalize();

System.out.println(aPath.subpath(2, 3));

}

}

This program prints the following:

A)..

B)src

C)NIO2

D)NIO2\src

E)..\NIO2

Answer: B) src

(The normalize() method removes redundant name elements in the given path, so after the call to the normalize() method, the aPath value is D:\OCPJP7\NIO2\src\SubPath.java.

The subpath(int beginIndex, int endIndex) method returns a path based on the values of beginIndex and endIndex. The name that is closest to the root has index 0; note that the root itself (in this case D:\) is not considered as an element in the path. Hence, the name elements “OCPJP7”, “NIO2”, “src”, “SubPath.java” are in index positions 0, 1, 2, and 3, respectively.

Note that beginIndex is the index of the first element, inclusive of that element; endIndex is the index of the last element, exclusive of that element. Hence, the subpath is “sub”, which is at index position 2 in this path.)

5.Assuming that the variable path points to a valid Path object, which one of the following statements is the correct way to create a WatchService?

A)WatchService watchService = WatchService.getInstance(path);

B)WatchService watchService = FileSystem.newWatchService();

C)WatchService watchService = path.getFileSystem().newWatchService();

D)WatchService watchService = FileSystem("default").getWatchService(path);

Answer: C) WatchService watchService = path.getFileSystem().newWatchService();

(The newWatchService() method is an abstract method defined in the FileSystem class. To get a WatchService instance associated with a given path object, you need to first get the associated FileSystem object and call the newWatchService() method on that FileSystem object. Hence, option C) is the right answer.)

279