Linux進階內容
阿新 • • 發佈：2022-04-20
為什麼會出現字元流
由於位元組流操作中文不是特別的方便，所以Java就提供字元流
- 字元流 = 位元組流 + 編碼表
用字元流複製文字檔案時，文字檔案也會有中文，但是沒有問題，原因是最終底層操作會自動進行位元組拼接成中文，如何識別是中文呢？
- 漢字在儲存的時候，無論選擇哪種編碼儲存，第一個位元組都是負數
1 import java.io.FileInputStream; 2 import java.io.IOException; 3 import java.util.Arrays; 4 5 /* 6 需求：位元組流讀文字檔案資料 7 8 一個漢字的儲存： 9如果是GBK編碼，佔用2個位元組 10 如果是UTF-8編碼，佔用3個位元組 11 12 */ 13 14 public class FileInputStreamDemo3 { 15 public static void main(String[] args) throws IOException{ 16 // FileInputStream fis=new FileInputStream("..\\hello java\\a.txt"); 17 // 18 // int by; 19 // while((by=fis.read())!=-1) {20 // System.out.print((char)by); 21 // } 22 // 23 // fis.close(); 24 25 // String s="abc";//[97, 98, 99] 26 27 String s="中國";//[-42, -48, -71, -6] 預設GBK編碼 28 // byte[] bys = s.getBytes(); 29 30 // byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67] 31 byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6] 32 System.out.println(Arrays.toString(bys)); 33 34 35 } 36 }
編碼表
基礎知識：
-
- 計算機中儲存的資訊都是用二進位制數表示的；我們在螢幕上看到的英文、漢字等字元是二進位制數轉換之後的結果
- 按照某種規則，將字元儲存到計算機中，稱為編碼。反之，將儲存在計算機中的二進位制數按照某種規則解析顯示出來，稱為解碼。這裡強調一下：按照A編碼儲存，必須按照A編碼解析，這樣才能顯示正確的文字符號。否則就會導致亂碼現象。
字元編碼：就是一套自然語言的字元與二進位制數之間的對應規則（A，65）
字符集：
-
- 是一個系統支援的所有字元的集合，包括各國家文字、標點符號、圖形符號、數字等
- 計算機要準確的儲存和識別個只能怪字符集符號，就需要進行字元編碼，一套字符集必然至少有一套字元編碼。
常見字符集有ASCII字符集、GBXXX字符集、Unicode字符集等
ASCII字符集：
-
- ASCII（American Standard Code for Information Interchange，美國資訊交換標準程式碼）：是基於拉丁字母的一套電腦編碼系統，用於顯示現代英文，主要包括控制字元（回車鍵、退格、換行鍵等）和可顯示字元（英文大小寫字元、阿拉伯數字和西文符號）
- 基本的ASCII字符集，使用7為表示一個字元，共128字元。ASCII的擴充套件字符集使用8位表示一個字元，共256字元，方便支援歐洲常用字元。是一個系統支援的所有字元的集合，包括各國家文字、標點符號、圖形符號、數字等
GBXXX字符集：
-
- GB2312：簡體中文碼錶。一個小於127的字元的意義與原來相同，但兩個大於127的字元連在一起時，就表示一個漢字，這樣大約可以組合了包含7000多個簡體漢字，此外數學符號、羅馬希臘的字母、日文的假名等都編進去了，連在ASCII裡本來就有的數字、標點、字母都統統重寫編了兩個位元組長的編碼，這就是常說的“全形”字元，而原來在127號以下的那些就餓叫“半形”字元了
- GBK： 最常用的中文碼錶。是在GB2312標準基礎上擴充套件規範，使用了雙位元組編碼方案，共收錄了21003個漢字，完全相容GB2312標準，同時支援繁體漢字以及日韓漢字等
- GB18030：最新的中文碼錶。共收錄漢字70244個，採用多位元組編碼，每個字可以有1個、2個或4個位元組組成。支援中國國內少數民族的文字，同時支援繁體漢字以及日韓漢字等
Unicode字符集：
-
- 為表達任意語言的任意字元而設計，是業界的一種標準，也稱為統一碼、標準萬國碼。它最多使用4個位元組的數字來表達每個字母、符號、或者文字。有三種編碼方案，UTF-8、UTF-16和UTF32。最為常用的UTF-8編碼
- UTF-8編碼：可以用來表示Unicode標準中任意字元，它是電子郵件、網頁及其他儲存或傳送文字的應用中，優先採用的編碼。網際網路工程工作小組（IETF）要求所有網際網路協議都必須支援UTF-8編碼。它使用一至4個位元組為每個字元編碼
編碼規則：
128個US-ASCII字元，只需一個位元組編碼
拉丁文等文字，需要二個位元組編碼
大部分常用字（含中文），使用三個位元組編碼
其他極少使用的Unicode輔助字元，使用四位元組編碼
小結：採用何種規則編碼，就要採用對應規則解碼，否則就會出現亂碼
字串中的編碼解碼
編碼：
-
- byte[] getBytes()：使用平臺的預設字符集將該String編碼為以一系列位元組，將結果儲存到新的位元組陣列中
- byte[] getBytes(String charsetName)：使用指定的字符集將該String編碼為一系列位元組，將結果儲存到新的位元組陣列中
解碼：
-
- String(byte[] bytes)：通過使用平臺的預設字符集解碼指定的位元組陣列來構造新的String
- String(byte[] bytes,String charsetName)：通過指定的字符集解碼指定的位元組陣列來構造新的String
1 import java.io.UnsupportedEncodingException; 2 import java.util.Arrays; 3 4 /* 5 編碼： 6 7 - byte[] getBytes()：使用平臺的預設字符集將該String編碼為以一系列位元組，將結果儲存到新的位元組陣列中 8 - byte[] getBytes(String charsetName)：使用指定的字符集將該String編碼為一系列位元組，將結果儲存到新的位元組陣列中 9 10 解碼： 11 12 - String(byte[] bytes)：通過使用平臺的預設字符集解碼指定的位元組陣列來構造新的String 13 - String(byte[] bytes,String charsetName)：通過指定的字符集解碼指定的位元組陣列來構造新的String 14 15 */ 16 public class StringDemo { 17 public static void main(String[] args) throws UnsupportedEncodingException { 18 //定義一個字串 19 String s="中國"; 20 //編碼： 21 //byte[] getBytes()：使用平臺的預設字符集將該String編碼為以一系列位元組，將結果儲存到新的位元組陣列中 22 byte[] bys = s.getBytes();//[-42, -48, -71, -6] 23 24 //byte[] getBytes(String charsetName)：使用指定的字符集將該String編碼為一系列位元組，將結果儲存到新的位元組陣列中 25 // byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67] 26 // byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6] 27 System.out.println(Arrays.toString(bys)); 28 29 //解碼： 30 //String(byte[] bytes)：通過使用平臺的預設字符集解碼指定的位元組陣列來構造新的String 31 // String ss=new String(bys);//中國 32 //String(byte[] bytes,String charsetName)：通過指定的字符集解碼指定的位元組陣列來構造新的String 33 // String ss=new String(bys,"UTF-8");//?й? 34 String ss=new String(bys,"GBK");//中國 35 System.out.println(ss); 36 } 37 }
字元流中的編碼解碼
字元流抽象基類：
-
- Reader：字元輸入流的抽象類
- Writer：字元輸出流的抽象類
字元流中和編碼解碼的兩個類：
-
- InputStreamReader：是從位元組流到字元流的橋樑
它讀取位元組，並使用指定的編碼將其解碼為字元
它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接收平臺的預設字符集
-
- OutputStreamWriter：是從字元流到位元組流的橋樑
是從字元流到位元組流的橋樑，使用指定的編碼將寫入的字元編碼為位元組
它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接收平臺的預設字符集
1 import java.io.FileInputStream; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 import java.io.InputStreamReader; 5 import java.io.OutputStreamWriter; 6 7 /* 8 - InputStreamReader：是從位元組流到字元流的橋樑 9 它讀取位元組，並使用指定的編碼將其解碼為字元 10 它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接收平臺的預設字符集 11 12 - OutputStreamWriter：是從字元流到位元組流的橋樑 13 是從字元流到位元組流的橋樑，使用指定的編碼將寫入的字元編碼為位元組 14 它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接收平臺的預設字符集 15 */ 16 public class ConversionStreamDemo { 17 public static void main(String[] args) throws IOException{ 18 //OutputStreamWriter(OutputStream out)建立一個使用預設字元編碼的OutputStreamWriter 19 //OutputStreamWriter(OutputStream out,String charsetName)建立一個使用命名字符集的OutputStreamWriter 20 21 // FileOutputStream fos=new FileOutputStream("..\\hello java\\osw.txt"); 22 // OutputStreamWriter osw=new OutputStreamWriter(fos); 23 //兩步合併 24 // OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt")); 25 // OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"),"GBK");//中國 26 OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt"),"UTF-8");//涓浗 27 osw.write("中國"); 28 osw.close(); 29 30 //InputStreamReader(InputStream in)建立一個使用預設字符集的InputStreamReader 31 //InputStreamReader(InputStream in,String charsetName)建立一個使用命名字符集的InputStreamReader 32 33 // InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"));//涓浗 34 // InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"),"GBK");//涓浗 35 InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt"),"UTF-8");//中國 36 //一次讀取一個字元資料 37 int ch; 38 while((ch=isr.read())!=-1) { 39 System.out.print((char)ch); 40 } 41 42 isr.close(); 43 44 } 45 }
字元流寫資料的5種方式
1 import java.io.FileOutputStream; 2 import java.io.IOException; 3 import java.io.OutputStreamWriter; 4 5 /* 6 構造方法： 7 OutputStreamWriter(OutputStream out)建立一個使用預設字元編碼的OutputStreamWriter 8 9 字元流寫資料的5種方式** 10 11 void write(int c) 寫一個字元 12 void write(char[] cbuf)寫入一個字元陣列 13 void write(char[] cbuf,int off,int len)寫入字元陣列的一部分 14 void write(String str)寫一個字串 15 void write(String str,int off,int len)寫一個字串的一部分 16 */ 17 18 public class OutputStreamWriterDemo { 19 public static void main(String[] args) throws IOException { 20 // OutputStreamWriter(OutputStream out)建立一個使用預設字元編碼的OutputStreamWriter 21 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("..\\hello java\\osw.txt")); 22 /* 23 //void write(int c) 寫一個字元 24 osw.write(97);//不重新整理資料進不來，因為真正底層寫資料是位元組流，而字元流相對於位元組流是有緩衝的 25 //void flush()重新整理流 26 osw.flush(); 27 osw.write(98); 28 osw.flush(); 29 osw.write(99);*/ 30 31 //void write(char[] cbuf)寫入一個字元陣列 32 char[] chs = { 'a', 'b', 'c', 'd', 'e' }; 33 //osw.write(chs);//abcde 34 35 //void write(char[] cbuf,int off,int len)寫入字元陣列的一部分 36 //osw.write(chs,0,chs.length);//abcde 37 //osw.write(chs,1,3);//bcd 38 39 //void write(String str)寫一個字串 40 //osw.write("abcde");//abcde 41 42 //void write(String str,int off,int len)寫一個字串的一部分 43 //osw.write("abcde",0,"abcde".length());//abcde 44 osw.write("abcde", 1, 3);//bcd 45 46 osw.close();//關閉流，先重新整理 47 //osw.write(100);//java.io.IOException: Stream closed 48 49 } 50 }
字元流讀資料的2種方式
1 import java.io.FileInputStream; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 5 /* 6 構造方法： 7 InputStreamReader(InputStream in)建立一個使用預設字符集的InputStreamReader 8 9 字元流讀資料的2種方式** 10 int read() 一次讀一個字元資料 11 int read(char[] cbuf)一次讀一個字元陣列資料 12 13 */ 14 public class InputStreamReaderDemo { 15 public static void main(String[] args) throws IOException{ 16 //InputStreamReader(InputStream in)建立一個使用預設字符集的InputStreamReader 17 // InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\osw.txt")); 18 InputStreamReader isr=new InputStreamReader(new FileInputStream("..\\hello java\\ConversionStreamDemo.java")); 19 20 21 //int read() 一次讀一個字元資料 22 // int ch; 23 // while((ch=isr.read())!=-1) { 24 // System.out.print((char)ch); 25 // } 26 /*執行結果： 27 hello 28 world 29 java*/ 30 31 //int read(char[] cbuf)一次讀一個字元陣列資料 32 char[] chs=new char[1024]; 33 int len; 34 while((len=isr.read(chs))!=-1) { 35 System.out.print(new String(chs,0,len)); 36 } 37 /*執行結果： 38 hello 39 world 40 java*/ 41 42 //釋放資源 43 isr.close(); 44 45 } 46 }
案例：複製Java檔案
需求：把模組目錄下的“ConversionSteamDemo.java”複製到模組目錄下的“Copy.java”
思路：
- 根據資料來源建立字元輸入流物件
- 根據目的地建立字元輸出流物件
- 讀寫資料，複製檔案
- 釋放資源
1 import java.io.FileInputStream; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 import java.io.InputStreamReader; 5 import java.io.OutputStreamWriter; 6 7 /* 8 案例：複製Java檔案 9 需求：把模組目錄下的“ConversionSteamDemo.java”複製到模組目錄下的“Copy.java” 10 11 思路： 12 13 1. 根據資料來源建立字輸入流物件 14 2. 根據目的地建立字元輸出流物件 15 3. 讀寫資料，複製檔案 16 4. 釋放資源 17 */ 18 19 public class CopyJavaDemo { 20 public static void main(String[] args) throws IOException { 21 //1. 根據資料來源建立字輸入流物件 22 InputStreamReader isr = new InputStreamReader(new FileInputStream("..\\hello java\\ConversionStreamDemo.java")); 23 //2. 根據目的地建立字元輸出流物件 24 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("..\\hello java\\Copy.java")); 25 //3. 讀寫資料，複製檔案 26 //一次讀寫一個字元資料 27 //int ch; 28 //while((ch=isr.read())!=-1) { 29 // osw.write(ch); 30 //} 31 32 //一次讀寫一個字元陣列資料 33 char[] chs = new char[1024]; 34 int len; 35 while ((len = isr.read(chs)) != -1) { 36 osw.write(chs, 0, len); 37 } 38 39 //釋放資源 40 isr.close(); 41 osw.close(); 42 43 } 44 }
複製Java檔案（改進版）
轉換流的名字比較長，而我們常見的操作都是按照本地預設編碼實現的，所以，為了簡化書寫，轉換流提供了對應的子類
- FileReader：用於讀取字元檔案的便捷類
FileReader(String fileName)
- FileWriter：用於寫入字元檔案的便捷類
FileWriter(String fileName)
資料來源和目的地的分析
資料來源：…\hello java\ConversionStreamDemo.java—讀資料—Reader—InputStreamReader—FileReader
目的地：…\hello java\Copy.java–寫資料–Writer–OutputStreamWriter—FileWriter
1 import java.io.FileReader; 2 import java.io.FileWriter; 3 import java.io.IOException; 4 5 /* 6 案例：複製Java檔案（改進版） 7 8 需求：把模組目錄下的“ConversionSteamDemo.java”複製到模組目錄下的“Copy.java” 9 10 分析： 11 12 1. 轉換流的名字比較長，而我們常見的操作都是按照本地預設編碼實現的，所以，為了簡化書寫，轉換流提供了對應的子類 13 2. FileReader：用於讀取字元檔案的便捷類 14 FileReader(String fileName) 15 3. FileWriter：用於寫入字元檔案的便捷類 16 FileWriter(String fileName) 17 4. 資料來源和目的地的分析 18 資料來源：---讀資料---Reader---InputStreamReader---FileReader 19 目的地：..\\hello java\\Copy.java--寫資料--Writer--OutputStreamWriter---FileWriter 20 21 思路： 22 23 1. 根據資料來源建立字輸入流物件 24 2. 根據目的地建立字元輸出流物件 25 3. 讀寫資料，複製檔案 26 4. 釋放資源 27 28 */ 29 public class CopyJavaDemo2 { 30 public static void main(String[] args) throws IOException { 31 //1. 根據資料來源建立字輸入流物件 32 FileReader fr = new FileReader("..\\hello java\\ConversionStreamDemo.java"); 33 34 //2. 根據目的地建立字元輸出流物件 35 FileWriter fw = new FileWriter("..\\hello java\\Copy.java"); 36 37 //3. 讀寫資料，複製檔案 38 //一次讀寫一個字元資料 39 //int ch; 40 //while((ch=fr.read())!=-1) { 41 // fw.write(ch); 42 //} 43 44 //一次讀寫一個字元陣列資料 45 char[] chs = new char[1024]; 46 int len; 47 while ((len = fr.read(chs)) != -1) { 48 fw.write(chs, 0, len); 49 } 50 51 //4. 釋放資源 52 fr.close(); 53 fw.close(); 54 55 } 56 }
字元緩衝流
字元緩衝流：
-
- BufferedWriter：將文字寫入字元輸出流，緩衝字元，以提供單個字元，陣列和字串的高效寫入，可以指定緩衝區大小，或者可以接收預設大小。預設值足夠大，可用於大多數用途
- BufferedReader：從字元輸入流讀取文字，緩衝字元，以提供字元，陣列和行的高效讀取，可以指定緩衝區大小，或者可以使用預設大小。預設值足夠大，可用於大多數用途
構造方法：
-
- BufferedWriter(Writer out)
- BufferedReader(Reader in)
1 import java.io.BufferedReader; 2 import java.io.BufferedWriter; 3 import java.io.FileReader; 4 import java.io.FileWriter; 5 import java.io.IOException; 6 7 /* 8 字元緩衝流： 9 10 - BufferedWriter：將文字寫入字元輸出流，緩衝字元，以提供單個字元，陣列和字串的高效寫入，可以指定緩衝區大小，或者可以接收預設大小。預設值足夠大，可用於大多數用途 11 - BufferedReader：從字元輸入流讀取文字，緩衝字元，以提供字元，陣列和行的高效讀取，可以指定緩衝區大小，或者可以使用預設大小。預設值足夠大，可用於大多數用途 12 13 構造方法： 14 15 - BufferedWriter(Writer out) 16 - BufferedReader(Reader in) 17 */ 18 19 public class BufferedStreamDemo2 { 20 public static void main(String[] args) throws IOException { 21 //BufferedWriter(Writer out) 22 // FileWriter fw=new FileWriter("..\\hello java\\bw.txt"); 23 // BufferedWriter bw=new BufferedWriter(fw); 24 /* 25 //可合併為一句 26 BufferedWriter bw=new BufferedWriter(new FileWriter("..\\hello java\\bw.txt")); 27 28 bw.write("hello\r\n"); 29 bw.write("world\r\n"); 30 31 bw.close();*/ 32 33 //BufferedReader(Reader in) 34 BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\bw.txt")); 35 /* 36 //一次讀一個字元資料 37 int ch; 38 while((ch=br.read())!=-1) { 39 System.out.print((char)ch); 40 }*/ 41 42 //一次讀一個字元陣列資料 43 char[] chs = new char[1024]; 44 int len; 45 while ((len = br.read(chs)) != -1) { 46 System.out.print(new String(chs, 0, len)); 47 } 48 49 br.close(); 50 51 } 52 }
複製Java檔案（字元緩衝流改進版）
1 import java.io.BufferedReader; 2 import java.io.BufferedWriter; 3 import java.io.FileReader; 4 import java.io.FileWriter; 5 import java.io.IOException; 6 7 /* 8 案例：複製Java檔案（字元緩衝流改進版） 9 10 需求：把模組目錄下的“ConversionStreamDemo.java”複製到模組目錄下的“Copy.java” 11 12 思路： 13 1. 根據資料來源建立字元緩衝輸入流物件 14 2. 根據目的地建立字元緩衝輸出流物件 15 3. 讀寫資料，複製檔案 16 4. 釋放資源 17 */ 18 19 public class CopyJavaDemo3 { 20 public static void main(String[] args) throws IOException { 21 //1. 根據資料來源建立字元緩衝輸入流物件 22 BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\ConversionStreamDemo.java")); 23 24 //2. 根據目的地建立字元緩衝輸出流物件 25 BufferedWriter bw = new BufferedWriter(new FileWriter("..\\hello java\\Copy.java")); 26 27 //3. 讀寫資料，複製檔案 28 /* 29 //一次讀寫一個字元資料 30 int ch; 31 while((ch=br.read())!=-1) { 32 bw.write(ch); 33 }*/ 34 35 //一次讀寫一個字元陣列資料 36 char[] chs = new char[1024]; 37 int len; 38 while ((len = br.read(chs)) != -1) { 39 bw.write(chs, 0, len); 40 } 41 42 //4. 釋放資源 43 br.close(); 44 bw.close(); 45 46 } 47 }
字元緩衝流的特有功能
- BufferedWrite：
void newLine()：寫行分隔符，行分隔符字串有系統屬性定義
- BufferedReader：
public String readLine()：讀一行文字。結果包含行的內容的字串，不包括任何行終止字元，如果流的結尾已經到大，則為null
1 /* 2 字元緩衝流的特有功能 3 4 BufferedWrite： 5 void newLine()：寫一行行分隔符，行分隔符字串有系統屬性定義 6 7 BufferedReader： 8 public String readLine()：讀一行文字。結果包含行的內容的字串，不包括任何行終止字元，如果流的結尾已經到大，則為null 9 10 */ 11 12 import java.io.BufferedReader; 13 import java.io.BufferedWriter; 14 import java.io.FileReader; 15 import java.io.FileWriter; 16 import java.io.IOException; 17 18 public class BufferedStreamDemo3 { 19 public static void main(String[] args) throws IOException { 20 /*//建立字元緩衝輸出流 21 BufferedWriter bw=new BufferedWriter(new FileWriter("..\\hello java\\bw.txt")); 22 23 //寫資料 24 for(int i=0;i<10;i++) { 25 bw.write("hello"+i); 26 // bw.write("\r\n");//只適用於Windows 27 bw.newLine(); 28 bw.flush(); 29 } 30 hello0 31 hello1 32 hello2 33 hello3 34 hello4 35 hello5 36 hello6 37 hello7 38 hello8 39 hello9 40 41 //釋放資源 42 bw.close(); 43 */ 44 45 //建立字元緩衝輸入流 46 BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\bw.txt")); 47 48 //public String readLine()：讀一行文字。結果包含行的內容的字串，不包括任何行終止字元，如果流的結尾已經到大，則為null 49 /*//第一次讀取資料 50 String line = br.readLine(); 51 System.out.println(line);//hello0 52 //第二次讀取資料 53 line = br.readLine(); 54 System.out.println(line);//hello1 55 //再多讀兩次 56 line = br.readLine(); 57 System.out.println(line);//null 58 line = br.readLine(); 59 System.out.println(line);//null 60 */ 61 62 String line; 63 while ((line = br.readLine()) != null) { 64 System.out.println(line);//readline只讀內容，不包含換行符，要加ln 65 } 66 67 //釋放資源 68 br.close(); 69 70 } 71 }
複製Java檔案（字元緩衝流特有功能改進版）
1 import java.io.BufferedReader; 2 import java.io.BufferedWriter; 3 import java.io.FileReader; 4 import java.io.FileWriter; 5 import java.io.IOException; 6 7 /* 8 案例：複製Java檔案（字元緩衝流特有功能改進版） 9 10 需求：把模組目錄下的“ConversionSteamDemo.java”複製到模組目錄下的“Copy.java” 11 12 思路： 13 14 1. 根據資料來源建立字元緩衝輸入流物件 15 2. 根據目的地建立字元緩衝輸出流物件 16 3. 讀寫資料，複製檔案 17 使用字元緩衝流特有功能實現 18 4. 釋放資源 19 */ 20 public class CopyJavaDemo4 { 21 public static void main(String[] args) throws IOException { 22 //1. 根據資料來源建立字元緩衝輸入流物件 23 BufferedReader br = new BufferedReader(new FileReader("..\\hello java\\ConversionStreamDemo.java")); 24 25 //2. 根據目的地建立字元緩衝輸出流物件 26 BufferedWriter bw = new BufferedWriter(new FileWriter("..\\hello java\\Copy.java")); 27 28 //3. 讀寫資料，複製檔案(使用字元緩衝流特有功能實現) 29 String line; 30 while ((line = br.readLine()) != null) { 31 bw.write(line); 32 bw.newLine();//要加換行 33 bw.flush(); 34 } 35 36 //4. 釋放資源 37 br.close(); 38 bw.close(); 39 40 } 41 }
IO流小結
複製檔案的異常處理
try…catch…finally的做法：
1 try{ 2 可能出現異常的程式碼; 3 }catch(異常類名 變數名){ 4 異常的處理程式碼; 5 }finally{ 6 執行所有清除操作; 7 }
JDK7改進方案：
1 try(定義流物件){ 2 可能出現異常的程式碼; 3 }catch(異常類名 變數名){ 4 異常的處理程式碼; 5 } 6 7 自動釋放資源
JDK9的改進方案：
1 定義輸入流物件; 2 定義輸出流物件; 3 try(輸入流物件;輸出流物件){ 4 可能出現異常的程式碼; 5 }catch(異常類名 變數名){ 6 異常的處理程式碼; 7 } 8 9 自動釋放資源
1 import java.io.FileReader; 2 import java.io.FileWriter; 3 import java.io.IOException; 4 5 /* 6 複製檔案加入異常處理 7 */ 8 public class CopyFileDemo { 9 public static void main(String[] args) { 10 11 } 12 13 //JDK9的改進方案 14 private static void method4() throws IOException { 15 FileReader fr = new FileReader("fr.txt"); 16 FileWriter fw = new FileWriter("fw.txt"); 17 try (fr; fw) { 18 19 char[] chs = new char[1024]; 20 int len; 21 while ((len = fr.read()) != -1) { 22 fw.write(chs, 0, len); 23 } 24 } catch (IOException e) { 25 e.printStackTrace(); 26 } 27 28 } 29 30 //JDK7的改進方案 31 private static void method3() { 32 try (FileReader fr = new FileReader("fr.txt"); FileWriter fw = new FileWriter("fw.txt");) { 33 34 char[] chs = new char[1024]; 35 int len; 36 while ((len = fr.read()) != -1) { 37 fw.write(chs, 0, len); 38 } 39 } catch (IOException e) { 40 e.printStackTrace(); 41 } 42 43 } 44 45 //try...catch...finally 46 private static void method2() { 47 FileReader fr = null;//放外面定義，並給初始化 48 FileWriter fw = null; 49 try { 50 fr = new FileReader("fr.txt"); 51 fw = new FileWriter("fw.txt"); 52 53 char[] chs = new char[1024]; 54 int len; 55 while ((len = fr.read()) != -1) { 56 fw.write(chs, 0, len); 57 } 58 59 } catch (IOException e) { 60 e.printStackTrace(); 61 } finally {//close出現問題,先判斷不為空，再用try...catch處理 62 if (fw != null) { 63 64 try { 65 fw.close(); 66 } catch (IOException e) { 67 // TODO Auto-generated catch block 68 e.printStackTrace(); 69 } 70 } 71 //同理 72 if (fr != null) { 73 try { 74 fr.close(); 75 } catch (IOException e) { 76 // TODO Auto-generated catch block 77 e.printStackTrace(); 78 } 79 } 80 81 } 82 } 83 84 //丟擲異常 85 private static void method1() throws IOException { 86 FileReader fr = new FileReader("fr.txt"); 87 FileWriter fw = new FileWriter("fw.txt"); 88 89 char[] chs = new char[1024]; 90 int len; 91 while ((len = fr.read()) != -1) { 92 fw.write(chs, 0, len); 93 } 94 95 fr.close(); 96 fw.close(); 97 } 98 99 }