一，IO流常識

Ⅰ，IO流的概述

1，IO流用來處理設備之間的數據傳輸

2，Java對數據的操作都是通過流的方式

3，Java用于操作流的類都在IO包中

4，流按流向分為：

①輸入流

②輸出流

5，流按操作類型分為：

①字節流：字節流可以操作任何數據，因為在計算機中任何數據都是以字節存儲的

②字符流：字符流只能操作純字符數據，比較方便

Ⅱ，IO流常用父類

1，字節流的抽象父類（抽象類不能直接new對象）

InputStream

OutputStream

2，字符流的抽象父類（抽象類不能直接new對象）

reader 返回值是int而不是byte

writer

Ⅲ，IO程序書寫

使用前，導入IO包中的類

使用時，進行IO異常處理

使用后，釋放資源

二，IO流——字節流（FileIntputStream）

read() ：（demo1）一次讀取一個字節；

（demo2）當所讀取的文件全部讀取完成之后，會返回-1。

這里寫圖片描述

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class Demo1_FileInputStream {public static void main(String[] args) throws IOException {demo1();    //從硬盤上（xxx.txt）一個一個讀取字節，然后輸出                                            demo2();    //通過while循環進行輸出}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");   //創建流對象int b;while((b = fis.read())!= -1){System.out.println(b);}fis.close();                                            //關流釋放資源}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");       //創建流對象，開流int x  = fis.read();                                        //從硬盤上讀取一個字節System.out.println(x);int y  = fis.read();                                        //從硬盤上讀取一個字節System.out.println(y);int z  = fis.read();                                        //從硬盤上讀取一個字節System.out.println(z);fis.close();                                                //關流釋放資源}   }

demo1
輸出形式：
97
98
99

demo2
輸出形式：
97
98
99

三，IO流——字節流（FileOutputStream）

write() ：（demo1）一次寫出一個字節；

（demo2）若想實現數據的追加

package com.wsq.stream;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo2_FileOutputStream {public static void main(String[] args) throws IOException  {demo1();//如果有文件yyy.txt則會在該文件輸入  abc ；若沒有該文件，則系統會先創建，然后在輸入  abc  到該文件內；demo2();//yy.txt文件會續寫上 d}private static void demo2() throws FileNotFoundException, IOException {FileOutputStream fos = new FileOutputStream("yyy.txt",true);    //如果想續寫就在第二個參數傳true即可；應用于QQ聊天記錄的續寫fos.write(100);fos.close();                                                    //關流}private static void demo1() throws FileNotFoundException, IOException {FileOutputStream fos = new FileOutputStream("yyy.txt"); //創建字節輸出流對象，如果沒有就自動創建一個fos.write(97);                                          //雖然寫出的是一個int數，但是到文件上的是一個字節，系統會自動去除前三個8位fos.write(98);fos.write(99);fos.close();                                            //關流}}

四，IO流——拷貝

這里寫圖片描述

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {demo1();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("思You.jpg");      //創建輸入流對象，關聯  思You.jpgFileOutputStream fos = new FileOutputStream("yy.jpg");      //創建輸出流對象，關聯 copy.jpgint b;while((b = fis.read()) != -1 ){fos.write(b);}fis.close();    //關流，釋放資源fos.close();    //關流，釋放資源}}

程序運行之后，會將原有的思You.jpg 原樣復制一份，名稱為 yy.jpg。

四，IO流——字節數組拷貝，定義小數組

（demo2）write (byte [] b,int off, int len)將指定byte數組中從偏移量off開始的len個字節寫入此文件輸出流

b：數據
off：數據中的起始偏移量
len：要寫入的字節數

package com.wsq.stream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo4_ArrayCopy {public static void main(String[] args) throws IOException {demo1();demo2();FileInputStream fis = new FileInputStream("xxx.txt");FileOutputStream fos = new FileOutputStream("yyy.txt");byte [] arr = new byte[1024 * 8];               //一般定義字節數組都是1024的整數倍int len;while((len = fis.read(arr)) != -1){             //如果忘記加arr。返回的就不是讀取的字節個數，而是字節的碼表值fos.write(arr,0,len);}fis.close();                                    //關流，釋放資源fos.close();                                    //關流，釋放資源}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");FileOutputStream fos = new FileOutputStream("yyy.txt");byte [] arr = new byte[2];int len;while((len = fis.read(arr)) != -1){fos.write(arr,0,len);}fis.close();                                    //關流，釋放資源fos.close();                                    //關流，釋放資源}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis = new FileInputStream("xxx.txt");byte [] arr = new byte[2];      //定義字節數組為2個字節int a = fis.read(arr);          //將文件上的字節讀取到字節數組中，文件xxx.txt上有3個字節abcSystem.out.println(a);          //讀到的有效字節個數for (byte b : arr) {            //第一次獲取到文件上的a和bSystem.out.println(b);}System.out.println("——————————————————————————————————————————————————————————————————");int c = fis.read(arr);          //若有有效字節個數，就返回有效的字節個數；若沒有的話，就返回-1；System.out.println(c);          //每次讀取2個，由于有3個字節，所以讀取一次之后還會剩余1個，故返回1；for (byte b : arr) {System.out.println(b);      //每次讀取2個字節，ab讀取，然后再次讀取c，c將a給掩蓋，會剩下cb，然后輸出；}fis.close();}}

demo1運行輸出結果:
這里寫圖片描述
demo2運行輸出結果：
xxx.txt 里面的內容給拷貝到 yyy.txt 文件里面。

五，IO流——BufferedInputStream跟BufferedOutputStream拷貝

package com.wsq.stream;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class Demo5_BufferCopy {
/*** close()方法* 具備刷新的功能，在關閉流之前，就會先刷新一次緩沖區，將緩沖區的字節全都刷到文件上，再關閉，close方法刷完之后就不能寫了* * flush()方法* 具備刷新的功能，刷完之后還可以繼續寫* */public static void main(String[] args) throws IOException {//demo1();//flush和close方法的區別BufferedInputStream bis = new BufferedInputStream(new FileInputStream("xxx.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("wsq.txt"));int b;while((b = bis.read()) != -1){bos.write(b);bos.flush();}//      bis.close();
//      bos.close();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis  = new FileInputStream("xxx.txt");      //創建輸入流對象，關聯  xxx.txtFileOutputStream fos  = new FileOutputStream("copy.txt");   //創建輸出流對象，關聯  copy.txtBufferedInputStream bis = new BufferedInputStream(fis);     //創建緩沖區對象，對輸入流fis進行包裝，讓其變得更加強大BufferedOutputStream bos = new BufferedOutputStream(fos);   //創建緩沖區對象，對輸出流fos進行包裝，讓其變得更加強大int b;while((b = bis.read()) != -1){bos.write(b);}bis.close();bos.close();}}

六，IO流——錄入數據拷貝到文件

問題：將鍵盤錄入的語句拷貝到當前項目下的xxx.txt文件中，鍵盤錄入數據當遇到quit時就退出

分析：
1，創建鍵盤錄入對象
2，創建輸出流對象，關聯xxx.txt文件
3，定義無限循環
4，遇到quit退出循環
5，如果不quit，就將內容寫出
6，關閉流

package com.wsq.lianxi;import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;public class Test3 {public static void main(String[] args) throws IOException {//1，創建鍵盤錄入對象Scanner  wsq = new Scanner(System.in);//2，創建輸出流對象，關聯xxx.txt文件FileOutputStream fos = new FileOutputStream("xxx.txt");System.out.println("請輸入數據：");//3，定義無限循環  while(true){String line = wsq.nextLine();//4，遇到quit退出循環if("quit".equals(line)){break;}//5，如果不quit，就將內容寫出fos.write(line.getBytes());         //字符串寫出必須轉換成字節數組fos.write("\r\n".getBytes());       //輸出一個   換行  }//6，關閉流fos.close();//關流}}

七，IO流——字符流（FileReader）

問題：將xxx.txt文件內的內容給讀取出來

package com.yy.chario;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class Demo1_FileReader {public static void main(String[] args) throws IOException {demo1();  //只讀取一個字符demo2();  //通過while循環，將xxx.txt文件內的所有內容都讀取出來}private static void demo2() throws FileNotFoundException, IOException {FileReader yy = new FileReader("xxx.txt");int y;while((y = yy.read()) != -1){               //通過項目默認的碼表（GBK）一次讀取一個字符 System.out.print((char)y);向下轉型，將int強制轉換成char}yy.close();}private static void demo1() throws FileNotFoundException, IOException {FileReader  wsq = new FileReader("xxx.txt");int x = wsq.read();System.out.println(x);char s = (char) x ;//向下轉型，將int強制轉換成charSystem.out.println(s);wsq.close();}}

八，IO流——字符流（FileWriter）

問題：將字符串和單個字符寫到wsq.txt文件內

如果沒有wsq.txt這個文件，系統會自動創建出來該文件

package com.yy.chario;import java.io.FileWriter;
import java.io.IOException;public class Demo2_FileWriter {public static void main(String[] args) throws IOException {FileWriter wsq = new FileWriter("wsq.txt");wsq.write("原諒我這一生不羈放縱愛自由。");//可以直接寫 字符串wsq.write(29579);                     //也可以寫 單個字符wsq.write(24605);wsq.write(29738);wsq.close();}}

九，IO流——字符流的拷貝

問題：將qqq.txt文件（已創建）內容拷貝到www.txt文件里（如果沒有創建，系統會自動生成該文件）。

package com.yy.chario;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {FileReader yy = new FileReader("qqq.txt");//qqq.txt這個文件必須存在FileWriter wsq= new FileWriter("www.txt");//www.txt這個文件會自動生成int y ;while((y = yy.read()) != -1){wsq.write(y);}yy.close();wsq.close();  //Writer類中有一個2K的小緩沖區，如果不關流，就會將內容寫到緩沖區里，關流會將緩沖區內容刷新，再關閉}}

十，IO流——字節流與字符流的不同用處

字節流：

①字節輸入，字節輸出，只是對字節的一種搬運
②如果進行只寫的時候，必須將字節轉換成字節數組才能寫出去

字符流：

①字符流也可以拷貝文件，但不推薦使用；因為，讀取時，會把字節轉為字符（通過GBK碼表轉換），寫出時，會將字符轉回字。
②程序需要讀取一段文本，或者需要寫出一段文本的時候可以使用字符流
也就是只讀或者只寫的情況下使用字符流，字符流是通過碼表進行讀寫的，整個字符整個字符進讀寫的
③讀取的時候是按照字符的大小讀取的不會出現半個中文；寫出的時候可以直接將字符串寫出，不用轉換為字節數組
④不可以拷貝非純文本的文件；因為在讀的時候會將字節轉換成字符，在轉換過程中，就會用?替代，寫出的時候會將字符轉換成字節寫出去；如果是？，直接寫出，這樣寫出之后的文件就會亂，看不了了。

十一，IO流——字符流拷貝的不同形式

demo1()：將qqq.txt這個文件上的內容，拷貝到www.txt這個文件上
demo2()：字節流不可以拷非文本的文件；運行結束之后，我們會發現，所拷貝之后的王思琪.jpg 無法打開
demo3()：自定義字符數組的拷貝
demo4()：帶緩沖區的字符流拷貝

package com.yy.chario;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo3_Copy {public static void main(String[] args) throws IOException {
//      demo1();  將qqq.txt這個文件上的內容，拷貝到www.txt這個文件上
//      demo2();  字節流不可以拷   文本的文件；運行結束之后，我們會發現，所拷貝之后的 王思琪.jpg 無法打開
//      demo3();  自定義字符數組的拷貝
//      demo4();  帶緩沖區的字符流拷貝        }private static void demo4() throws FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("zzz.txt"));//若有zzz.txt該文件，系統會將該文件的原有內容給清空掉，然后在去拷貝；若該文件不存在，則系統會先創建，再拷貝；int c;while((c = br.read()) != -1){           //讀取xxx.txt文件里面的內容，讀取到緩沖區里面bw.write(c);                        //將讀取到緩沖區（大小為8192=1024*8，16K）的內容給寫出去}   br.close();bw.close();}private static void demo3() throws FileNotFoundException, IOException {FileReader fr = new FileReader("www.txt");//www.txt必須事先創建好FileWriter fw = new FileWriter("sss.txt");//sss.txt有沒有無所謂，若沒有，系統會自動創建，然后將www.txt上的內容給拷貝到該文件上char [] arr = new char[ 1024* 8 ];        //自定義一個字符數組int len;                                    while((len = fr.read(arr)) != -1){        //將文件上的數據讀取到字符數組中fw.write(arr,0,len);                  //將字符數組中的數據寫到文件上}fr.close();fw.close();}private static void demo2() throws FileNotFoundException, IOException {FileReader yy = new FileReader("思You.jpg");//添加一個字節文件（思You.jpg），用一個字符流去讀取一個字節文件（思You.jpg）FileWriter wsq= new FileWriter("王思琪.jpg");//拷貝到  王思琪.jpg  時，該文件損壞       int y ;while((y = yy.read()) != -1){               //進行循環，讀取思You.jpgwsq.write(y);                           //拷貝到 王思琪.jpg上}yy.close();wsq.close();  //Writer類中有一個2K的小緩沖區，如果不關流，就會將內容寫到緩沖區里，關流會將緩沖區內容刷新，再關閉}private static void demo1() throws FileNotFoundException, IOException {FileReader yy = new FileReader("qqq.txt");//qqq.txt這個文件必須存在FileWriter wsq= new FileWriter("www.txt");//www.txt這個文件會自動生成int y ;while((y = yy.read()) != -1){             //進行循環，讀取qqq.txt文本上的內容wsq.write(y);                         //拷貝到www.txt文本上}yy.close();wsq.close();  //Writer類中有一個2K的小緩沖區，如果不關流，就會將內容寫到緩沖區里；如果關流，就會將緩沖區內容刷新，再關閉}}

十二，IO流——帶緩沖區Buffered的換行兩種方法

帶緩沖區Buffered的換行：也就是，若文本有換行，讀取的時候也會進行換行。

帶緩沖區的特殊方法：

readLine();屬于 BufferedReader
newLine(); 屬于 BufferedWriter

newLine() 與 \r\n 的區別

newLine()是跨平臺的方法
而 \r\n只支持的是Windows系統

package com.yy.chario;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Demo4_Buffered {public static void main(String[] args) throws IOException {demo1();//readLine();demo2();//newLine();}private static void demo2() throws FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("xxx.txt"));String line;while((line = br.readLine()) != null){bw.write(line);                                         //寫出回車換行符bw.newLine();                                           //bw.write("\r\n");                                     //跟這個bw.newLine()方法效果一樣}   br.close();bw.close();
}private static void demo1() throws FileNotFoundException, IOException {/*   public String readLine()  讀取一個文本行，通過下列字符之一即可認為某行已終止，換行('\n')、回車('\r')或者回車后直接跟著換行返回：包含該行內容的字符串，不包含任何行終止符，如果已達到流末尾，則返回null*/BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));//將zzz.txt文件里面的內容給輸出到Buffered緩沖區內String line;while((line = br.readLine()) != null){System.out.print(line);                                        //從控制臺輸出出來}br.close();
}}

十三，IO流——字符流-文本反轉

案例：

將一個文本文檔的文本反轉，第一行和倒數第一行交換，第二行和倒數第二行交換

分析：

1，創建輸入輸出流對象
2，創建集合對象
3，將讀到的數據存儲在集合中
4，倒著遍歷集合，將數據寫到文件上
5，關流

package com.wsq.test;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;public class Test1 {public static void main(String[] args) throws IOException {demo1();                            //正常步驟demo2();                            //改進之后}private static void demo2() throws FileNotFoundException, IOException {/*** 注意事項，流對象，早開晚關，什么時候用到什么時候開，用完之后就關掉* 改進之后：* */BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));ArrayList<String> list = new ArrayList<>();String line;while((line = br.readLine()) != null){list.add(line);}br.close();BufferedWriter bw = new BufferedWriter(new FileWriter("likewsq.txt"));for(int i = list.size() - 1 ; i>=0 ; i--){bw.write(list.get(i));                      //把數據給寫出去bw.newLine();                               //換行}bw.close();}private static void demo1() throws FileNotFoundException, IOException {//1，創建輸入輸出流對象BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("likewsq.txt"));//2，創建集合對象ArrayList<String> list = new ArrayList<>();//3，將讀到的數據存儲在集合中String line;while((line = br.readLine()) != null){list.add(line);}//4，倒著遍歷集合，將數據寫到文件上for(int i = list.size() - 1 ; i>=0 ; i--){bw.write(list.get(i));                      //把數據給寫出去bw.newLine();                               //換行}//5,關流br.close();bw.close();}}

十四，IO流——字符流-LineNumberReader

public class LineNumberReader extends BufferedReader

跟蹤行號的緩沖字符輸入流。

此類定義了方法getLineNumber(int)和getLineNumber()，它們可分別用于設置和獲取當前行號。
默認情況下，行編號從 0 開始。該行號隨數據讀取在每個行結束符處遞增，并且可以通過調用 setLineNumber(int) 更改行號。但要注意的是，setLineNumber(int) 不會實際更改流中的當前位置；它只更改將由 getLineNumber() 返回的值。
可認為行在遇到以下符號之一時結束：換行符（’\n’）、回車符（’\r’）、回車后緊跟換行符。

package com.yy.chario;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;public class Demo5_LineNumberReader {public static void main(String[] args) throws IOException {LineNumberReader wsq = new LineNumberReader(new FileReader("xxx.txt"));String line;wsq.setLineNumber(100);//設置當前行號，若為100，這xxx.txt文件內容從行號從101開始while((line = wsq.readLine()) != null){System.out.println(wsq.getLineNumber() + " "+line);//獲得當前行號}wsq.close();}}

十五，IO流——裝飾設計模式

package com.yy.chario;public class Demo6_Wrap {
/*** 裝飾設計模式的好處：* 耦合性不強，被裝飾的類的變化，與裝飾類的變化無關* 如果是繼承的話，耦合性太強* */public static void main(String[] args) {HeiMaStudent wsq = new HeiMaStudent(new Student());wsq.Coder();}}interface Coder{public void Coder();
}class Student implements Coder{@Overridepublic void Coder() {System.out.println("javase");System.out.println("javaweb");}
}
class HeiMaStudent implements Coder{//1，獲取被裝飾類的引用private Student wsq;                        //獲取學生引用，通過構造方法//2，在構造方法中傳入被裝飾類的對象public HeiMaStudent (Student s){this.wsq = wsq;}//3，對原有的功能進行升級@Overridepublic void Coder() {wsq.Coder();System.out.println("ssh");System.out.println("數據庫");System.out.println("大數據");System.out.println("......");}
}

十六，IO流——用指定的碼表讀寫字符

將utf_8.txt文件上(該文件存在)的內容(UTF-8編碼)拷貝到gbk.txt文件(該文件存在與否都可以)上(GBK碼表)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;public class Demo7_TransIO {public static void main(String[] args) throws IOException {demo1();demo2();demo3();    }private static void demo3() throws UnsupportedEncodingException, FileNotFoundException, IOException {BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("utf_8.txt"),"utf_8"));//更高效的讀BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk"));  //更高效的寫int wsq;while((wsq = br.read()) != -1){bw.write(wsq);}br.close();bw.close();}private static void demo2() throws UnsupportedEncodingException, FileNotFoundException, IOException {InputStreamReader yy = new InputStreamReader(new FileInputStream("utf_8.txt"),"utf-8");//字節流通向字符流的橋梁,用指定碼表讀字符OutputStreamWriter wsq = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");//字符流通向字節流的橋梁,用指定碼表寫字符int c;while((c = yy.read()) != -1){wsq.write(c);}yy.close();wsq.close();}private static void demo1() throws FileNotFoundException, IOException {//用默認編碼表讀寫，出現亂碼FileReader fr = new FileReader("utf_8.txt");FileWriter fw = new FileWriter("gbk.txt");int wsq;while((wsq = fr.read()) != -1){fw.write(wsq);}fr.close();fw.close();}}

十七，IO流——獲取文本上的字符出現的次數

案例：

獲取xxx.txt(該文本已創建，并且有內容)文本上每個字符出現的次數，將結果寫在wsq.txt上

獲取一個文本上每個字符出現的次數，將結果寫在wsq.txt上
- 分析：
- 1，創建帶緩沖的輸入流對象
- 2，創建雙列集合對象TreeMap
- 3，將讀到的字符存儲在雙列集合中，存儲的時候要做判斷，如果不包含這個鍵，就將鍵和1存儲，如果包含這個鍵，就將改建和值加1存儲
- 4，關閉輸入流
- 5，創建輸出流對象
- 6，遍歷集合，將集合中的內容寫到wsq.txt中
- 7，關閉輸出流

package com.wsq.test;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.TreeMap;public class Test3 {public static void main(String[] args) throws IOException {//1，創建帶緩沖的輸入流對象BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));//2，創建雙列集合對象TreeMapTreeMap<Character, Integer> yy = new TreeMap<>();//3,將讀到的字符存儲在雙列集合中，存儲的時候要做判斷，如果不包含這個鍵，就將鍵和1存儲，如果包含這個鍵，就將改建和值加1存儲int qq;while((qq = br.read()) != -1){char y = (char) qq;                     //強制類型轉換/*if(!yy.containsKey(y)){               //判斷是否包含這個鍵yy.put(y, 1);                       //如果不包含就將鍵和值為1添加進來}else{yy.put(y,yy.get(y) + 1);}*/yy.put(y, !yy.containsKey(y) ? 1 : yy.get(y) + 1 );}//4，關閉輸入流br.close();//5，創建輸出流對象BufferedWriter  bw = new BufferedWriter(new FileWriter("wsq.txt"));//6，遍歷集合，將集合中的內容寫到wsq.txt中for(Character key : yy.keySet()){switch (key) {case '\t':bw.write("\\t" + "=" + yy.get(key));break;case '\n':bw.write("\\n" + "=" + yy.get(key));break;case '\r':bw.write("\\r" + "=" + yy.get(key));break;default:break;}bw.write (key + "=" + yy.get(key));bw.newLine();}//7，關閉輸出流bw.close();}}

十八，IO流——測試版軟件

當我們下載一個試用版軟件，沒有購買正版的時候，每執行一次就會提醒我們還有多少次使用機會，用所學過的IO流知識，模擬試用版軟件
使用10次機會，執行一次就提示一次您還有幾次機會，如果次數到了，提示購買正版
分析：
1，創造帶緩沖的輸入流對象，因為要使用readLine方法，可以保證數據的原樣性
2，將讀到的字符串轉換為int數
3，對int數進行判斷，如果大于0，就將其–寫回去，如果不大于0，就提示請購買正版
4，在if判斷中要將–的結果打印，并將結果通過輸出流寫到文件上

package com.wsq.test;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {//1，創造帶緩沖的輸入流對象，因為要使用readLine方法，可以保證數據的原樣性BufferedReader br = new BufferedReader(new FileReader("config.txt"));//2，將讀到的字符串轉換為int數String line = br.readLine();//System.out.println(line);int times = Integer.parseInt(line);         //將數字字符串轉換為數字//3，對int數進行判斷，如果大于0，就將其--寫回去，如果不大于0，就提示請購買正版if(times > 0){//4，在if判斷中要將--的結果打印，并將結果通過輸出流寫到文件上System.out.println("您還有" + times-- +"次機會");FileWriter fw = new FileWriter("config.txt");fw.write(times + "");fw.close();}else{System.out.println("您的試用次數已到，請購買正版");}br.close();//關閉流}}

十九，IO流——遞歸

案例：從鍵盤輸入接收一個文件件路徑，打印出該文件夾下所有的.java文件名

分析：
- 從鍵盤接收一個文件夾路徑
- 1，如果錄入文件夾的是不存在，給予提示
- 2，如果錄入的是文件路徑，給予提示
- 3，如果是文件夾路徑，直接返回
打印出該文件夾路徑下的所有的.java文件名
- 1，獲取到該文件夾路徑下的所以的文件和文件夾，存儲在File數組中
- 2，遍歷數組，對每一個文件或文件夾做判斷
- 3，如果是文件，并且后綴是.java的，就打印
- 4，如果是文件夾，就遞歸調用

package com.wsq.test;import java.io.File;
import java.util.Scanner;public class Test5 {public static void main(String[] args) {File dir = getDir();                 //獲取文件夾路徑printJavaFile(dir);}/*** 獲取鍵盤錄入的文件夾路徑* 1，返回值類型File，因為是返回的是文件夾* 2，不需要有參數* */public static File getDir(){             //獲取文件夾路徑Scanner wsq = new Scanner(System.in);//創建鍵盤錄入對象System.out.println("請輸入一個文件夾路徑");while(true){String line = wsq.nextLine();    //將鍵盤錄入的文件路徑存儲File dir = new File(line);       //封裝成File對象if(!dir.exists()){               //如果錄入的文件路徑不存在System.out.println("您錄入的文件夾路徑不存在，請重新錄入");}else if(dir.isFile()){          //如果錄入 的是文件路徑System.out.println("您錄入的是文件路徑，請重新錄入文件夾路徑");}else{return dir;}}}/*** 獲取文件夾路徑下的所有.java文件* 1，返回值類型void* 2，參數列表File dir* * */public static void printJavaFile(File dir){//1，獲取到該文件夾路徑下的所以的文件和文件夾，存儲在File數組中File [] subFiles = dir.listFiles(); //2，遍歷數組，對每一個文件或文件夾做判斷for (File subFile : subFiles) {//3，如果是文件，并且后綴是.java的，就打印if(subFile.isFile() && subFile.getName().endsWith(".java")){System.out.println(subFile);//4，如果是文件夾，就遞歸調用}else if(subFile.isDirectory()){printJavaFile(subFile);}}}
}

二十，IO流——序列流


package com.yy.otherio;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;public class Demo1_SequenceInputStream {public static void main(String[] args) throws IOException {demo1();demo2();demo3();}private static void demo3() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");FileInputStream fis2 = new FileInputStream("b.txt");FileInputStream fis3 = new FileInputStream("c.txt");Vector<FileInputStream> v = new Vector<>();                     //創建集合對象v.add(fis1);                                                    //將流對象存儲進來v.add(fis2);v.add(fis3);Enumeration<FileInputStream> en = v.elements();         SequenceInputStream sis = new SequenceInputStream(en);          //將枚舉中的輸入流整合成一個 FileOutputStream fos = new FileOutputStream("d.txt");           int sole;while((sole = sis.read()) != -1){fos.write(sole);}sis.close();fos.close();}private static void demo2() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");FileInputStream fis2 = new FileInputStream("b.txt");SequenceInputStream sis = new SequenceInputStream(fis2,fis1);FileOutputStream fos = new FileOutputStream("c.txt"); int yy;while((yy = sis.read()) != -1){fos.write(yy);}sis.close();                    //sis在關閉的時候，會將構造方法中傳入的流對象也都關閉fos.close();}private static void demo1() throws FileNotFoundException, IOException {FileInputStream fis1 = new FileInputStream("a.txt");        //創建字節輸入流，關聯a.txtFileOutputStream fos = new FileOutputStream("c.txt");       //創建字節輸出流，關聯c.txtint wsq;while((wsq = fis1.read()) != -1){                           //不斷的在a.txt上讀取字節fos.write(wsq);                                         //將讀到的字節寫到c.txt上}fis1.close();                                               //關閉字節輸入流FileInputStream fis2 = new FileInputStream("b.txt");int yy;while((yy = fis2.read()) != -1){fos.write(yy);}fis2.close();fos.close();}}