1.1，什么是io流？

　　流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱為流，流的本質是數據傳輸，根據數據傳輸特性將流抽象為各種類，方便更直觀的進行數據操作。

1.2，流按類型分為兩種:

　* 字節流 : 字節流可以操作任何數據,因為在計算機中任何數據都是以字節的形式存儲的
　* 字符流 : 字符流只能操作純字符數據，比較方便。

1.2.1，io流的結構圖:

　　

1.3，IO流常用父類:

　　* 字節流的抽象父類：　　　　　　　　　　　　* 字符流的抽象父類：
　　　　* InputStream?　　　　　　　　　　　　　　* Reader?
　　　　* OutputStream　　　　　　　　　　　　　? * Writer　　

1.4，IO程序書寫：

* 使用前，導入IO包中的類
* 使用時，進行IO異常處理
* 使用后，釋放資源

1.5，IO流(FileInputStream)~（1.5~2.0講的是字節流):

* read()一次讀取一個字節

* read()一次讀取一個字節

1 FileInputStream fis = new FileInputStream("aaa.txt"); //創建一個文件輸入流對象,并關聯aaa.txt 2 int b; //定義變量,記錄每次讀到的字節 3 while((b = fis.read()) != -1) { //將每次讀到的字節賦值給b并判斷是否是-1 4 System.out.println(b); //打印每一個字節 5 } 6 7 fis.close(); //關閉流釋放資源

read()方法讀取的是一個字節,為什么返回是int,而不是byte？
　　因為字節輸入流可以操作任意類型的文件,比如圖片音頻等,這些文件底層都是以二進制形式的存儲的,如果每次讀取都返回byte,有可能在讀到中間的時候遇到111111111
　　那么這11111111是byte類型的-1,我們的程序是遇到-1就會停止不讀了,后面的數據就讀不到了,所以在讀取的時候用int類型接收,如果11111111會在其前面補上
　　24個0湊足4個字節,那么byte類型的-1就變成int類型的255了這樣可以保證整個數據讀完,而結束標記的-1就是int類型

1.6，IO流(FileOutputStream):

　　* write()一次寫出一個字節

1 FileOutputStream fos = new FileOutputStream("bbb.txt"); //如果沒有bbb.txt,會創建出一個 2 //fos.write(97); //雖然寫出的是一個int數,但是在寫出的時候會將前面的24個0去掉,所以寫出的一個byte 3 fos.write(98); 4 fos.write(99); 5 fos.close();

1.7，第一種方法:IO之字節流流的基本讀寫(FileInputStream讀取，FileOutputStream寫出)：

1 //創建輸入流對象,C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\1970年的來歷.rtf 2 FileInputStream fis = new FileInputStream("C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\1970年的來歷.rtf"); 3 //創建輸出流對象,關聯copt.txt 4 FileOutputStream fos = new FileOutputStream("C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\copt.rtf"); 5 int b; 6 while((b = fis.read())!=-1){ //在不斷的讀取每一個字節 7 fos.write(b); //將每一個字節寫出 8 } 9 fis.close(); //關閉釋放 10 fos.close(); 11 }

第二種讀寫方法:

1 //創建輸入流對象 2 FileInputStream fis = new FileInputStream("C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\由淺入深學Java—基礎、進階與必做260題.pdf"); 3 //創建輸出流對象 4 FileOutputStream fos = new FileOutputStream("C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\Jy.pdf"); 5 byte[] arr = new byte[1024*8]; 6 int len; 7 while((len =fis.read(arr))!=-1){ 8 fos.write(arr,0,len);　　 9 }

1.8，緩沖流思想:

　　緩沖思想：

　　　　* 字節流一次讀寫一個數組的速度明顯比一次讀寫一個字節的速度快很多，這是加入了數組這樣的緩沖區效果，java本身在設計的時候，?也考慮到了這樣的設計思想(裝飾設計模式后面講解)，所以提供了字節緩沖區流。
　　　　* BufferedInputStream
　　　　? BufferedInputStream內置了一個緩沖區(數組)，從BufferedInputStream中讀取一個字節時，* BufferedInputStream會一次性從文件中讀取8192個, 存在緩沖區中, 返回給程序一個，程序再次讀取時, 就不用找文件了, 直接從緩沖區中獲取，直到緩沖區中所有的都被使用過, 才重新從文件中讀取8192個。
　　　　* BufferedOutputStream
　　　　? BufferedOutputStream也內置了一個緩沖區(數組)，程序向流中寫出字節時, 不會直接寫到文件, 先寫到緩沖區中，直到緩沖區寫滿, BufferedOutputStream才會把緩沖區中的數據一次性寫到文件里。

