10.1　Java处理I/O的经典方式

10.1　Java处理I/O的经典方式

File 类是以前 Java 处理文件 I/O 的基础。这个抽象既能表示文件，也能表示目录，不过有时使用起来有些麻烦，写出的代码如下所示：

// 创建一个文件对象，表示用户的家目录
File homedir = new File(System.getProperty("user.home"));
// 创建一个对象，表示配置文件
// （家目录中应该存在这个文件）
File f = new File(homedir, "app.conf");
// 检查文件是否存在，是否真是文件，以及是否可读
if (f.exists() && f.isFile() && f.canRead()) {
  // 创建一个文件对象，表示新配置目录
  File configdir = new File(f, ".configdir");
  // 然后创建这个目录
  configdir.mkdir();
  // 最后，把配置文件移到新位置
  f.renameTo(new File(configdir, ".config"));
}

上述代码展现了 File 类使用灵活的一面，但也演示了这种抽象带来的一些问题。一般情况下，需要调用很多方法查询 File 对象才能判断这个对象到底表示的是什么，以及具有什么能力。

10.1.1　文件

File 类中有相当多的方法，但根本没有直接提供一些基本功能（尤其是无法读取文件的内容）。

下述代码简要总结了 File 类中的方法：

// 权限管理
boolean canX = f.canExecute();
boolean canR = f.canRead();
boolean canW = f.canWrite();
boolean ok;
ok = f.setReadOnly();
ok = f.setExecutable(true);
ok = f.setReadable(true);
ok = f.setWritable(false);
// 使用不同的方式表示文件名
File absF = f.getAbsoluteFile();
File canF = f.getCanonicalFile();
String absName = f.getAbsolutePath();
String canName = f.getCanonicalPath();
String name = f.getName();
String pName = getParent();
URI fileURI = f.toURI(); // 创建文件路径的URI形式
// 文件的元数据
boolean exists = f.exists();
boolean isAbs = f.isAbsolute();
boolean isDir = f.isDirectory();
boolean isFile = f.isFile();
boolean isHidden = f.isHidden();
long modTime = f.lastModified(); // 距Epoch时间的毫秒数
boolean updateOK = f.setLastModified(updateTime); // 毫秒
long fileLen = f.length();
// 文件管理操作
boolean renamed = f.renameTo(destFile);
boolean deleted = f.delete();
// 创建文件不会覆盖现有文件
boolean createdOK = f.createNewFile();
// 处理临时文件
File tmp = File.createTempFile("my-tmp", ".tmp");
tmp.deleteOnExit();
// 处理目录
boolean createdDir = dir.mkdir();
String[] fileNames = dir.list();
File[] files = dir.listFiles();

File 类中还有一些方法不完全符合这种抽象。其中多数方法都要查询文件系统（例如，查询可用空间）：

long free, total, usable;
free = f.getFreeSpace();
total = f.getTotalSpace();
usable = f.getUsableSpace();
File[] roots = File.listRoots(); // 所有可用的文件系统根目录

10.1.2　流

I/O 流抽象（不要跟 Java 8 集合 API 使用的流搞混了）出现在 Java 1.0 中，用于处理硬盘或其他源发出的连续字节流。

这个 API 的核心是一对抽象类，InputStream 和 OutputStream。这两个类使用广泛，事实上，“标准”输入和输出流（System.in 和 System.out）就是这种流。标准输入和输出流是 System 类的公开静态字段，在最简单的程序中也能用到：

System.out.println("Hello World!");

流的某些特定的子类，例如 FileInputStream 和 FileOutputStream，可以操作文件中单独的字节。例如，下述代码用于统计文件中 ASCII 97（小写的 a）出现的次数：

try (InputStream is = new FileInputStream("/Users/ben/cluster.txt")) {
  byte[] buf = new byte[4096];
  int len, count = 0;
  while ((len = is.read(buf)) > 0) {
    for (int i=0; i<len; i++)
      if (buf[i] == 97) count++;
  }
  System.out.println("'a's seen: "+ count);
} catch (IOException e) {
  e.printStackTrace();
}

使用这种方式处理硬盘中的数据缺乏灵活性，因为多数开发者习惯以字符而不是字节的方式思考问题。因此，这种流经常和高层的 Reader 和 Writer 类结合在一起使用。Reader 和 Writer 类处理的是字符流，而不是 InputStream 和 OutputStream 及其子类提供的低层字节流。

10.1.3　`Reader`和`Writer`类

把抽象从字节提升到字符后，开发者就更熟悉所面对的 API 了，而且这样也能规避很多由字符编码和 Unicode 等引起的问题。

Reader 和 Writer 类架构在字节流相关的类之上，无需再处理低层 I/O 流。这两个类有几个子类，往往都两两结合在一起使用，例如：

FileReader
BufferedReader
InputStreamReader
FileWriter
PrintWriter
BufferedWriter

