java高級之Io流
1.1，什麼是io流？
流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱爲流，流的本質是數據傳輸，根據數據傳輸特性將流抽象爲各類類，方便更直觀的進行數據操做。java
1.2，流按類型分爲兩種:
* 字節流 : 字節流能夠操做任何數據,由於在計算機中任何數據都是以字節的形式存儲的
* 字符流 : 字符流只能操做純字符數據，比較方便。windows
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類型spa
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 }
第二種讀寫方法:code
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);
- 1. java之十 高級IO流
- 2. JAVA高級部分IO流
- 3. IO流高級
- 4. 深入IO流--高級IO
- 5. Java基礎練習 — IO流（高級）
- 6. Java之IO流
- 7. java之IO流
- 8. JAVA之 IO流
- 9. 【面試之java io流】IO
- 10. java IO流之一 IO流入門
- 更多相關文章...
- • XML DOM 高級 - XML 教程
- • Markdown 高級技巧 - Markdown 教程
- • Java 8 Stream 教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. java之十 高級IO流
- 2. JAVA高級部分IO流
- 3. IO流高級
- 4. 深入IO流--高級IO
- 5. Java基礎練習 — IO流（高級）
- 6. Java之IO流
- 7. java之IO流
- 8. JAVA之 IO流
- 9. 【面試之java io流】IO
- 10. java IO流之一 IO流入門