1 　　 FileInputStream fis = new FileInputStream("致青春.mp3"); //創建文件輸入流對象,關聯致青春.mp3 2 BufferedInputStream bis = new BufferedInputStream(fis); //創建緩沖區對fis裝飾 3 FileOutputStream fos = new FileOutputStream("copy.mp3"); //創建輸出流對象,關聯copy.mp3 4 BufferedOutputStream bos = new BufferedOutputStream(fos); //創建緩沖區對fos裝飾 5 6 int b; 7 while((b = bis.read()) != -1) { 8 bos.write(b); 9 } 10 11 bis.close(); //只關裝飾后的對象即可 12 bos.close();

1.9，IO流(flush和close方法的區別):

　　* flush()方法　　　　　　　　　　　　　　　 * close()方法
　　　* 用來刷新緩沖區的,刷新后可以再次寫出 　? ? 　　* 用來關閉流釋放資源的的,如果是帶緩沖區的流對象的close()方法,不但會關閉流,還會再關閉流之前刷新緩沖區,關閉后不能再寫出?

2.0，IO流(字節流讀寫中文)：

　　* 字節流讀取中文的問題
　　　　* 字節流在讀中文的時候有可能會讀到半個中文,造成亂碼
　　* 字節流寫出中文的問題
　　　　* 字節流直接操作的字節,所以寫出中文必須將字符串轉換成字節數組,寫出回車換行 write("\r\n".getBytes());

1 　　//字節流讀取中文會造成亂碼的解決方法 2 FileInputStream fis = new FileInputStream("xxx.txt"); 3 byte[] arr = new byte[5]; 4 int len; 5 while((len=fis.read(arr))!=-1){ 6 System.out.println(new String(arr,0,len)); 7 } 8 fis.close(); 9 } 1 //字節流寫出中文的問題 2 FileOutputStream fos = new FileOutputStream("zzz.txt"); 3 fos.write("我讀書少你,不要騙我".getBytes()); 4 fos.write("\r\n".getBytes()); 5 fos.close();

2.1，字符流是什么(2.1~3.1講的是字符流知識):

　　* 字符流是可以直接讀寫字符的IO流
　　* 字符流讀取字符, 就要先讀取到字節數據, 然后轉為字符. 如果要寫出字符, 需要把字符轉為字節再寫出。

2.2，FileReader類的read()方法可以按照字符大小讀取

1 FileReader fr = new FileReader("aaa.txt"); //創建輸入流對象,關聯aaa.txt 2 int ch; 3 while((ch = fr.read()) != -1) { //將讀到的字符賦值給ch 4 System.out.println((char)ch); //將讀到的字符強轉后打印 5 } 6 fr.close(); //關流

2.3，FileWriter類的write()方法可以自動把字符轉為字節寫出：