若想读取一个文件中的所有行，并把这些行打印出来，可以在 FileReader 对象的基础上使用 BufferedReader 对象，如下述代码所示：

try (BufferedReader in =
  new BufferedReader(new FileReader(filename))) {
  String line;
  while((line = in.readLine()) != null) {
    System.out.println(line);
  }
} catch (IOException e) {
  // 这处理FileNotFoundException等异常
}

如果想从终端读取行，而不是文件，一般会在 System.in 对象上使用 InputStreamReader 对象。我们来看个例子，在这个示例中我们想从终端读取行，但特殊对待以特殊字符开头的行——这种行是要处理的命令（“元”），而不是普通文本。很多聊天程序，包括 IRC，都需要这种功能。这里，我们要借助第 9 章介绍的正则表达式：

Pattern SHELL_META_START = Pattern.compile("^#(\\w+)\\s*(\\w+)?");
try (BufferedReader console =
  new BufferedReader(new InputStreamReader(System.in))) {
  String line;
  READ: while((line = console.readLine()) != null) {
    // 检查特殊的命令
    Matcher m = SHELL_META_START.matcher(line);
    if (m.find()) {
      String metaName = m.group(1);
      String arg = m.group(2);
      doMeta(metaName, arg);
      continue READ;
    }
    System.out.println(line);
  }
} catch (IOException e) {
  // 这里处理FileNotFoundException等异常
}

若想把文本输出到文件中，可以使用如下代码：

File f = new File(System.getProperty("user.home")
 + File.separator + ".bashrc");
try (PrintWriter out
   = new PrintWriter(new BufferedWriter(new FileWriter(f)))) {
  out.println("## Automatically generated config file. DO NOT EDIT");
} catch (IOException iox) {
  // 处理异常
}

Java 处理 I/O 的旧风格中有些功能偶尔也有用。例如，处理文本文件时，FilterInputStream 类往往非常有用。对于想使用类似于经典“管道”I/O 方式通信的线程来说，Java 提供了 PipedInputStream 和 PipedReader 类，以及对应的写入器。

到目前为止，本章多次用到了一种语言特性——“处理资源的try 语句”（try-with-resources，TWR）。这种语句的句法在 2.5.18 节简单介绍过，但要结合 I/O 等操作才能充分发挥潜能，而且还给旧 I/O 风格带来了新生。

10.1.4　再次介绍TWR

为了充分发挥 Java 的 I/O 能力，一定要理解如何以及何时使用 TWR。何时使用很好确定，只要可以用就用。

在 TWR 出现之前，必须手动关闭资源，而且处理资源之间复杂交互的代码可能有缺陷，无法关闭资源，从而导致资源泄露。

事实上，根据甲骨文工程师的估计，在 JDK 6 的初始版本中，处理资源的代码有 60% 都不正确。因此，既然连平台的作者都无法完全正确地手动处理资源，那么所有新代码显然都应该使用 TWR。

实现 TWR 的关键是一个新接口——AutoCloseable。这个新接口（在 Java 7 中出现）是 Closeable 的直接超接口，表示资源必须自动关闭。为此，编译器会插入特殊的异常处理代码。

在 TWR 的资源子句中，只能声明实现了 AutoCloseable 接口的对象，而且数量不限：

try (BufferedReader in = new BufferedReader(
                           new FileReader("profile"));
     PrintWriter out = new PrintWriter(
                         new BufferedWriter(
                           new FileWriter("profile.bak")))) {
  String line;
  while((line = in.readLine()) != null) {
    out.println(line);
  }
} catch (IOException e) {
  // 这里处理FileNotFoundException等异常
}

这样写，资源的作用域就自动放入 try 块中，各个资源（不管是可读的还是可写的）会按照正确的顺序自动关闭，而且编译器插入的异常处理代码会考虑到资源之间的相互依赖关系。

TWR 的作用大致和 C# 的 using 关键字类似，开发者可以把 TWR 看成“正确的终结方式”。6.4 节说过，新代码绝对不能直接使用终结机制，而一定要使用 TWR。旧代码应该根据情况尽早重构，换用 TWR。

10.1.5　I/O经典处理方式的问题

即便添加了受欢迎的 TWR，File 及相关的类还是有一些问题，就算执行标准的 I/O 操作也不理想，无法广泛使用。例如：

缺少处理常见操作的方法；
在不同的平台中不能使用一致的方式处理文件名；
没有统一的文件属性模型（例如，读写模型）；
难以遍历未知的目录结构；
没有平台或操作系统专用的特性；
不支持使用非阻塞方式处理文件系统。

为了改善这些缺点，Java 的 I/O API 在过去的几个主版本中一直在改进。直到 Java 7，处理 I/O 才真正变得简单而高效。

10.1 Java处理I/O的经典方式