NIO Paths工具对文件操作

Path—路径操作
Path类定义了路径操作的功能。Java1.7为了向后兼容，在传统IOjava.io.File类中添加了File.toPath方法用于将File对象转成Path。
同样的java.nio.file.Path中也定义了一个Path.toFile方法向前兼容


为了平台的无关性，Java提供了一个Paths工厂类让不同平台的JDK创建对应的Path对象。

使用Paths工具类创建Path对象

Paths类只有两个方法，实现也很简单：

public final class Paths {
    private Paths() { }
    // 通过FileSystem根据字符串构建Path对象
    public static Path get(String first, String... more) {
        return FileSystems.getDefault().getPath(first, more);
    }
    // 通过FileSystem根据URI构建Path对象
    public static Path get(URI uri) {
        String scheme =  uri.getScheme();
        if (scheme == null)
            throw new IllegalArgumentException("Missing scheme");
        // check for default provider to avoid loading of installed providers
        if (scheme.equalsIgnoreCase("file"))
            return FileSystems.getDefault().provider().getPath(uri);
        // try to find provider
        for (FileSystemProvider provider: FileSystemProvider.installedProviders()) {
            if (provider.getScheme().equalsIgnoreCase(scheme)) {
                return provider.getPath(uri);
            }
        }
        throw new FileSystemNotFoundException("Provider \"" + scheme + "\" not installed");
    }
}

1. 简单路径操作(字符操作)

Path路径本质上就是一个字符串，在没有访问文件系统之前，大部分操作只是进行字符串的操作。

// 判断路径是否为绝对路径
boolean isAbsolute();
// 该路径对应的根路径(如果根路径不存在会返回null)
Path getRoot();
// 获取该路径的对应的文件(或文件夹)的名字
Path getFileName();
// 获取父路径
Path getParent();
// 获取路径中文件夹名(或文件名)的个数
int getNameCount();
// 根据索引获取路径中的文件夹名(或文件名)
Path getName(int index);
// 根据索引范围获取子路径
Path subpath(int beginIndex, int endIndex);
// 判断当前路径是否以other路径作为开头
boolean startsWith(Path other);
// 判断当前路径是否以other字符串开头
boolean startsWith(String other);
// 判断当前路径是否以other路径结尾
boolean endsWith(Path other);
// 判断当前路径是否以other字符串结尾
boolean endsWith(String other);
// 将路径名常规化去除冗余：去掉中间出现的“..”代表的上级目录，“.”代表的当前目录
// 相当于File类中的getCanonicalPath方法
Path normalize();
// 如果原路径是相对路径则将路径转为绝对路径
Path toAbsolutePath();

示例：

public static void main(String[] args) {
   Path[] paths = {
      Paths.get(URI.create("file:///D:/dir/test.txt")), // URI路径
      Paths.get("D:/dir/test.txt"),                     // 正常路径
      Paths.get("D:/dir/../dir/test.txt"),              // 冗余路径
      Paths.get("../dir/test.txt")                      // 相对路径
   };
   for (Path path : paths) {
      System.out.println("-------" + path.toString() + "-------");
      System.out.println("normalize: " + path.normalize());
      System.out.println("getFileName: " + path.getFileName());
      System.out.println("getParent: " + path.getParent());
      System.out.println("getRoot: " + path.getRoot());
      System.out.println("isAbsolute: " + path.isAbsolute());
      System.out.println("toAbsolutePath: " + path.toAbsolutePath());
      int nameCount = path.getNameCount();
      System.out.println("getNameCount: " + nameCount);
      System.out.println("subpath(0, NameCount): " + path.subpath(0, nameCount));
      // 两种子路径名迭代方式
      for (int i = 0; i < nameCount; i++) {
         System.out.println("count-" + i + ": " + path.getName(i));
      }
      for (Path sub : path) {
         System.out.println("iterate subpath: " + sub);
      }
   }
}

运行结果：