1 　public static void main(String[] args){ 2 FileWriter fw = new FileWriter("ccc.txt",true);　　//true是對數據進行追加的 3 fw.write(97); 4 fw.close(); 5 }

2.4，字符流的拷貝:

1 //創建字符輸入流 2 FileReader fr = new FileReader("ccc.txt"); 3 //創建字符輸出流 4 FileWriter fw = new FileWriter("xxx.txt"); 5 int len; 6 //while中的條件是fr.read()的字符長度等于len假如fr.read的值等于-1的時候就停止跳轉 7 while((len=fr.read())!=-1){ 8 fw.write(len); 9 } 10 fr.close(); 11 fw.close();//writer類中有一個2k的小緩沖區,如果不關流,就會將內容寫到緩沖區里,關流回將緩沖區內容刷新,再關閉 12 }

2.5，(什么情況下使用字符流):

　　* 字符流也可以拷貝文本文件, 但不推薦使用. 因為讀取時會把字節轉為字符, 寫出時還要把字符轉回字節.
　　* 程序需要讀取一段文本, 或者需要寫出一段文本的時候可以使用字符流
　　* 讀取的時候是按照字符的大小讀取的,不會出現半個中文
　　* 寫出的時候可以直接將字符串寫出,不用轉換為字節數組

2.6，IO流(字符流是否可以拷貝非純文本的文件)：

　　* 不可以拷貝非純文本的文件
　　* 因為在讀的時候會將字節轉換為字符,在轉換過程中,可能找不到對應的字符,就會用?代替,寫出的時候會將字符轉換成字節寫出去
　　* 如果是?,直接寫出,這樣寫出之后的文件就亂了,看不了

2.7，IO流(自定義字符數組的拷貝):

1 2 FileReader fr = new FileReader("aaa.txt"); //創建字符輸入流,關聯aaa.txt 3 FileWriter fw = new FileWriter("bbb.txt"); //創建字符輸出流,關聯bbb.txt 4 int len; 5 char[] arr = new char[1024*8]; //創建字符數組 6 while((len = fr.read(arr)) != -1) { //將數據讀到字符數組中 7 fw.write(arr, 0, len); //從字符數組將數據寫到文件上 8 } 9 10 fr.close(); //關流釋放資源 11 fw.close();

2.8，IO流(帶緩沖的字符流) ：

* BufferedReader的read()方法讀取字符時會一次讀取若干字符到緩沖區, 然后逐個返回給程序, 降低讀取文件的次數, 提高效率
* BufferedWriter的write()方法寫出字符時會先寫到緩沖區, 緩沖區寫滿時才會寫到文件, 降低寫文件的次數, 提高效率

1 BufferedReader br = new BufferedReader(new FileReader("aaa.txt")); //創建字符輸入流對象,關聯aaa.txt 2 BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt")); //創建字符輸出流對象,關聯bbb.txt 3 4 int ch; 5 while((ch = br.read()) != -1) { //read一次,會先將緩沖區讀滿,從緩沖去中一個一個的返給臨時變量ch 6 bw.write(ch); //write一次,是將數據裝到字符數組,裝滿后再一起寫出去 7 } 8 9 br.close(); //關流 10 bw.close();

2.9，IO流(readLine()和newLine()方法):

　　* BufferedReader的readLine()方法可以讀取一行字符(不包含換行符號)
　　* BufferedWriter的newLine()可以輸出一個跨平臺的換行符號"\r\n"

1 BufferedReader br = new BufferedReader(new FileReader("aaa.txt")); 2 BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt")); 3 String line; 4 while((line = br.readLine()) != null) { 5 bw.write(line); 6 //bw.write("\r\n"); //只支持windows系統 7 bw.newLine(); //跨平臺的 8 } 9 10 br.close(); 11 bw.close();

3.0，IO流(LineNumberReader):

　　* LineNumberReader是BufferedReader的子類, 具有相同的功能, 并且可以統計行號
　　* 調用getLineNumber()方法可以獲取當前行號
　　* 調用setLineNumber()方法可以設置當前行號

1 LineNumberReader lnr = new LineNumberReader(new FileReader("aaa.txt")); 2 String line; 3 lnr.setLineNumber(100); //設置行號 4 while((line = lnr.readLine()) != null) { 5 System.out.println(lnr.getLineNumber() + ":" + line);//獲取行號 6 } 7 8 lnr.close();

3.1，IO流(使用指定的碼表讀寫字符)(掌握):

　　* FileReader是使用默認碼表讀取文件, 如果需要使用指定碼表讀取, 那么可以使用InputStreamReader(字節流,編碼表)
　　* FileWriter是使用默認碼表寫出文件, 如果需要使用指定碼表寫出, 那么可以使用OutputStreamWriter(字節流,編碼表)

1 BufferedReader br = //高效的用指定的編碼表讀 2 new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8")); 3 BufferedWriter bw = //高效的用指定的編碼表寫 4 new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK")); 5 int ch; 6 while((ch = br.read()) != -1) { 7 bw.write(ch); 8 } 9 10 br.close(); 11 bw.close();

---

除卻字節流與字符流本博客還將總結一些課外的流，開發中也會遇見，為了豐富知識的同學們可以看看。

3.2，什么是序列流(了解):

　　* 序列流可以把多個字節輸入流整合成一個, 從序列流中讀取數據時, 將從被整合的第一個流開始讀, 讀完一個之后繼續讀第二個, 以此類推。

1 //整合多個字節輸入流: SequenceInputStream(Enumeration) 2 FileInputStream fis1 = new FileInputStream("a.txt"); //創建輸入流對象,關聯a.txt 3 FileInputStream fis2 = new FileInputStream("b.txt"); //創建輸入流對象,關聯b.txt 4 FileInputStream fis3 = new FileInputStream("c.txt"); //創建輸入流對象,關聯c.txt 5 Vector<InputStream> v = new Vector<>(); //創建vector集合對象 6 v.add(fis1); //將流對象添加 7 v.add(fis2); 8 v.add(fis3); 9 Enumeration<InputStream> en = v.elements(); //獲取枚舉引用 10 SequenceInputStream sis = new SequenceInputStream(en); //傳遞給SequenceInputStream構造 11 FileOutputStream fos = new FileOutputStream("d.txt"); 12 int b; 13 while((b = sis.read()) != -1) { 14 fos.write(b); 15 } 16 17 sis.close(); 18 fos.close();

3.3，什么是內存輸出流(了解):

　　* 該輸出流可以向內存中寫數據, 把內存當作一個緩沖區, 寫出之后可以一次性獲取出所有數據

1 　　 FileInputStream fis = new FileInputStream("a.txt"); 2 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 3 int b; 4 while((b = fis.read()) != -1) { 5 baos.write(b); 6 } 7 8 //byte[] newArr = baos.toByteArray(); //將內存緩沖區中所有的字節存儲在newArr中 9 //System.out.println(new String(newArr)); 10 System.out.println(baos); 11 fis.close();

3.4，什么是對象操作流(了解):

　　* 該流可以將一個對象寫出, 或者讀取一個對象到程序中. 也就是執行了序列化和反序列化的操作.

3.4.1，使用方式:

　　* 寫出: new ObjectOutputStream(OutputStream), writeObject()

1 public static void main(String[] args) throws IOException { 2 Person p1 = new Person("張三", 23); 3 Person p2 = new Person("李四", 24); 4 // FileOutputStream fos = new FileOutputStream("e.txt"); 5 // fos.write(p1); 6 // FileWriter fw = new FileWriter("e.txt"); 7 // fw.write(p1); 8 //無論是字節輸出流,還是字符輸出流都不能直接寫出對象 9 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//創建對象輸出流 10 oos.writeObject(p1); 11 oos.writeObject(p2); 12 oos.close(); 13 }

3.4.2，使用方式:

　　　　* 讀取: new ObjectInputStream(InputStream), readObject()

1 　　//讀取對象,反序列化 2 public static void main(String[] args) throws IOException, ClassNotFoundException { 3 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt")); 4 Person p1 = (Person) ois.readObject(); 5 Person p2 = (Person) ois.readObject(); 6 System.out.println(p1); 7 System.out.println(p2); 8 ois.close(); 9 }

3.4.3，IO流(對象操作流優化)(寫入與讀取寫一起了)(了解):

　　*　將對象存儲在集合中寫出

1 Person p1 = new Person("張三", 23); 2 Person p2 = new Person("李四", 24); 3 Person p3 = new Person("馬哥", 18); 4 Person p4 = new Person("輝哥", 20); 5 6 ArrayList<Person> list = new ArrayList<>(); 7 list.add(p1); 8 list.add(p2); 9 list.add(p3); 10 list.add(p4); 11 12 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt")); 13 oos.writeObject(list); //寫出集合對象 14 oos.close(); 15 　　　　//讀取到的是一個集合對象 16 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt")); 17 ArrayList<Person> list = (ArrayList<Person>)ois.readObject(); //泛型在運行期會被擦除,索引運行期相當于沒有泛型 18 //想去掉黃色可以加注解 @SuppressWarnings("unchecked") 19 for (Person person : list) { 20 System.out.println(person); 21 } 22 ois.close();

