1.1，什么是io流？

　　流是一組有順序的，有起點和終點的字節(jié)集合，是對數(shù)據(jù)傳輸?shù)目偡Q或抽象。即數(shù)據(jù)在兩設(shè)備間的傳輸稱為流，流的本質(zhì)是數(shù)據(jù)傳輸，根據(jù)數(shù)據(jù)傳輸特性將流抽象為各種類，方便更直觀的進行數(shù)據(jù)操作。

1.2，流按類型分為兩種:

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

1.2.1，io流的結(jié)構(gòu)圖:

　　

1.3，IO流常用父類:

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

1.4，IO程序書寫：

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

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

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

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

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

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

1.6，IO流(FileOutputStream):

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

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

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

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

第二種讀寫方法:

1 //創(chuàng)建輸入流對象 2 FileInputStream fis = new FileInputStream("C:\\Users\\十年飲冰，難涼熱血\\Desktop\\日常一趣\\由淺入深學(xué)Java—基礎(chǔ)、進階與必做260題.pdf"); 3 //創(chuàng)建輸出流對象 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，緩沖流思想:

　　緩沖思想：

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

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

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

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

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

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

1 　　//字節(jié)流讀取中文會造成亂碼的解決方法 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 //字節(jié)流寫出中文的問題 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流
　　* 字符流讀取字符, 就要先讀取到字節(jié)數(shù)據(jù), 然后轉(zhuǎn)為字符. 如果要寫出字符, 需要把字符轉(zhuǎn)為字節(jié)再寫出。

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

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

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

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

2.4，字符流的拷貝:

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

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

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

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

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

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

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

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

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

1 BufferedReader br = new BufferedReader(new FileReader("aaa.txt")); //創(chuàng)建字符輸入流對象,關(guān)聯(lián)aaa.txt 2 BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt")); //創(chuàng)建字符輸出流對象,關(guān)聯(lián)bbb.txt 3 4 int ch; 5 while((ch = br.read()) != -1) { //read一次,會先將緩沖區(qū)讀滿,從緩沖去中一個一個的返給臨時變量ch 6 bw.write(ch); //write一次,是將數(shù)據(jù)裝到字符數(shù)組,裝滿后再一起寫出去 7 } 8 9 br.close(); //關(guān)流 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系統(tǒng) 7 bw.newLine(); //跨平臺的 8 } 9 10 br.close(); 11 bw.close();

3.0，IO流(LineNumberReader):

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

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

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

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

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();

---

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

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

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

1 //整合多個字節(jié)輸入流: SequenceInputStream(Enumeration) 2 FileInputStream fis1 = new FileInputStream("a.txt"); //創(chuàng)建輸入流對象,關(guān)聯(lián)a.txt 3 FileInputStream fis2 = new FileInputStream("b.txt"); //創(chuàng)建輸入流對象,關(guān)聯(lián)b.txt 4 FileInputStream fis3 = new FileInputStream("c.txt"); //創(chuàng)建輸入流對象,關(guān)聯(lián)c.txt 5 Vector<InputStream> v = new Vector<>(); //創(chuàng)建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構(gòu)造 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，什么是內(nèi)存輸出流(了解):

　　* 該輸出流可以向內(nèi)存中寫數(shù)據(jù), 把內(nèi)存當作一個緩沖區(qū), 寫出之后可以一次性獲取出所有數(shù)據(jù)

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(); //將內(nèi)存緩沖區(qū)中所有的字節(jié)存儲在newArr中 9 //System.out.println(new String(newArr)); 10 System.out.println(baos); 11 fis.close();

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

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

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 //無論是字節(jié)輸出流,還是字符輸出流都不能直接寫出對象 9 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//創(chuàng)建對象輸出流 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流(對象操作流優(yōu)化)(寫入與讀取寫一起了)(了解):

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

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()結(jié)果輸出, 并且自動加上換行, 而且可以使用自動刷出的模式
　　* System.out就是一個PrintStream, 其默認向控制臺輸出信息

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

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

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

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上讀取數(shù)據(jù) 8 ps.write(b); //將數(shù)據(jù)寫到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，(數(shù)據(jù)輸入輸出流)(讀寫一起寫了)(了解):

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

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)
　　* 屬性列表中每個鍵及其對應(yīng)值都是一個字符串。　　　　　　　* 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); //第二個參數(shù)是對列表參數(shù)的描述,可以給值,也可以給null 5 System.out.println(prop);

轉(zhuǎn)載于:https://www.cnblogs.com/joeyJss/p/9490262.html

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。