關于資源關閉：

一般情況下是：先打開的后關閉，后打開的先關閉

另一種情況：看依賴關系，如果流a依賴流b，應該先關閉流a，再關閉流b

例如處理流a依賴節點流b，應該先關閉處理流a，再關閉節點流b

當然完全可以只關閉處理流，不用關閉節點流。處理流關閉的時候，會調用其處理的節點流的關閉方法

如果將節點流關閉以后再關閉處理流，會拋出IO異常

參考資料該文中的內容來源于 Oracle 的官方文檔。Oracle 在 Java 方面的文檔是非常完善的。對 Java 8 感興趣的朋友，可以從這個總入口 Java SE 8 Documentation 開始尋找感興趣的內容。本博客不定期從 Oracle 官網搬磚。這一篇主要講 Java 中的 I/O，官方文檔在這里 Java I/O, NIO, and NIO.2。 前言不知道大家看到這個標題會不會笑我，一個使用 Java 多年的老程序員居然一直沒有記住 Java 中的 I/O。不過說實話，Java 中的 I/O 確實含有太多的類、接口和抽象類，而每個類又有好幾種不同的構造函數，而且在 Java 的 I/O 中又廣泛使用了 Decorator 設計模式（裝飾者模式）。總之，即使是在 OO 領域浸淫多年的老手，看到下面這樣的調用一樣會蛋疼： BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("somefile.txt")));當然，這僅僅只是我為了體現 Java I/O 的錯綜復雜的構造函數而虛構出來的一個例子，現實中創建一個 BufferedReader 很少會嵌套這么深，因為可以直接使用 FileReader 而避免多創建一個 FileInputStream。但是從一個 InputStream 轉化成一個 BufferedReader 總是有那么幾步路要走的，比如下面這個例子： URL cnblogs = new URL("http://www.cnblogs.com/"); BufferedReader reader = new BufferedReader(new InputStreamReader(cnblogs.openStream()));Java I/O 涉及到的類也確實特別多，不僅有分別用于操作字符流和字節流的 InputStream 和 Reader、OutputStream 和 Writer，還有什么 BufferedInputStream、BufferedReader、PrintWriter、PrintStream等，還有用于溝通字節流和字符流的橋梁 InputStreamReader 和 OutputStreamWriter，每一個類都有其不同的應用場景，如此細致的劃分，光是名字就足夠讓人暈頭轉向了。我一直記不住 Java I/O 中各種細節的另一個原因可能是我深受 ANSI C 的荼毒吧。在 C 語言的標準庫中，將文件的打開方式分為兩種，一種是將文件當成二進制格式打開，一種是當成文本格式打開。這和 Java 中的字節流和字符流的劃分有相似之處，但卻掩蓋了所有的數據其實都是字節流這樣的本質。ANSI C 用多了，總以為二進制格式和文本格式是同一個層面的兩種對立面，只能對立而不能統一，卻不知在 Java 中，字符流是對字節流的更高層次的封裝，最底層的 I/O 都是建立在字節流的基礎上的。如果拋開 ANSI C 語言的標準 I/O 庫，直接考察操作系統層面的 POSIX I/O，會發現操作的一切都是原始的字節數據，根本沒有什么字節字符的區別。除此之外，Java 走得更遠，它考慮到了各種更加廣泛的字節流，而不僅僅限于文件。比如網絡中傳輸的數據、內存中傳輸的對象等等，都可以用流來抽象。但是不同的流具有不同的特性，有的流可以隨機訪問，而有的卻只能順序訪問，有的可以解釋為字符，有的不能。在能解釋為字符的流中，有的一次只能訪問一個字符，有的卻可以一次訪問一行，而且把字節流解釋成字符流，還要考慮到字符編碼的問題。以上種種，均是造成 Java I/O 中類和接口多、對象構造方式復雜的原因。 從對立到統一，字節流和字符流先來說對立。在 Java 中如果要把流中的數據按字節來訪問，就應該使用 InputStream 和 OutputStream，如果要把流中的數據按字符來訪問，就應該使用 Reader 和 Writer。上面提到的這四個類都是抽象類，是所有其它具體類的基礎。不能直接構造 InputStream、OutputStream、Reader 和 Writer 類的實例，但是根據 OO 原則，可以這樣用： InputStream in = new FileInputStream("somefile"); int c = in.read();或者這樣： Reader reader = new FileReader("somefile"); int c = reader.read();這里的 FileInputStream 和 FileReader 就是具體的類，這樣的類還有很多，都位于 java.io 包中。文件讀寫是我們最常用的操作，所以最常用的就是 FileInputStream、FileOutputStream、FileReader、FileWriter這四個。這幾個類的構造函數有多個，但是最簡單的，肯定是接受一個代表文件路徑的字符串做參數的那一個。根據 OO 原則，我們一般使用更加抽象的 InputStream、OutputStream、Reader、Writer 來引用具體的對象。所以，在考察 API 的時候，只需要考察這四個抽象類就可以了，其它的具體類，基本上只需要考察它們的構造方式。而這幾個類的 API 也確實很好記，用來輸入的兩個類 InputStream 和 Reader 主要定義了read()方法，而用來輸出的兩個類 OutputStream 和 Writer 主要定義了write()方法。所不同者，前者操作的是字節，后者操作的是字符。read()和write()最簡單的用法是這樣的： 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){//關閉流時產生的異常，直接拋棄}}}} }上面的例子展示了read()和write()的用法，在 InputStream 和 OutputStream 中，這兩個方法操作的都是字節，但是，這里用來保存這個字節的變量卻是int類型的。這正是 API 設計的匠心所在，因為int的寬度明顯比byte要大，所以將一個byte讀入到一個int之后，有效的數據只占據int型變量的最低8位，如果read()方法返回的是有效數據，那么這個int型的變量永遠都不可能是負數。在這種情況下，read()方法可以用返回負數的方式來表示碰到特殊情況，比如返回-1表示到達了流的末尾，也就是用-1代表EOF。write()方法接受的參數也是int型的，但是它只把這個int型變量的最低8位寫入流，其余的數據被忽略。上面的例子還展示了 Java I/O 的一些特征： InputStream、OutputStream、Reader、Writer 等資源用完之后要關閉； 所有的 I/O 操作都可能產生異常，包括調用close()方法。這兩個特征攪到一起就比較復雜了，本來因為異常的產生就容易讓流的close()語句執行不到，所以只有把close()寫到finally塊中，但是在finally塊中調用close()又要寫一層try...catch...代碼塊。如果同時有多個流需要關閉，而前面的close()拋出異常，則后面的close()將不會執行，極易發生資源泄露。再加上如果前面的catch()塊中的異常被重新拋出，而finally塊中又沒有處理好異常的話，前面的異常會被抑制，所以大部分人都 hold 不住這樣的代碼，包括 Oracle 的官方教程中的寫法都是錯誤的。下面來看一下 Oracle 官方教程中的例子： 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();}}} }官方教程寫得比我更偷懶，它直接讓main()方法拋出IOException而避免了異常處理，也避免了在finally塊中的close()語句外再寫一層try...catch...。但是，這個示例的漏洞有兩個，其一是如果in.close()拋出了異常，則out.close()就不會執行；其二是如果try塊中拋出了異常，finally塊中又拋出了異常，則前面拋出的異常會被丟棄。為了解決這個問題，Java 7中新加入了try-with-resource語法。后面都用這種方式寫代碼。很顯然，一次處理一個字節效率是及其低下的，所以read()和write()還有別的重載版本： int read(byte[] b) int read(byte[] b, int off, int len) void write(byte[] b) void write(byte[] b, int off, int len)它們都可以一次操作一塊數據，用字節數組做為存儲數據的容器。read()返回的是實際讀取的字節數。而對于 Reader 和 Writer，它們的read()和write()方法的定義是這樣的： 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)可以看出，使用 Reader 和 Writer 一次操作一個字符的時候，依然使用的是int型的變量。如果一次操作一塊數據，則使用字符數組。輸出的時候，還可以直接使用字符串。到這里，已經可以很輕易記住八個類了：InputStream、OutputStream、Reader、Writer、FileInputStream、FileOutputStream、FileReader、FileWriter。前四個是抽象類，后四個是操作文件的具體類。而且這八個類分成兩組，一組操作字節流，一組操作字符流。很簡單的對立分組。然而，前面我提到過，其實字節流和字符流并不是完全對立的存在，其實字符流是在字節流上更高層次的封裝。在底層，一切數據都是字節，但是經過適當的封裝，可以把這些字節解釋成字符。而且，并不是所有的 Reader 都是可以像 FileReader 那樣直接創建的，有時，只能拿到一個可以讀取字節數據的 InputStream，卻需要在它之上封裝出一個 Reader，以方便按字符的方式讀取數據。最典型的例子就是可以這樣訪問一個網頁： URL cnblogs = new URL("http://www.cnblogs.com/"); InputStream in = cnblogs.openStream();這時，拿到的是字節流 InputStream，如果想獲得按字符讀取數據的 Reader，可以這樣創建： Reader reader = new InputStreamReader(in);所以， InputStreamReader 是溝通字節流和字符流的橋梁。同樣的橋梁還用用于輸出的 OutputStreamWriter。至此，不僅又輕松地記住了兩個類，也再次證明了字節流和字符流既對立又統一的辯證關系。 從抽象到具體，數據的來源和目的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 類圖可以展示這些類的關系。InputStreams 和 Readers：OutputStreams 和 Writers：從簡單到豐富，使用 Decorator 模式擴展功能從前文可以看出，所有的流都支持read()和write()，但是這樣的功能畢竟還是太簡單，有時還需要更高層次的功能需求，所以需要使用 Decorator 模式來對流進行擴展。比如，一次操作一個字節或一個字符效率太低，想把數據先緩存在內存中再進行操作，就可以擴展出 BufferedInputStream、BufferedReader、BufferedOutputStream、BufferedWriter 類。可以猜測到，BufferedOutputStream 和 BufferedWriter 類中一定有一個flush()方法，用來把緩存的數據寫入到流中。而且，BufferedReader 還有 readLine() 方法，可以一次讀取一行字符，甚至可以再擴展出一個 LineNumberReader，還可以提供行號的支持。再比如，有時從流中讀出一個字節或一個字符后，又不想要了，想把它還回去，就可以再擴展出 PushbackInputStream 和 PushbackReader，提供unread()方法將剛讀取的字節或字符還回去。可以想象，這種還回去的功能應該是需要緩存功能支持的，所以它們應該是在 BufferedInputStream 和 BufferedReader 外面又加了一層的裝飾。這就是 Decorator 模式。Java I/O 中自帶的這種擴展類還有很多，不容易記。后面的介紹中，會針對重要的類舉幾個例子。在此之前，還是通過 UML 類圖來了解一下擴展類。從 InputStream 擴展的類：從 Reader 擴展的類：從 OutputStream 擴展的類：從 Writer 擴展的類：從上圖中可以看到，每一個分組中擴展的類的數量是不一樣的，再也不是一種對稱的關系。仔細一想也很好理解，例如 Pushback 這樣的功能就只能用在輸入流 InputStream 和 Reader 上，而向輸出流中寫入數據就像潑出去的水，沒辦法再 Pushback 了。再例如，向流中寫入對象和讀取對象，操作的肯定是字節流而不是字符流，所以只有 ObjectInputStream 和 ObjectOutputStream，而沒有相應的 Reader 和 Writer 版本。再例如打印，操作的肯定是輸出流，所以只有 PrintStream 和 PrintWriter，沒有相應的輸入流版本，這沒有什么好奇怪的。在這些類中，可以通過 PrintStream 和 PrintWriter 向流中寫入格式化的文本，也可以通過 DataInputStream 和 DataOutputStream 從流中讀取或向流中寫入原始的數據，還可以通過 ObjectInputStream 和 ObjectOutputStream 從流中讀取或寫入一個完整的對象。如果要從流中讀取格式化的文本，就必須使用 java.util.Scanner 類了。下面先看一個簡單的示例，使用 DataOutputStream 的writeInt()、writeDouble()以及writeUTF()方法將int、double、String類型的數據寫入流中，然后再使用 DataInputStream 的readInt()、readDouble()、readUTF()方法從流中讀取int、double、String類型的數據。為了簡單起見，就使用基于文件的流作為存儲數據的方式。代碼如下： 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());}} }然后在main()方法中這樣調用： 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]);}}然后這樣運行該程序： java com.xkland.sample.JavaIODemo /home/youxia/testfile最后輸出是這樣： 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如果使用cat命令查看/home/youxia/testfile文件的內容，只會看到一堆亂碼，說明該文件是以二進制格式存儲的。如下： youxia@ubuntu:~$cat testfile @3?p?? =Duke Juggling Dolls@???Q?Java Pin@??\(?2Java Key Chain上面的代碼展示了 DataInputStream 和 DataOutputStream 的用法，通過前面的探討，對它們這樣層層包裝的構造方式已經見怪不怪了。并且在示例代碼中使用了 Java 7 中新引入的try-with-resource語法，這樣大大減少了代碼的復雜度，所有打開的流都可以自動關閉，而且異常處理也更簡潔。從代碼中還可以看到，需要捕獲 DataInputStream 的 EOFException 異常才能判斷讀取到了文件結尾。另外，使用這種方式寫入和讀取數據要非常小心，寫入數據的順序和讀取數據的順序一定要保持一致，如果先寫一個int，再寫一個double，則一定要先讀一個int，再讀一個double，否則只會讀取錯誤的數據。不信可以通過修改上述示例代碼中讀取數據的順序進行測試。使用 DataInputStream 和 DataOutputStream 只能寫入和讀取原始的數據類型的數據，如byte、char、short、float等，如果要讀取和寫入復雜的對象就不行了，比如java.math.BigDecimal。這個時候就需要使用 ObjectInputStream 和 ObjectOutputStream 了。所有需要寫入流和從流讀取的 Object 必須實現Serializable接口，然后調用 ObjectInputStream 和 ObjectOutputStream 的writeObject()方法和readObject()方法就可以了。而且很奇妙的是，如果一個 Object 中包含了其它的 Object 對象，則這些對象都會被寫入到流中，而且能保持它們之間的引用關系。從流中讀取對象的時候，這些對象也會同時被讀入內存，并保持它們之間的引用關系。如果把同一批對象寫入不同的流，再從這些流中讀出，就會獲得這些對象多個副本。這里就不舉例了。與以二進制格式寫入和讀取數據相對的，就是以文本的方式寫入和讀取數據。PrintStream 和 PrintWriter 中的 Print 就是代表著輸出能供人讀取的數據。比如浮點數3.14可以輸出為字符串"3.14"。利用 PrintStream 和 PrintWriter 中提供的大量print()方法和println()方法就可以做到這點，利用format()方法還可以進行更加復雜的格式化。把上面的例子做少量修改，如下： 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());}} }這時輸出的數據和輸入的數據都是經過良好格式化的，非常便于閱讀和打印，但是在處理數據的時候需要進行適當的轉換和解析，所以會一定程度上影響效率。在使用java.util.Scanner時，可以使用useDelimiter()方法設置合適的分隔符，在 Linux 系統中，空格、冒號、逗號都是常用的分隔符，具體情況具體分析。在上面的例子中，我直接將每個數據作為一行保存，這樣更加簡單。如果使用cat命令查看/home/youxia/testfile文件的內容，可以看到格式良好的數據，如下： 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如果不想使用流，只想像 C 語言那樣簡單地操作文件，可以使用 RandomAccessFile 類。對于 PrintStream 和 PrintWriter，我們用得最多的就是基于命令行的標準輸入輸出，也就是從鍵盤讀入數據和向屏幕寫入數據。Java 中有幾個內建的對象，它們分別是 System.in、System.out、System.err，因為平時用得多，我就不一一細講了。需要說明的是，這幾個對象都是字節流而不是字符流，這也可以理解，雖然我們的鍵盤不能輸入純二進制數據，但是通過管道和文件重定向卻可以，在控制臺中輸出亂碼也是常見的現象，所以這幾個流必須是字節流而不是字符流。如果要想按字符的方式讀取標準輸入，可以使用 InputStreamReader 這樣轉換一下： InputStreamReader cin = new InputStreamReader(System.in);除此之外，還可以使用 System.console 對象，它是 Console 類的一個實例。它提供了幾個實用的方法來操作命令行，如readLine()、readPassword()等，它的操作是基于字符流的。不過在使用 System.console 之前，先要判斷它是否存在，如果操作系統不支持或程序運行在一個沒有命令行的環境中，則其值為null。 Java 7 中引入的 NIO.2早在 2002 年發布的 Java 1.4 中就引入了所謂的 New I/O，也就是 NIO。但是依然被打臉， NIO 還是不那么好用，還白白浪費了 New 這個詞，搞得 Java 7 中對 I/O 的改進不得不稱為 NIO.2。在 Java 7 之前的 I/O 怎么不好用呢？主要表現在以下幾點： 在不同的操作系統中，對文件名的處理不一致； 不方便對目錄樹進行遍歷； 不能處理符號鏈接； 沒有一致的文件屬性模型，不能方便地訪問文件的屬性。所以，雖然存在java.io.File類，我前文中卻沒有介紹它。在 Java 7 中，引入了 Path、Paths、Files等類來對文件進行操作。Path 代表文件的路徑，不同操作系統有不同的文件路徑格式，而且還有絕對路徑和相對路徑之分。可以這樣創建路徑： Path absolute = Paths.get("/", "home", "youxia"); Path relative = Paths.get("myprog", "conf", "user.properties");靜態方法Paths.get()可以接受一個或多個字符串，然后它將這些字符串用文件系統默認的路徑分隔符連接起來。然后它對結果進行解析，如果結果在指定的文件系統上不是一個有效的路徑，那么它會拋出一個 InvalidPathException 異常。當然，也可以給該方法傳遞一個含有分隔符的字符串： Path home = Paths.get("/home/youxia");Path 類提供很多有用的方法對路徑進行操作。例如： 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(); //獲得根目錄使用 Files 類可以快速實現一些常用的文件操作。例如，可以很容易地讀取一個文件的全部內容： byte[] bytes = Files.readAllBytes(path);如果想將文件內容解釋為字符串，可以在 readAllBytes 后調用： String content = new String(bytes, StandardCharsets.UTF_8);也可以按行來讀取文件： List<String> lines = Files.readAllLines(path);反過來，將一個字符串寫入文件： Files.write(path, content.getBytes(StandardCharsets.UTF_8));按行寫入： Files.write(path, lines);將內容追加到指定文件中： Files.write(path, lines, StandardOpenOption.APPEND);當然，仍然可以使用前文介紹的 InputStream、OutputStream、Reader、Writer 類。這樣創建它們： InputStream in = Files.newInputStream(path); OutputStream out = Files.newOutputStream(path); Reader reader = Files.newBufferedReader(path); Writer in = Files.newBufferedWriter(path);同時，使用Files.copy()方法，可以簡化某些工作： Files.copy(in, path); //將一個 InputStream 中的內容保存到一個文件中 Files.copy(path, out); //將一個文件的內容復制到一個 OutputStream 中一些創建、刪除、復制、移動文件和目錄的操作： Files.createDirectory(path); //創建一個新目錄 Files.createFile(path); //創建一個空文件 Files.exists(path); //檢測一個文件或目錄是否存在 Files.createTempFile(prefix, suffix); //創建一個臨時文件 Files.copy(fromPath, toPath); //復制一個文件 Files.move(fromPath, toPath); //移動一個文件 Files.delete(path); //刪除一個文件如果目標文件或目錄存在的話，copy()和move()方法會失敗。如果希望覆蓋一個已存在的文件，可以使用StandardCopyOption.REPLACE_EXISTING選項。也可以指定使用原子方式來執行移動操作，這樣要么移動操作成功完成，要么源文件依然存在，可以使用StandardCopyOption.ATOMIC_MOVE選項。可以通過Files.isSymbolicLink()方法判斷一個文件是否是符號鏈接，還可以通過File.readSymbolicLink()方法讀取該符號鏈接目標的真實路徑。關于文件屬性，Java 7 中提供了 BasicFileAttributes 對真正通用的文件屬性進行了抽象，對于更具體的文件屬性，還提供了 PosixFileAttributes 等類。可以使用Files.readAttributes()方法讀取文件的屬性。關于符號鏈接和屬性，來看一個示例： 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();}} }如果這樣運行程序，可以查看/etc/alternatives/js文件是否是符號鏈接，并查看具體鏈接到哪個文件： youxia@ubuntu:~$java com.xkland.sample.JavaIODemo /etc/alternatives/js /etc/alternatives/js, size: 15, isSymbolicLink: true . /usr/bin/nodejs, size: 11187096, isSymbolicLink: false .NIO.2 API 會默認跟隨符號鏈接，如果不要上述示例代碼中的LinkOption.NOFOLLOW_LINKS選項，則Files.readAttributes()返回的結果就是實際文件的屬性，而不是符號鏈接文件的屬性。 NIO.2 中的異步 I/O由于 I/O 操作經常會阻塞，所以編寫異步 I/O 操作的代碼從來都是提高程序運行效率的有效手段。特別是 Node.js 的出現，使異步 I/O 的影響達到空前的巨大，基于 Callback 的異步 I/O 早已深入人心。 Java 7 中有三個新的異步通道： AsynchronousFileChannel —— 用于文件 I/O； AsynchronousSocketChannel —— 用于套接字 I/O，支持超時； AsynchronousServerSocketChannel —— 用于套接字接受異步鏈接。這里只考察一下基于文件的異步 I/O。使用異步 I/O 有兩種形式，一種是基于 Future，一種是基于 Callback。使用 Future 的示例代碼如下： 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()); }如果使用基于 Callback 的異步 I/O，其示例代碼是這樣的： 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()); }在這里，創建了一個回調對象，該對象有completed()方法和failed()方法，根據 I/O 操作是否成功相應的方法會被回調，這和 Node.js 中的異步 I/O 是何其的相似啊。 總結寫完這一篇，估計我是再也不會忘記 Java I/O 的用法了。認真讀完我這一篇的朋友應該也一樣，如果讀一遍又忘記了的話，就多讀幾遍。當然，我這一篇文章仍不可能包含 Java I/O 的方方面面。關于具體的 API，大家直接查看 Oracle 的官方文檔就可以了。讀到這里的朋友，請不要忘記給個推薦，謝謝。 （京山游俠于2016-09-30發布于博客園，轉載請注明出處。）

　　

轉載于:https://www.cnblogs.com/Frank99/p/6665202.html

總結

以上是生活随笔為你收集整理的转 -----那些年总也记不牢的IO的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。