3.5，什么是打印流(了解):

　　* 該流可以很方便的將對象的toString()結果輸出, 并且自動加上換行, 而且可以使用自動刷出的模式
　　* System.out就是一個PrintStream, 其默認向控制臺輸出信息

1 　　PrintStream ps = System.out; 2 ps.println(97); //其實底層用的是Integer.toString(x),將x轉換為數字字符串打印 3 ps.println("xxx"); 4 ps.println(new Person("張三", 23)); 5 Person p = null; 6 ps.println(p); //如果是null,就返回null,如果不是null,就調用對象的toString()

3.6，什么是標準輸入輸出流(掌握):

　　*?System.in是InputStream, 標準輸入流, 默認可以從鍵盤輸入讀取字節數據
　　* System.out是PrintStream, 標準輸出流, 默認可以向Console中輸出字符和字節數據

3.6.1，修改標準輸入輸出流(了解):

　修改輸入流: System.setIn(InputStream)　　　　* 修改輸出流: System.setOut(PrintStream)

1 System.setIn(new FileInputStream("a.txt")); //修改標準輸入流 2 System.setOut(new PrintStream("b.txt")); //修改標準輸出流 3 4 InputStream in = System.in; //獲取標準輸入流 5 PrintStream ps = System.out; //獲取標準輸出流 6 int b; 7 while((b = in.read()) != -1) { //從a.txt上讀取數據 8 ps.write(b); //將數據寫到b.txt上 9 } 10 11 in.close(); 12 ps.close();

