这些年一直记不住的 Java I/O
FanCastle
8年前
<h2><strong>前言</strong></h2> <p>不知道大家看到这个标题会不会笑我，一个使用 Java 多年的老程序员居然一直没有记住 Java 中的 I/O。不过说实话，Java 中的 I/O 确实含有太多的类、接口和抽象类，而每个类又有好几种不同的构造函数，而且在 Java 的 I/O 中又广泛使用了 Decorator 设计模式（装饰者模式）。总之，即使是在 OO 领域浸淫多年的老手，看到下面这样的调用一样会蛋疼：</p> <pre> <code class="language-java">BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("somefile.txt")));</code></pre> <p>当然，这仅仅只是我为了体现 Java I/O 的错综复杂的构造函数而虚构出来的一个例子，现实中创建一个 BufferedReader 很少会嵌套这么深，因为可以直接使用 FileReader 而避免多创建一个 FileInputStream。但是从一个 InputStream 转化成一个 BufferedReader 总是有那么几步路要走的，比如下面这个例子：</p> <pre> <code class="language-java">URL cnblogs = new URL("http://www.cnblogs.com/"); BufferedReader reader = new BufferedReader(new InputStreamReader(cnblogs.openStream()));</code></pre> <p>Java I/O 涉及到的类也确实特别多，不仅有分别用于操作字符流和字节流的 InputStream 和 Reader、OutputStream 和 Writer，还有什么 BufferedInputStream、BufferedReader、PrintWriter、PrintStream等，还有用于沟通字节流和字符流的桥梁 InputStreamReader 和 OutputStreamWriter，每一个类都有其不同的应用场景，如此细致的划分，光是名字就足够让人晕头转向了。</p> <p>我一直记不住 Java I/O 中各种细节的另一个原因可能是我深受 ANSI C 的荼毒吧。在 C 语言的标准库中，将文件的打开方式分为两种，一种是将文件当成二进制格式打开，一种是当成文本格式打开。这和 Java 中的字节流和字符流的划分有相似之处，但却掩盖了所有的数据其实都是字节流这样的本质。ANSI C 用多了，总以为二进制格式和文本格式是同一个层面的两种对立面，只能对立而不能统一，却不知在 Java 中，字符流是对字节流的更高层次的封装，最底层的 I/O 都是建立在字节流的基础上的。如果抛开 ANSI C 语言的标准 I/O 库，直接考察操作系统层面的 POSIX I/O，会发现操作的一切都是原始的字节数据，根本没有什么字节字符的区别。</p> <p>除此之外，Java 走得更远，它考虑到了各种更加广泛的字节流，而不仅仅限于文件。比如网络中传输的数据、内存中传输的对象等等，都可以用流来抽象。但是不同的流具有不同的特性，有的流可以随机访问，而有的却只能顺序访问，有的可以解释为字符，有的不能。在能解释为字符的流中，有的一次只能访问一个字符，有的却可以一次访问一行，而且把字节流解释成字符流，还要考虑到字符编码的问题。</p> <p>以上种种，均是造成 Java I/O 中类和接口多、对象构造方式复杂的原因。</p> <h2><strong>从对立到统一，字节流和字符流</strong></h2> <p>先来说对立。在 Java 中如果要把流中的数据按字节来访问，就应该使用 InputStream 和 OutputStream，如果要把流中的数据按字符来访问，就应该使用 Reader 和 Writer。上面提到的这四个类都是抽象类，是所有其它具体类的基础。不能直接构造 InputStream、OutputStream、Reader 和 Writer 类的实例，但是根据 OO 原则，可以这样用：</p> <pre> <code class="language-java">InputStream in = new FileInputStream("somefile"); int c = in.read();</code></pre> <p>或者这样：</p> <pre> <code class="language-java">Reader reader = new FileReader("somefile"); int c = reader.read();</code></pre> <p>这里的 FileInputStream 和 FileReader 就是具体的类，这样的类还有很多，都位于 java.io 包中。文件读写是我们最常用的操作，所以最常用的就是 FileInputStream、FileOutputStream、FileReader、FileWriter这四个。这几个类的构造函数有多个，但是最简单的，肯定是接受一个代表文件路径的字符串做参数的那一个。根据 OO 原则，我们一般使用更加抽象的 InputStream、OutputStream、Reader、Writer 来引用具体的对象。所以，在考察 API 的时候，只需要考察这四个抽象类就可以了，其它的具体类，基本上只需要考察它们的构造方式。</p> <p>而这几个类的 API 也确实很好记，用来输入的两个类 InputStream 和 Reader 主要定义了 read() 方法，而用来输出的两个类 OutputStream 和 Writer 主要定义了 write() 方法。所不同者，前者操作的是字节，后者操作的是字符。 read() 和 write() 最简单的用法是这样的：</p> <pre> <code class="language-java">package com.xkland.sample; import java.io.InputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.FileNotFoundException; public class JavaIODemo { public static void main(String[] args) { if(args.length < 1){ System.out.println("Usage: JavaIODemo filename"); return; } String somefile = args[0]; InputStream in = null; try{ in = new FileInputStream(somefile); int c; while((c = in.read()) != -1) { //这里用到read() System.out.write(c); //这里用到write() } }catch(FileNotFoundException e){ System.out.println("File not found."); }catch(IOException e){ System.out.println("I/O failed."); }finally{ if(in != null){ try { in.close(); }catch(IOException e){ //关闭流时产生的异常，直接抛弃 } } } } }</code></pre> <p>上面的例子展示了 read() 和 write() 的用法，在 InputStream 和 OutputStream 中，这两个方法操作的都是字节，但是，这里用来保存这个字节的变量却是 int 类型的。这正是 API 设计的匠心所在，因为 int 的宽度明显比 byte 要大，所以将一个 byte 读入到一个 int 之后，有效的数据只占据 int 型变量的最低8位，如果 read() 方法返回的是有效数据，那么这个 int 型的变量永远都不可能是负数。在这种情况下， read() 方法可以用返回负数的方式来表示碰到特殊情况，比如返回 -1 表示到达了流的末尾，也就是用 -1 代表 EOF 。 write() 方法接受的参数也是 int 型的，但是它只把这个 int 型变量的最低8位写入流，其余的数据被忽略。</p> <p>上面的例子还展示了 Java I/O 的一些特征：</p> <ol> <li>InputStream、OutputStream、Reader、Writer 等资源用完之后要关闭；</li> <li>所有的 I/O 操作都可能产生异常，包括调用 close() 方法。</li> </ol> <p>这两个特征搅到一起就比较复杂了，本来因为异常的产生就容易让流的 close() 语句执行不到，所以只有把 close() 写到 finally 块中，但是在 finally 块中调用 close() 又要写一层 try...catch... 代码块。如果同时有多个流需要关闭，而前面的 close() 抛出异常，则后面的 close() 将不会执行，极易发生资源泄露。再加上如果前面的 catch() 块中的异常被重新抛出，而 finally 块中又没有处理好异常的话，前面的异常会被抑制，所以大部分人都 hold 不住这样的代码，包括 Oracle 的官方教程中的写法都是错误的。下面来看一下 Oracle 官方教程中的例子：</p> <pre> <code class="language-java">import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class CopyBytes { public static void main(String[] args) throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("xanadu.txt"); out = new FileOutputStream("outagain.txt"); int c; while ((c = in.read()) != -1) { out.write(c); } } finally { if (in != null) { in.close(); } if (out != null) { out.close(); } } } }</code></pre> <p>官方教程写得比我更偷懒，它直接让 main() 方法抛出 IOException 而避免了异常处理，也避免了在 finally 块中的 close() 语句外再写一层 try...catch... 。但是，这个示例的漏洞有两个，其一是如果 in.close() 抛出了异常，则 out.close() 就不会执行；其二是如果 try 块中抛出了异常， finally 块中又抛出了异常，则前面抛出的异常会被丢弃。为了解决这个问题，Java 7中新加入了 try-with-resource 语法。后面都用这种方式写代码。</p> <p>很显然，一次处理一个字节效率是及其低下的，所以 read() 和 write() 还有别的重载版本：</p> <pre> <code class="language-java">int read(byte[] b) int read(byte[] b, int off, int len) void write(byte[] b) void write(byte[] b, int off, int len)</code></pre> <p>它们都可以一次操作一块数据，用字节数组做为存储数据的容器。 read() 返回的是实际读取的字节数。而对于 Reader 和 Writer，它们的 read() 和 write() 方法的定义是这样的：</p> <pre> <code class="language-java">int read() int read(char[] cbuf) int read(char[] cbuf, int off, int len) void write(int c) void write(char[] cbuf) void write(char[] cbuf, int off, int len) void write(String str) void write(String str, int off, int len)</code></pre> <p>可以看出，使用 Reader 和 Writer 一次操作一个字符的时候，依然使用的是 int 型的变量。如果一次操作一块数据，则使用字符数组。输出的时候，还可以直接使用字符串。</p> <p>到这里，已经可以很轻易记住八个类了：InputStream、OutputStream、Reader、Writer、FileInputStream、FileOutputStream、FileReader、FileWriter。前四个是抽象类，后四个是操作文件的具体类。而且这八个类分成两组，一组操作字节流，一组操作字符流。很简单的对立分组。</p> <p>然而，前面我提到过，其实字节流和字符流并不是完全对立的存在，其实字符流是在字节流上更高层次的封装。在底层，一切数据都是字节，但是经过适当的封装，可以把这些字节解释成字符。而且，并不是所有的 Reader 都是可以像 FileReader 那样直接创建的，有时，只能拿到一个可以读取字节数据的 InputStream，却需要在它之上封装出一个 Reader，以方便按字符的方式读取数据。最典型的例子就是可以这样访问一个网页：</p> <pre> <code class="language-java">URL cnblogs = new URL("http://www.cnblogs.com/"); InputStream in = cnblogs.openStream();</code></pre> <p>这时，拿到的是字节流 InputStream，如果想获得按字符读取数据的 Reader，可以这样创建：</p> <pre> <code class="language-java">Reader reader = new InputStreamReader(in);</code></pre> <p>所以， InputStreamReader 是沟通字节流和字符流的桥梁。同样的桥梁还用用于输出的 OutputStreamWriter。至此，不仅又轻松地记住了两个类，也再次证明了字节流和字符流既对立又统一的辩证关系。</p> <h2><strong>从抽象到具体，数据的来源和目的</strong></h2> <p>InputStream、OutputStream、Reader 和 Writer 是抽象的，根据不同的数据来源和目的又有不同的具体类。前面的例子中提到了基于 File 的流，也初步展示了一个基于网络的流。结合平时使用计算机的经验，我们也可以想到其它一些不同的数据来源和目的，比如从内存中读取字节或把字节写入内存，从字符串中读取字符或者把字符写入字符串等等，还有从管道中读取数据和向管道中写入数据等等。根据不同的数据来源和目的，可以有这样一些具体类：FileInputStream、ByteArrayInputStream、PipedInputStream、FileOutputStream、ByteArrayOutputStream、PipedOutputStream、FileReader、StringReader、CharArrayReader、PipedReader、FileWriter、StringWriter、CharArrayWriter、PipedWriter等。从这些类的命名可以看出，凡是以Stream结尾的，都是操作字节的流，凡是以 Reader 和 Writer 结尾的，都是操作字符的流。只有 InputStreamReader 和 OutputStreamWriter 是例外，它是沟通字节和字符的桥梁。对于这些具体类，使用起来是没有什么困难的，只需要考察它们的构造函数就可以了。下面两幅 UML 类图可以展示这些类的关系。</p> <p>InputStreams 和 Readers：</p> <p style="text-align: center;"><img src="https://simg.open-open.com/show/85c143292a897e10c9111448bc89f22d.png"></p> <p>OutputStreams 和 Writers：</p> <p style="text-align: center;"><img src="https://simg.open-open.com/show/3837b777c50999d5ad1efdff363adff6.png"></p> <h2><strong>从简单到丰富，使用 Decorator 模式扩展功能</strong></h2> <p>从前文可以看出，所有的流都支持 read() 和 write() ，但是这样的功能毕竟还是太简单，有时还需要更高层次的功能需求，所以需要使用 Decorator 模式来对流进行扩展。比如，一次操作一个字节或一个字符效率太低，想把数据先缓存在内存中再进行操作，就可以扩展出 BufferedInputStream、BufferedReader、BufferedOutputStream、BufferedWriter 类。可以猜测到，BufferedOutputStream 和 BufferedWriter 类中一定有一个 flush() 方法，用来把缓存的数据写入到流中。而且，BufferedReader 还有 readLine() 方法，可以一次读取一行字符，甚至可以再扩展出一个 LineNumberReader，还可以提供行号的支持。再比如，有时从流中读出一个字节或一个字符后，又不想要了，想把它还回去，就可以再扩展出 PushbackInputStream 和 PushbackReader，提供 unread() 方法将刚读取的字节或字符还回去。可以想象，这种还回去的功能应该是需要缓存功能支持的，所以它们应该是在 BufferedInputStream 和 BufferedReader 外面又加了一层的装饰。这就是 Decorator 模式。</p> <p>Java I/O 中自带的这种扩展类还有很多，不容易记。后面的介绍中，会针对重要的类举几个例子。在此之前，还是通过 UML 类图来了解一下扩展类。</p> <p>从 InputStream 扩展的类：</p> <p style="text-align:center"><img src="https://simg.open-open.com/show/e5441ca182a12bf9b8bee136002a8654.png"></p> <p>从 Reader 扩展的类：</p> <p style="text-align: center;"><img src="https://simg.open-open.com/show/6d595e4b00aedb74ba7cdb0e0b7f3e62.png"></p> <p>从 OutputStream 扩展的类：</p> <p style="text-align: center;"><img src="https://simg.open-open.com/show/0786370701a58b4c1fc43aad69b3fac7.png"></p> <p>从 Writer 扩展的类：</p> <p><img src="https://simg.open-open.com/show/cdcc0df1c4006a94f57bfb0ea9ba420b.png"></p> <p>从上图中可以看到，每一个分组中扩展的类的数量是不一样的，再也不是一种对称的关系。仔细一想也很好理解，例如 Pushback 这样的功能就只能用在输入流 InputStream 和 Reader 上，而向输出流中写入数据就像泼出去的水，没办法再 Pushback 了。再例如，向流中写入对象和读取对象，操作的肯定是字节流而不是字符流，所以只有 ObjectInputStream 和 ObjectOutputStream，而没有相应的 Reader 和 Writer 版本。再例如打印，操作的肯定是输出流，所以只有 PrintStream 和 PrintWriter，没有相应的输入流版本，这没有什么好奇怪的。</p> <p>在这些类中，可以通过 PrintStream 和 PrintWriter 向流中写入格式化的文本，也可以通过 DataInputStream 和 DataOutputStream 从流中读取或向流中写入原始的数据，还可以通过 ObjectInputStream 和 ObjectOutputStream 从流中读取或写入一个完整的对象。如果要从流中读取格式化的文本，就必须使用 java.util.Scanner 类了。</p> <p>下面先看一个简单的示例，使用 DataOutputStream 的 writeInt() 、 writeDouble() 以及 writeUTF() 方法将 int 、 double 、 String 类型的数据写入流中，然后再使用 DataInputStream 的 readInt() 、 readDouble() 、 readUTF() 方法从流中读取 int 、 double 、 String 类型的数据。为了简单起见，就使用基于文件的流作为存储数据的方式。代码如下：</p> <pre> <code class="language-java">package com.xkland.sample; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.EOFException; public class DataStreamsDemo { public static void writeToFile(String filename){ double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 }; int[] units = { 12, 8, 13, 29, 50 }; String[] descs = { "Java T-shirt", "Java Mug", "Duke Juggling Dolls", "Java Pin", "Java Key Chain" }; try(DataOutputStream out = new DataOutputStream( new BufferedOutputStream( new FileOutputStream(filename)))){ for (int i = 0; i < prices.length; i ++) { out.writeDouble(prices[i]); out.writeInt(units[i]); out.writeUTF(descs[i]); } }catch(IOException e){ System.out.println(e.getMessage()); } } public static void readFromFile(String filename){ double price; int unit; String desc; double total = 0.0; try(DataInputStream in = new DataInputStream( new BufferedInputStream( new FileInputStream(filename)))){ while (true) { price = in.readDouble(); unit = in.readInt(); desc = in.readUTF(); System.out.format("You ordered %d" + " units of %s at $%.2f%n", unit, desc, price); total += unit * price; } }catch(EOFException e){ //达到文件末尾 System.out.format("所有数据已读入，总价格为：$%.2f%n", total); }catch(IOException e){ System.out.println(e.getMessage()); } } }</code></pre> <p>然后在 main() 方法中这样调用：</p> <pre> <code class="language-java">package com.xkland.sample; public class JavaIODemo { public static void main(String[] args) { if(args.length < 1){ System.out.println("Usage: JavaIODemo filename"); return; } //向文件中写入数据 DataStreamsDemo.writeToFile(args[0]); //从文件中读取数据并显示 DataStreamsDemo.readFromFile(args[0]); } }</code></pre> <p>然后这样运行该程序：</p> <pre> <code class="language-java">java com.xkland.sample.JavaIODemo /home/youxia/testfile</code></pre> <p>最后输出是这样：</p> <pre> <code class="language-java">You ordered 12 units of Java T-shirt at $19.99 You ordered 8 units of Java Mug at $9.99 You ordered 13 units of Duke Juggling Dolls at $15.99 You ordered 29 units of Java Pin at $3.99 You ordered 50 units of Java Key Chain at $4.99 所有数据已读入，总价格为：$892.88</code></pre> <p>如果使用 cat 命令查看 /home/youxia/testfile 文件的内容，只会看到一堆乱码，说明该文件是以二进制格式存储的。如下：</p> <pre> <code class="language-java">youxia@ubuntu:~$cat testfile @3�p�� = Duke Juggling Dolls@�� �Q�Java Pin@�\(�2Java Key Chain</code></pre> <p>上面的代码展示了 DataInputStream 和 DataOutputStream 的用法，通过前面的探讨，对它们这样层层包装的构造方式已经见怪不怪了。并且在示例代码中使用了 Java 7 中新引入的 try-with-resource 语法，这样大大减少了代码的复杂度，所有打开的流都可以自动关闭，而且异常处理也更简洁。从代码中还可以看到，需要捕获 DataInputStream 的 EOFException 异常才能判断读取到了文件结尾。另外，使用这种方式写入和读取数据要非常小心，写入数据的顺序和读取数据的顺序一定要保持一致，如果先写一个 int ，再写一个 double ，则一定要先读一个 int ，再读一个 double ，否则只会读取错误的数据。不信可以通过修改上述示例代码中读取数据的顺序进行测试。</p> <p>使用 DataInputStream 和 DataOutputStream 只能写入和读取原始的数据类型的数据，如 byte 、 char 、 short 、 float 等，如果要读取和写入复杂的对象就不行了，比如 java.math.BigDecimal 。这个时候就需要使用 ObjectInputStream 和 ObjectOutputStream 了。所有需要写入流和从流读取的 Object 必须实现 Serializable 接口，然后调用 ObjectInputStream 和 ObjectOutputStream 的 writeObject() 方法和 readObject() 方法就可以了。而且很奇妙的是，如果一个 Object 中包含了其它的 Object 对象，则这些对象都会被写入到流中，而且能保持它们之间的引用关系。从流中读取对象的时候，这些对象也会同时被读入内存，并保持它们之间的引用关系。如果把同一批对象写入不同的流，再从这些流中读出，就会获得这些对象多个副本。这里就不举例了。</p> <p>与以二进制格式写入和读取数据相对的，就是以文本的方式写入和读取数据。PrintStream 和 PrintWriter 中的 Print 就是代表着输出能供人读取的数据。比如浮点数 3.14 可以输出为字符串 "3.14" 。利用 PrintStream 和 PrintWriter 中提供的大量 print() 方法和 println() 方法就可以做到这点，利用 format() 方法还可以进行更加复杂的格式化。把上面的例子做少量修改，如下：</p> <pre> <code class="language-java">package com.xkland.sample; import java.io.*; import java.util.Scanner; public class PrintStreamDemo { public static void writeToFile(String filename){ double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 }; int[] units = { 12, 8, 13, 29, 50 }; String[] descs = { "Java T-shirt", "Java Mug", "Duke Juggling Dolls", "Java Pin", "Java Key Chain" }; try(PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream(filename)))){ for (int i = 0; i < prices.length; i ++) { out.println(prices[i]); out.println(units[i]); out.println(descs[i]); } }catch(IOException e){ System.out.println(e.getMessage()); } } public static void readFromFile(String filename){ double price; int unit; String desc; double total = 0.0; try(Scanner s = new Scanner(new BufferedReader(new FileReader(filename)))){ s.useDelimiter("\n"); while (s.hasNext()) { price = s.nextDouble(); unit = s.nextInt(); desc = s.next(); System.out.format("You ordered %d" + " units of %s at $%.2f%n", unit, desc, price); total += unit * price; } System.out.format("所有数据已读入，总价格为：$%.2f%n", total); }catch(IOException e){ System.out.println(e.getMessage()); } } }</code></pre> <p>这时输出的数据和输入的数据都是经过良好格式化的，非常便于阅读和打印，但是在处理数据的时候需要进行适当的转换和解析，所以会一定程度上影响效率。在使用 java.util.Scanner 时，可以使用 useDelimiter() 方法设置合适的分隔符，在 Linux 系统中，空格、冒号、逗号都是常用的分隔符，具体情况具体分析。在上面的例子中，我直接将每个数据作为一行保存，这样更加简单。如果使用 cat 命令查看 /home/youxia/testfile 文件的内容，可以看到格式良好的数据，如下：</p> <pre> <code class="language-java">youxia@ubuntu:~$ cat testfile 19.99 12 Java T-shirt 9.99 8 Java Mug 15.99 13 Duke Juggling Dolls 3.99 29 Java Pin 4.99 50 Java Key Chain</code></pre> <p>如果不想使用流，只想像 C 语言那样简单地操作文件，可以使用 RandomAccessFile 类。</p> <p>对于 PrintStream 和 PrintWriter，我们用得最多的就是基于命令行的标准输入输出，也就是从键盘读入数据和向屏幕写入数据。Java 中有几个内建的对象，它们分别是 System.in、System.out、System.err，因为平时用得多，我就不一一细讲了。需要说明的是，这几个对象都是字节流而不是字符流，这也可以理解，虽然我们的键盘不能输入纯二进制数据，但是通过管道和文件重定向却可以，在控制台中输出乱码也是常见的现象，所以这几个流必须是字节流而不是字符流。如果要想按字符的方式读取标准输入，可以使用 InputStreamReader 这样转换一下：</p> <pre> <code class="language-java">InputStreamReader cin = new InputStreamReader(System.in);</code></pre> <p>除此之外，还可以使用 System.console 对象，它是 Console 类的一个实例。它提供了几个实用的方法来操作命令行，如 readLine() 、 readPassword() 等，它的操作是基于字符流的。不过在使用 System.console 之前，先要判断它是否存在，如果操作系统不支持或程序运行在一个没有命令行的环境中，则其值为 null 。</p> <h2><strong>Java 7 中引入的 NIO.2</strong></h2> <p>早在 2002 年发布的 Java 1.4 中就引入了所谓的 New I/O，也就是 NIO。但是依然被打脸， NIO 还是不那么好用，还白白浪费了 New 这个词，搞得 Java 7 中对 I/O 的改进不得不称为 NIO.2。在 Java 7 之前的 I/O 怎么不好用呢？主要表现在以下几点：</p> <ol> <li>在不同的操作系统中，对文件名的处理不一致；</li> <li>不方便对目录树进行遍历；</li> <li>不能处理符号链接；</li> <li>没有一致的文件属性模型，不能方便地访问文件的属性。</li> </ol> <p>所以，虽然存在 java.io.File 类，我前文中却没有介绍它。在 Java 7 中，引入了 Path、Paths、Files等类来对文件进行操作。Path 代表文件的路径，不同操作系统有不同的文件路径格式，而且还有绝对路径和相对路径之分。可以这样创建路径：</p> <pre> <code class="language-java">Path absolute = Paths.get("/", "home", "youxia"); Path relative = Paths.get("myprog", "conf", "user.properties");</code></pre> <p>静态方法 Paths.get() 可以接受一个或多个字符串，然后它将这些字符串用文件系统默认的路径分隔符连接起来。然后它对结果进行解析，如果结果在指定的文件系统上不是一个有效的路径，那么它会抛出一个 InvalidPathException 异常。当然，也可以给该方法传递一个含有分隔符的字符串：</p> <pre> <code class="language-java">Path home = Paths.get("/home/youxia");</code></pre> <p>Path 类提供很多有用的方法对路径进行操作。例如：</p> <pre> <code class="language-java">Path home = Paths.get("/home/youxia"); Path conf = Paths.get("myprog", "conf", "user.properties"); home.resolve(conf); // 返回"/home/youxia/myprog/conf/user.properties" Path another_home = Paths.get("/home/another"); home.relativize(another_home); //返回相对路径"../another" Paths.get("/home/youxia/../another/./myprog").normalize(); //去掉路径中冗余，返回"/home/another/myprog" conf.toAbsolutePath(); //根据程序的运行目录返回绝对路径，如过在用户的根目录中启动程序，则返回"/home/youxia/myprog/conf/user.properties" conf.getParent(); //获得路径的不含文件名的部分，返回"myprog/conf/" conf.getFileName(); //获得文件名，返回"user.properties" conf.getRoot(); //获得根目录</code></pre> <p>使用 Files 类可以快速实现一些常用的文件操作。例如，可以很容易地读取一个文件的全部内容：</p> <pre> <code class="language-java">byte[] bytes = Files.readAllBytes(path);</code></pre> <p>如果想将文件内容解释为字符串，可以在 readAllBytes 后调用：</p> <pre> <code class="language-java">String content = new String(bytes, StandardCharsets.UTF_8);</code></pre> <p>也可以按行来读取文件：</p> <pre> <code class="language-java">List<String> lines = Files.readAllLines(path);</code></pre> <p>反过来，将一个字符串写入文件：</p> <pre> <code class="language-java">Files.write(path, content.getBytes(StandardCharsets.UTF_8));</code></pre> <p>按行写入：</p> <pre> <code class="language-java">Files.write(path, lines);</code></pre> <p>将内容追加到指定文件中：</p> <pre> <code class="language-java">Files.write(path, lines, StandardOpenOption.APPEND);</code></pre> <p>当然，仍然可以使用前文介绍的 InputStream、OutputStream、Reader、Writer 类。这样创建它们：</p> <pre> <code class="language-java">InputStream in = Files.newInputStream(path); OutputStream out = Files.newOutputStream(path); Reader reader = Files.newBufferedReader(path); Writer in = Files.newBufferedWriter(path);</code></pre> <p>同时，使用 Files.copy() 方法，可以简化某些工作：</p> <pre> <code class="language-java">Files.copy(in, path); //将一个 InputStream 中的内容保存到一个文件中 Files.copy(path, out); //将一个文件的内容复制到一个 OutputStream 中</code></pre> <p>一些创建、删除、复制、移动文件和目录的操作：</p> <pre> <code class="language-java">Files.createDirectory(path); //创建一个新目录 Files.createFile(path); //创建一个空文件 Files.exists(path); //检测一个文件或目录是否存在 Files.createTempFile(prefix, suffix); //创建一个临时文件 Files.copy(fromPath, toPath); //复制一个文件 Files.move(fromPath, toPath); //移动一个文件 Files.delete(path); //删除一个文件</code></pre> <p>如果目标文件或目录存在的话， copy() 和 move() 方法会失败。如果希望覆盖一个已存在的文件，可以使用 StandardCopyOption.REPLACE_EXISTING 选项。也可以指定使用原子方式来执行移动操作，这样要么移动操作成功完成，要么源文件依然存在，可以使用 StandardCopyOption.ATOMIC_MOVE 选项。</p> <p>可以通过 Files.isSymbolicLink() 方法判断一个文件是否是符号链接，还可以通过 File.readSymbolicLink() 方法读取该符号链接目标的真实路径。关于文件属性，Java 7 中提供了 BasicFileAttributes 对真正通用的文件属性进行了抽象，对于更具体的文件属性，还提供了 PosixFileAttributes 等类。可以使用 Files.readAttributes() 方法读取文件的属性。关于符号链接和属性，来看一个示例：</p> <pre> <code class="language-java">package com.xkland.sample; import java.io.IOException; import java.nio.file.Files; import java.nio.file.LinkOption; import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.attribute.PosixFileAttributes; public class JavaIODemo { public static void main(String[] args) { if(args.length < 1){ System.out.println("Usage: JavaIODemo filename"); return; } Path path = Paths.get(args[0]); Path real = null; try{ if(Files.isSymbolicLink(path)){ real = Files.readSymbolicLink(path); } PosixFileAttributes attr = Files.readAttributes(path, PosixFileAttributes.class, LinkOption.NOFOLLOW_LINKS); System.out.format("%s, size: %d, isSymbolicLink: %b .", path, attr.size(), attr.isSymbolicLink()); System.out.println(); PosixFileAttributes attrOfReal = Files.readAttributes(real, PosixFileAttributes.class); System.out.format("%s, size: %d, isSymbolicLink: %b .", real, attrOfReal.size(), attrOfReal.isSymbolicLink()); System.out.println(); } catch (IOException e) { e.printStackTrace(); } } }</code></pre> <p>如果这样运行程序，可以查看 /etc/alternatives/js 文件是否是符号链接，并查看具体链接到哪个文件：</p> <pre> <code class="language-java">youxia@ubuntu:~$java com.xkland.sample.JavaIODemo /etc/alternatives/js /etc/alternatives/js, size: 15, isSymbolicLink: true . /usr/bin/nodejs, size: 11187096, isSymbolicLink: false .</code></pre> <p>NIO.2 API 会默认跟随符号链接，如果不要上述示例代码中的 LinkOption.NOFOLLOW_LINKS 选项，则 Files.readAttributes() 返回的结果就是实际文件的属性，而不是符号链接文件的属性。</p> <h2><strong>NIO.2 中的异步 I/O</strong></h2> <p>由于 I/O 操作经常会阻塞，所以编写异步 I/O 操作的代码从来都是提高程序运行效率的有效手段。特别是 Node.js 的出现，使异步 I/O 的影响达到空前的巨大，基于 Callback 的异步 I/O 早已深入人心。 Java 7 中有三个新的异步通道：</p> <ol> <li>AsynchronousFileChannel —— 用于文件 I/O；</li> <li>AsynchronousSocketChannel —— 用于套接字 I/O，支持超时；</li> <li>AsynchronousServerSocketChannel —— 用于套接字接受异步链接。</li> </ol> <p>这里只考察一下基于文件的异步 I/O。使用异步 I/O 有两种形式，一种是基于 Future，一种是基于 Callback。使用 Future 的示例代码如下：</p> <pre> <code class="language-java">try{ Path file = Paths.get("/home/youxia/testfile"); AsynchronousFileChannel channel = AsynchronousFileChannel.open(file); //异步打开文件 ByteBuffer buffer = ByteBuffer.allocate(100_000); Future<Integer> result = channel.read(buffer, 0); //读取 100 000 字节 while(!result.isDone()){ //干点儿别的事情 } Integer bytesRead = result.get(); //获取结果 System.out.println("已读取的字节数：" + bytesRead); }catch(IOException | ExecutionException | InterruptedException e){ System.out.println(e.getMessage()); }</code></pre> <p>如果使用基于 Callback 的异步 I/O，其示例代码是这样的：</p> <pre> <code class="language-java">try{ Path file = Paths.get("/home/youxia/testfile"); AsynchronousFileChannel channel = AsynchronousFileChannel.open(file); ByteBuffer buffer = ByteBuffer.allocate(100_000); //异步方式打开文件，分配缓冲区准备读取，和前面是一样的 channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>(){ public void completed(Integer result, ByteBuffer attachment){ System.out.println("已读取的字节数：" + bytesRead); } public void failed(Throwable exception, ByteBuffer attachment){ System.out.println(exception.getMessage()); } }); //调用 channel.read() 的另一个版本，接受一个 CompletionHandler 类的对象做参数 }catch(IOException e){ System.out.println(e.getMessage()); }</code></pre> <p>在这里，创建了一个回调对象，该对象有 completed() 方法和 failed() 方法，根据 I/O 操作是否成功相应的方法会被回调，这和 Node.js 中的异步 I/O 是何其的相似啊。</p> <h2><strong>总结</strong></h2> <p>写完这一篇，估计我是再也不会忘记 Java I/O 的用法了。认真读完我这一篇的朋友应该也一样，如果读一遍又忘记了的话，就多读几遍。当然，我这一篇文章仍不可能包含 Java I/O 的方方面面。关于具体的 API，大家直接查看 Oracle 的官方文档就可以了。</p> <p> </p> <p>来自：http://www.cnblogs.com/youxia/p/java007.html</p> <p> </p>