-------D:\dir\test.txt-------    # URI构造路径
normalize: D:\dir\test.txt
getFileName: test.txt
getParent: D:\dir
getRoot: D:\
isAbsolute: true
toAbsolutePath: D:\dir\test.txt
getNameCount: 2
subpath(0, NameCount): dir\test.txt
count-0: dir
count-1: test.txt
iterate subpath: dir
iterate subpath: test.txt
-------D:\dir\test.txt-------    # 正常路径
normalize: D:\dir\test.txt
getFileName: test.txt
getParent: D:\dir
getRoot: D:\
isAbsolute: true
toAbsolutePath: D:\dir\test.txt
getNameCount: 2
subpath(0, NameCount): dir\test.txt
count-0: dir
count-1: test.txt
iterate subpath: dir
iterate subpath: test.txt
-------D:\dir\..\dir\test.txt-------    # 冗余路径
normalize: D:\dir\test.txt
getFileName: test.txt
getParent: D:\dir\..\dir
getRoot: D:\
isAbsolute: true
toAbsolutePath: D:\dir\..\dir\test.txt
getNameCount: 4
subpath(0, NameCount): dir\..\dir\test.txt
count-0: dir
count-1: ..
count-2: dir
count-3: test.txt
iterate subpath: dir
iterate subpath: ..
iterate subpath: dir
iterate subpath: test.txt
-------..\dir\test.txt-------    # 相对路径
normalize: ..\dir\test.txt
getFileName: test.txt
getParent: ..\dir
getRoot: null
isAbsolute: false
toAbsolutePath: D:\java\Apache Commons\commons-io2.5\..\dir\test.txt
getNameCount: 3
subpath(0, NameCount): ..\dir\test.txt
count-0: ..
count-1: dir
count-2: test.txt
iterate subpath: ..
iterate subpath: dir
iterate subpath: test.txt

2. 路径的解析与处理

// 根据当前路径解析other路径
// 如果other为绝对路径则直接返回other,如果other为空路径则返回this
// 否则根据当前路径解析other路径,
// 比如:当前路径为"foo/bar",other为"gus",返回"foo/bar/gus"
Path resolve(Path other);
Path resolve(String other);
// 构造兄弟路径,即根据当前路径的父路径构造other的兄弟路径
// 比如当前路径为"/a/b",other为"c",构造得到兄弟路径"/a/c"
Path resolveSibling(Path other);
Path resolveSibling(String other);
// 根据当前路径构造other的相对路径
// 比如当前路径为"/a/b",other为"/a/b/c/d",构造得到相对路径"/c/d"
Path relativize(Path other);
// 返回一个已存在的文件的路径(文件不存在会抛IO异常)
Path toRealPath(LinkOption... options) throws IOException;
// 将路径转成URI
URI toUri();
// 返回该路径对应的File对象(File类中也有一个toPath方法与之相对应)
File toFile();

示例：

public static void main(String[] args) {
   Path path = Paths.get("D:/a/b");
   System.out.println(path.resolve(Paths.get("c")));
   System.out.println(path.resolveSibling(Paths.get("c")));
   System.out.println(path.relativize(Paths.get("D:/a/b/c")));
}

运行结果：

D:\a\b\c
D:\a\c
c

3. 路径(文件或目录)的监测

// 注册一个监听器观察路径对应的文件或目录是否有事件(创建,删除,修改)
WatchKey register(WatchService watcher,
                  WatchEvent.Kind<?>[] events,
                  WatchEvent.Modifier... modifiers)
        throws IOException;
WatchKey register(WatchService watcher,
                      WatchEvent.Kind<?>... events)
        throws IOException;

例子：

public class PathTest {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("D:/");
        WatchService watcher = FileSystems.getDefault().newWatchService();
        // 如果"D:/"目录下有新文件创建,删除或修改操作都会被观测到
        WatchKey token = path.register(watcher,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);
        while (true) {
            List<WatchEvent<?>> pollEvents = token.pollEvents();
            for (WatchEvent<?> e : pollEvents) {
                System.out.println(e.kind().name());
            }
        }
    }
}