3.6.2，(修改標準輸入輸出流拷貝圖片)(了解):

1 System.setIn(new FileInputStream("IO圖片.png")); //改變標準輸入流 2 System.setOut(new PrintStream("copy.png")); //改變標準輸出流 3 4 InputStream is = System.in; //獲取標準輸入流 5 PrintStream ps = System.out; //獲取標準輸出流 6 7 int len; 8 byte[] arr = new byte[1024 * 8]; 9 10 while((len = is.read(arr)) != -1) { 11 ps.write(arr, 0, len); 12 } 13 14 is.close(); 15 ps.close();

3.7，(數據輸入輸出流)(讀寫一起寫了)(了解):

　　* 1.什么是數據輸入輸出流
　　　　* DataInputStream, DataOutputStream可以按照基本數據類型大小讀寫數據
　　　　* 例如按Long大小寫出一個數字, 寫出時該數據占8字節. 讀取的時候也可以按照Long類型讀取, 一次讀取8個字節.

1 * DataOutputStream(OutputStream), writeInt(), writeLong() 2 3 DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt")); 4 dos.writeInt(997); 5 dos.writeInt(998); 6 dos.writeInt(999); 7 8 dos.close(); 9 * DataInputStream(InputStream), readInt(), readLong() 10 11 DataInputStream dis = new DataInputStream(new FileInputStream("b.txt")); 12 int x = dis.readInt(); 13 int y = dis.readInt(); 14 int z = dis.readInt(); 15 System.out.println(x); 16 System.out.println(y); 17 System.out.println(z); 18 dis.close();

3.8，(Properties的概述和作為Map集合的使用)(了解)

　　* A:Properties的概述　　　　　　　　　　　　　　　　　　* A:Properties的特殊功能
　　* Properties 類表示了一個持久的屬性集。　　　　　　　　　　* public Object setProperty(String key,String value)
　　* Properties 可保存在流中或從流中加載?！　　　　　　　　　? public String getProperty(String key)
　　* 屬性列表中每個鍵及其對應值都是一個字符串?！　　　　　　? public Enumeration<String> stringPropertyNames()　

1 Properties prop = new Properties(); 2 prop.load(new FileInputStream("config.properties")); //將文件讀取到集合中 3 prop.setProperty("tel", "18972345678"); 4 prop.store(new FileOutputStream("config.properties"), null); //第二個參數是對列表參數的描述,可以給值,也可以給null 5 System.out.println(prop);

轉載于:https://www.cnblogs.com/joeyJss/p/9490262.html

總結

以上是生活随笔為你收集整理的java高级之Io流的全部內容，希望文章能夠幫你解決所遇到的問題。

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