Java NIO Related

A file's status is 3-valued:

1. The file is verified to exist;
2. The file is verified to not exist;
3. The file's status is unknown, when program has not sufficient right to the file.

So !Files.exists(path) != Files.notExists(path).

If both exists and notExists return false, the existence of the file cannot be verified.

To verify a program can access a file as needed, use isReadable(path), isWritable(path), isExecutable(path) methods.

 Path = …
 boolean isRegularExecutableFile = File.isRegularFile(file) & Files.isReadable(file) & Files.isExecutable(file);

When symbolic paths exists, 2 paths maybe direct to same file, use isSameFile(p1,p2) to compare.

 Path p1 = ...;
 Path p2 = ...;
 if (Files.isSameFile(p1,p2)){
  //Code when 2 paths locate the same file
 }

Delete a file/dir: deleteIfExists(path)

 try{
     Files.delete(path);
 }catch(NoSuchFileException x){
     System.err.format("%s: no such " + "file or dir%n", path);
 }catch(DirectoryNotEmptyException x){
     System.err.format("%s not empty%n",path);
 }catch(IOException x){
     //File permissions problems are caught here.
     System.err.println(x);
 }

Copy a file/dir: Copy files may fail when target file exists, unless the REPLACE_EXISTING option is spec. Directory can be copied, but not with files inside it. When copy a symbolic link, the target of the link is copied, not the link. And if need to copy the link, spec. either NOFOLLOW_LINKS or REPLACE_EXISTING option. This method takes a varargs argument. 3 options are supported:

1. REPLACE_EXISTING: if dir not empty, copy fails with FileAlreadyExistsException
2. COPY_ATTRIBUTES: attributes are OS-spec. however, last-modified-time is across platform supported
3. NOFOLLOW_LINKS

 //import static methods from package
 import static java.nio.file.StandardCopyOption.*;
 ...
 Files.copy(src,dest,Options...);

in addition to file copy, copy method can also be used to copy between file & stream.  Usage: copy(InputStream, Path, Options...) & copy(Path, OutputStream).

See this method to support copy recursively.

Move a file/dir: move(path, path, option...) fails if target exists, unless REPLACE_EXISTING spec. Empty dir can be moved, on UNIX systems, moving a dir is equaling to renaming a dir, in that circumstances, non-empty dir can be moved, too. Options:

1. REPLACE_EXISTING: if target is symbolic link, the target is replaced without affecting the link it points to
2. ATOMIC_MOVE: move as an atomic file operation, if OS does not support atomic move, throw exception. This option guarantees that any other process watching the directory the file will be moved to should access and get a complete file.

 //import static methods from package
 import static java.nio.file.StandardCopyOption.*;
 ...
 File.move(src,dest,REPLACE_EXISTING);

Metadata: what is metadata? "Data about other data". In OS, data is contained in files/dirs, so the metadata tracks info about each of the objects: is it a regular file, a dir or a link? Size, cdate, lmdate, owner, accpermissions?

readAttributes(path, String, Option); readAttributes(path, Class<A>, Option);

 //using the BasicFileAttributes class to retrive file attributes
 Path file = ...;
 BasicFileAttributes attr = Files.readAttributes(file, BasicFileAttributes.class);
 System.out.println(attr.creationTime() + attr.lastAccessTime() +
     attr.lastModifiedTime() + attr.isDirectory() + attr.isOther() +
     attr.isRegularFile() + attr.isSymbolicLink() + attr.size());

Set the FileTime:

 Path file = ...;
 BasicFileAttributes attr =
     Files.readAttributes(file, BasicFileAttributes.class);
 long currentTime = System.currentTimeMillis();
 FileTime ft = FileTime.fromMillis(currentTime);
 Files.setLastModifiedTime(file, ft);

Create Dirs:

 //createDirectory(path, FileAttribute<?>)
 Path dir = ...;
 Files.createDirectory(dir);
 //way to set permission
 Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-x---");
 FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(perms);
 Files.createDirectory(file, attr);

List all root dirs of filesystem:

 Iterable<Path> dirs = FileSystems.getDefault().getRootDirectories();
 for (Path name:dirs){
     System.err.println(name);
 }

List contents in Dir:

Usage: newDirectoryStream(path), return an object that implements DirectoryStream interface, this interface implements Iterable, so iterate through the directory stream, behaves well even in large directories.

 Path dir = ...;
 try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir)){
     for(Path file:stream){
         System.out.println(file.getFileName);
     }
 }catch(IOException | DirectoryIteratorException x){
     //IOException can never be thrown by this iteration.
     //In this snippet, it can only be thrown by newDirectoryStream.
     System.out.println(x);
 }

 //file filter
 DirectoryStream<Path> stream = Files.newDirectoryStream(dir, *.{java,jar});

 //using DirectoryStream.Filter<T>, rewrite accept(), anonyinter class
 DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>(){
     Public boolean accept(Path file) throws IOException{
         try{
             return (Files.isDirectory(file);
         }catch (IOException x){
             //Failed to determine it's a directory
             System.err.println(x);
             return false;
         }
     }
 };

 DirectoryStream<Path> stream = Files.newDirectoryStream(dir, filter);

Path Class & File Class conversion:

 Path path = Paths.get("1.txt");
 //Convert a Path obj to File obj
 File file = path.toFile();
 file.getCanonicalFilePath();
 //Convert a File obj to Path obj
 path = file.toPath();
 path.getFileName();

About Links & Symbolics:

1. Symbolics: createSymbolicLink(link, target, attr);
2. Hard Link: createLink(link, target);
3. Use Files.isSymbolicLink(file) static method to determine. boolean
4. Use Files.readSymbolicLink(link) to find the target of link, return type Path, if not a symbolic link, throws a NotLinkException

Basic steps to implement a watch service:

1. Create a WatchService "watcher" for file system
2. For each directory need monitoring, register with watcher, spec. the type of events wanted, receive a WatchKey instance for each dir registered
3. implement an infinite loop to wait for incoming events, if triggered, key is signaled & placed into the watcher's queue
4. Retrieve the key from queue, obtain the file name wanted from key
5. Retrieve each pending event for the key (there might be multiple events) & process
6. reset key, resume waiting
7. Close service if no long needed by exit the thread or when it's .closed()

 //use the newWatchService() method in FileSystem class
 WatchService watcher = FileSystems.getDefault().newWatchService();
 //Any obj implements Watchable interface can be registered, include Path class
 //Path class implements 2 register methods, choose one, the other takes a
 //WatchEvent.Modifier. Choose the types to be monitored, supported
 //StandardWatchEventKinds:
 //ENTRY_CREATE
 //ENTRY_DELETE
 //ENTRY_MODIFY
 //OVERFLOW - indicate the event have been lost or discarded, do not have to indicate this identifier to receive it.
 //register a path instance for all three types:
 import static java.nio.file.StandardWatchEventKinds.*;

 Path dir = ...;
 try{
     WatchKey key = dir.register(watcher,
         ENTRY_CREATE,
         ENTRY_MODIFY,
         ENTRY_DELETE);
 }catch (IOException x){
     System.err.println(x);
 }

Usage of WatchService API:

• watcher.poll()
• watcher.poll(long,TimeUnit)
• watcher.take()
• key.pollEvents(): fetch a list of WatchEvents(StandardWatchEventKinds)
• (WatchEvent<?> event.kind()): get exactly the kind type, can be compared
• (WatchEvent<Path> event).context(): return the filename related to signal
• key.reset(): exit loop if this method returns false, prepare the key to be signaled again

 for (;;) {

     // wait for key to be signaled
     WatchKey key;
     try {
         key = watcher.take();
     } catch (InterruptedException x) {
         return;
     }

     for (WatchEvent<?> event: key.pollEvents()) {
         WatchEvent.Kind<?> kind = event.kind();

         // This key is registered only
         // for ENTRY_CREATE events,
         // but an OVERFLOW event can
         // occur regardless if events
         // are lost or discarded.
         if (kind == OVERFLOW) {
             continue;
         }

         // The filename is the
         // context of the event.
         WatchEvent<Path> ev = (WatchEvent<Path>)event;
         Path filename = ev.context();

         // Verify that the new
         //  file is a text file.
         try {
             // Resolve the filename against the directory.
             // If the filename is "test" and the directory is "foo",
             // the resolved name is "foo/test".
             Path child = dir.resolve(filename);
             if (!Files.probeContentType(child).equals("text/plain")) {
                 System.err.format("New file '%s'" +
                     " is not a plain text file.%n", filename);
                 continue;
             }
         } catch (IOException x) {
             System.err.println(x);
             continue;
         }

         // Email the file to the
         //  specified email alias.
         System.out.format("Emailing file %s%n", filename);
         //Details left to reader....
     }

     // Reset the key -- this step is critical if you want to
     // receive further watch events.  If the key is no longer valid,
     // the directory is inaccessible so exit the loop.
     boolean valid = key.reset();
     if (!valid) {
         break;
     }
 }

How to suppress warning of known safe operations?

 //Create a method that do the operation and suppress certain type of warning
 @SuppressWarnings("unchecked")
 static <T> WatchEvent<T> cast(WatchEvent<?> event){
     return (WatchEvent<Path>)event;
 }

Always ok to use this API WatchService, if filesystem support file change notif, API takes advantage of it, if do not support, API will poll the filesystem itself, waiting for changes.

The Files.probeContentType determined by the platform's default file type detector. In windows, the detector might determine a file content to be application/x-java based on the .class extension. That may go wrong. So if needed, custom a FileTypeDetector.

Default File System: use FileSystems.getDefault() to retrieve the default file system.

Path String Separator: To get the default file path separator of file system, use FileSystems.getDefault().getSeparator() or File.separator.

File Stores/Root Dirs: use FileSystems.getDefault().getFileStores(), FileSystems.getDefault().getRootDirectories(), Iterable<FileStore>|Iterable<Path>. return a file's root by: Files.getFileStore(path) | path.getRoot()

java.nio.file package:

• Path class: manipulating a path
• Files class: file modification, attr related
• FileSystem: info about file system