14：IO之字符字节流
生活随笔
收集整理的這篇文章主要介紹了
14：IO之字符字节流
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
字節流：InputStream ???OutputStream?字節流：?FileInputStreamFileOutputStreamBufferedInputStreamBufferedOutputStream字符流：Writer ReaderFileReaderFileWriterBufferedReaderBufferedWriter
?*??? ?*?需求:在硬盤上，創建一個文件并寫入一些文字數據。?? ?*?找到一個專門用于操作文件的Writer子類對象。FileWriter。??后綴名是父類名。?前綴名是該流對象的功能。?? ?*/?? public?class?FileWriterDemo?{?? ????public?static?void?main(String[]?args)?{?? ????????method();//寫內容?? ????????method2();//續寫內容?? ????}?? ?????? ????/*?? ?????*?寫數據?? ?????*/?? ????public?static?void?method(){?? ????????FileWriter?fw?=?null;?? ????????try?{?? ????????????//創建一個FileWriter對象。該對象一被初始化就必須要明確被操作的文件。?? ????????????//該文件會被存放在指定的目錄下，如果該文件已經存在，會被覆蓋?? ????????????//其實該步就是在明確數據要存放的目的地。?? ????????????fw?=?new?FileWriter("testwrite.txt");//?C:\\testwrite.txt?? ?????????????? ????????????//調用write方法，將字符串寫入到流中?? ????????????fw.write("asdsadafsd");?? ?????????????? ????????????//刷新流對象中的緩沖中的數據。?? ????????????//將數據刷到目的地中。?? //??????????fw.flush();?? ?????????????? ????????????//關閉流資源，但是關閉之前會刷新一次內部的緩沖中的數據。?? ????????????//將數據刷到目的地中。?? ????????????//和flush區別：flush刷新后，流可以繼續使用，close刷新后，會將流關閉。?? //??????????fw.close();?? ????????}?catch?(IOException?e)?{?? ????????????e.printStackTrace();?? ????????}finally{?? ????????????try?{?? ????????????????if(fw?!=?null)?? ????????????????????fw.close();?? ????????????}?catch?(IOException?e)?{?? ????????????????e.printStackTrace();?? ????????????}?? ????????}?? ????}?? ?????? ????/*?? ?????*?在文件原有內容的基礎上續寫內容?? ?????*/?? ????public?static?void?method2(){?? ????????FileWriter?fw?=?null;?? ????????try?{?? ????????????fw?=?new?FileWriter("testwrite.txt",?true);?? ????????????fw.write("\r\nnihao\r\nxiexie");//\r\n是換行符\n是linux下的換行?? ????????}?catch?(IOException?e)?{?? ????????????e.printStackTrace();?? ????????}finally{?? ????????????if(fw?!=?null){?? ????????????????try?{?? ????????????????????fw.close();?? ????????????????}?catch?(IOException?e)?{?? ????????????????????e.printStackTrace();?? ????????????????}?? ????????????}?? ????????}?? ????}?? } ?
? 方法1： /* * 思路： * 1，需要讀取源， * 2，將讀到的源數據寫入到目的地。 * 3，既然是操作文本數據，使用字符流。 * */ public class CopyTextTest { public static void main(String[] args) throws IOException { //1,讀取一個已有的文本文件，使用字符讀取流和文件相關聯。 FileReader fr = new FileReader("IO流_2.txt"); //2,創建一個目的，用于存儲讀到數據。 FileWriter fw = new FileWriter("copytext_1.txt"); //3,頻繁的讀寫操作。 int ch = 0; while((ch=fr.read())!=-1){ fw.write(ch); } //4,關閉流資源。先關寫再關讀 fw.close(); fr.close(); } } 方法2： public class CopyTextTest_2 { private static final int BUFFER_SIZE = 1024; public static void main(String[] args) { FileReader fr = null; FileWriter fw = null; try { fr = new FileReader("IO流_2.txt"); fw = new FileWriter("copytest_2.txt"); //創建一個臨時容器，用于緩存讀取到的字符。 char[] buf = new char[BUFFER_SIZE];//這就是緩沖區。 //定義一個變量記錄讀取到的字符數，(其實就是往數組里裝的字符個數 ) int len = 0; while((len=fr.read(buf))!=-1){ fw.write(buf, 0, len); } } catch (Exception e) { // System.out.println("讀寫失敗"); throw new RuntimeException("讀寫失敗"); }finally{ if(fw!=null) try { fw.close(); } catch (IOException e) { e.printStackTrace(); } if(fr!=null) try { fr.close(); } catch (IOException e) { e.printStackTrace(); } } } }
/ * 緩沖區的出現就是為了提高操作流的效率 * 所以在創建緩沖區之前必須要先有流對象 * * 緩沖區提供了一個跨平臺的換行符 new Line(); */ public class BufferedWriterDemo { public static void main(String[] args) { method(); } public static void method() { // 創建一個字符寫入流對象 FileWriter fw = null; BufferedWriter bfw = null; try { fw = new FileWriter("buf.txt"); // 為了提高字符寫入流效率。加入了緩沖技術。其實緩沖區就是封裝了數組，不用自己定義數組，用起來更方便 // 只要將需要被提高效率的流對象作為參數傳遞給緩沖區的構造函數即可。 bfw = new BufferedWriter(fw); for (int x = 0; x < 10; x++) { bfw.write("abcds" + x); bfw.newLine();// 換行在windows中相當于\r\n,在linux中相當于\n } // 記住，只要用到緩沖區，就要記得刷新。 // bufw.flush(); } catch (IOException e) { e.printStackTrace(); } finally { try { bfw.close();// 關閉緩沖區就是在關閉緩沖區中的流對象，關閉前刷新 } catch (IOException e) { e.printStackTrace(); } } } } private static final String LINE_SEPARATOR = System.getProperty("line.separator"); //使用緩沖區的寫入方法將數據先寫入到緩沖區中。 // bufw.write("abcdefq"+LINE_SEPARATOR+"hahahha"); // bufw.write("xixiixii"); // bufw.newLine(); 行分隔，就不需要LINE_SEPARATOR，不過只在這里有效 // bufw.write("heheheheh");
二、讀取流緩沖區BufferedReaderpublic class BufferedReaderDemo { public static void main(String[] args) { method(); } public static void method(){ //創建一個讀取流對象 FileReader fr = null; BufferedReader bfr = null; try { fr = new FileReader("buf.txt"); //為了提高效率。加入緩沖技術。將字符讀取流對象作為參數傳遞給緩沖對象的構造函數。 bfr = new BufferedReader(fr); // char[] buf = new char[1024]; // bfr.read(buf); // int len = 0; // while((len = bfr.read(buf)) != -1){ // System.out.println(new String(buf,0,len)); // } String line = null; while((line = bfr.readLine()) != null){ System.out.println(line); } } catch (IOException e) { e.printStackTrace(); }finally{ try { bfr.close(); } catch (IOException e) { e.printStackTrace(); } } } }
三、通過緩沖技術提高效率復制文件：public class CopyTextByBufTest { //不處理異常，拋出去 public static void main(String[] args) throws IOException { FileReader fr = new FileReader("buf.txt"); BufferedReader bufr = new BufferedReader(fr); FileWriter fw = new FileWriter("buf_copy.txt"); BufferedWriter bufw = new BufferedWriter(fw); String line = null; while ((line = bufr.readLine()) != null) { bufw.write(line); bufw.newLine(); bufw.flush(); } /* * int ch = 0; * * while((ch=bufr.read())!=-1){ * * bufw.write(ch); } */ bufw.close(); bufr.close(); } } 處理異常try...catchpublic class CopyByBuffer { public static void main(String[] args) { copyByBuf(); } public static void copyByBuf() { FileWriter fw = null; FileReader fr = null; BufferedWriter bfw = null; BufferedReader bfr = null; try { fw = new FileWriter("C:\\buffertest.txt");//創建寫文件對象 fr = new FileReader("buffertest.txt");//創建讀文件對象 bfw = new BufferedWriter(fw);//使用緩沖區關聯讀寫對象 bfr = new BufferedReader(fr); String line = null; while ((line = bfr.readLine()) != null) {//通過讀一行的方式提高效率 bfw.write(line); bfw.newLine();//換行，夸平臺 } } catch (IOException e) { e.printStackTrace(); } finally { if (bfw != null) { try { bfw.close(); } catch (IOException e) { e.printStackTrace(); } } if (bfr != null) { try { bfr.close(); } catch (IOException e) { e.printStackTrace(); } } } } }
四、自定義緩沖區其實就是模擬一個BufferedReader.?* 分析：?* 緩沖區中無非就是封裝了一個數組，并對外提供了更多的方法對數組進行訪問。?其實這些方法最終操作的都是數組的角標。?*?* 緩沖的原理：?* 其實就是從源中獲取一批數據裝進緩沖區中。在從緩沖區中不斷的取出一個一個數據。?*?在此次取完后，在從源中繼續取一批數據進緩沖區。?當源中的數據取光時，用-1作為結束標記。public class MyBufferedReader extends Reader { private Reader r; //定義一個數組作為緩沖區。 private char[] buf = new char[1024]; //定義一個指針用于操作這個數組中的元素。當操作到最后一個元素后，指針應該歸零。 private int pos = 0; //定義一個計數器用于記錄緩沖區中的數據個數。 當該數據減到0，就從源中繼續獲取數據到緩沖區中。 private int count = 0; MyBufferedReader(Reader r){ this.r = r; } /** * 該方法從緩沖區中一次取一個字符。 * @return * @throws IOException */ /* public int myRead() throws IOException{ //從源中獲取一批數據到緩沖區中。需要先做判斷，只有計數器為0時，才需要從源中獲取數據。 if(count==0){ count = r.read(buf); //這是在底層 if(count<0)//沒有了 return -1; //每次獲取數據到緩沖區后，角標歸零（第一個read，底層）創建了一個數組。 pos = 0; char ch = buf[pos]; // 然后調用一次（第二個）read，返回一個a,再調用返回b,角標取一個，count減一個 pos++; count--; return ch; } else if(count>0){//第二次調用的時候count就不為0了， 不需要count = r.read(buf)這一步了 char ch = buf[pos]; pos++; count--; return ch; }*/
優化后 public int myRead() throws IOException{ if(count==0){ count = r.read(buf); pos = 0; } if(count<0) return -1; char ch = buf[pos++]; count--; return ch; } 五、模擬ReadLine
public String myReadLine() throws IOException{ // 定義一個臨時容器，原BufferedReader封裝的是字符數組，這里定義StringBuilder演示原理 StringBuilder sb = new StringBuilder(); int ch = 0; while((ch = myRead())!=-1){ if(ch=='\r') //如是'\r'繼續往下讀 continue; if(ch=='\n') //讀到'\n'就停止讀，然后將這些數據返回 return sb.toString(); //將從緩沖區中讀到的字符，存儲到緩存行數據的緩沖區中。 sb.append((char)ch); } if(sb.length()!=0) //最后沒有空格，說明有東西，返回， //這里是防止最后一行沒有回車符的情況 return sb.toString(); return null; } public void myClose() throws IOException { r.close(); } @Override public int read(char[] cbuf, int off, int len) throws IOException { return 0; } @Override public void close() throws IOException { } } 運行 ReadLine public class MyBufferedReaderDemo { public static void main(String[] args) throws IOException { FileReader fr = new FileReader("buf.txt"); MyBufferedReader bufr = new MyBufferedReader(fr); String line = null; while((line=bufr.myReadLine())!=null){ System.out.println(line); } bufr.myClose(); Collections.reverseOrder(); HashMap map = null; map.values(); } } 六、LineNumberReader（功能增強的讀）public class LineNumberReaderDemo { public static void main(String[] args) throws IOException { FileReader fr = new FileReader("IO流_2.txt"); LineNumberReader lnr = new LineNumberReader(fr); String line = null; lnr.setLineNumber(100);// 默認是0 while ((line = lnr.readLine()) != null) { System.out.println(lnr.getLineNumber() + ":" + line); } lnr.close(); } }
class Buffer { Buffer(TextWriter w) // 要緩沖誰就加入進來 { } Buffer(MediaWirter w) // 要緩沖誰就加入進來 { } } // 但是這樣做，來新對象還得加入，比較麻煩 // 都能寫入，為了名字有意義，寫成BufferWriter class BufferWriter extends Writer { BufferWriter(Writer w) { } }
Writer?|--TextWriter:用于操作文本?|--MediaWriter：用于操作媒體。?|--BufferWriter:用于提高效率。
??裝飾比繼承靈活。?特點：裝飾類和被裝飾類都必須所屬同一個接口或者父類。?有個類想要增強，可以用裝飾設計模式，把被裝飾的類往里傳進來就可以
/ * 字節流操作 * InputStream OutputStream * */ public class FileStreamDemo { public static void main(String[] args) { // writeFile(); // readFile_1(); // readFile_2(); readFile_3(); } /* * 對字節流讀操作的第一種方式 通過read()方法讀取一個字節 */ public static void readFile_1() { FileInputStream fis = null;// 定義字節輸入流 try { fis = new FileInputStream("fos.txt");// 指定輸入流和文件關聯 int ch = 0; while ((ch = fis.read()) != -1) {// 讀取操作 System.out.println((char) ch); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { if (fis != null)// 判空，提高程序的健壯性 fis.close(); } catch (IOException e) { e.printStackTrace(); } } } /* * 對字節流讀操作的第二種方式 通過read(byte[])方法讀取字節數組 */ public static void readFile_2() { FileInputStream fis = null; try { fis = new FileInputStream("fos.txt"); byte[] byf = new byte[1024]; int len = 0; while ((len = fis.read(byf)) != -1) { System.out.println(new String(byf, 0, len)); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { if (fis != null) fis.close(); } catch (IOException e) { e.printStackTrace(); } } } /* * 對字節流讀操作的第三種方式 通過字節流的available()方法獲取到文件大小，定義一個大小剛剛好的數組，無需循環 但是，這種方式操作較大數據時容易內存溢出，所以要慎用 首選的還是定義1024的整數倍數組 */ public static void readFile_3() { FileInputStream fis = null; try { fis = new FileInputStream("fos.txt"); // 通過這樣的方式定義一個剛剛好的數組 // 這種方法慎用，如果文件不大，可以用這個方法 byte[] byf = new byte[fis.available()];// fis.available()獲取文件大小 fis.read(byf); System.out.println(new String(byf)); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } /* * 對字節流進行寫操作 */ public static void writeFile() { FileOutputStream fos = null; try { fos = new FileOutputStream("fos.txt");//定義字節寫出流和文件關聯 fos.write("abcds".getBytes());// str.getBytes()將String轉化成字節數組 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { if (fos != null) try { fos.close();// 因為字節流沒有用到緩沖區，所以不需要刷新，但必須關閉資源 } catch (IOException e) { e.printStackTrace(); } } } } 二、通過字節流復制媒體文件
* 通過字節流拷貝圖片 */ public class CopyPicture { public static void main(String[] args) { copyPic(); } public static void copyPic() { FileInputStream fis = null; FileOutputStream fos = null; try { fis = new FileInputStream("1.jpg"); fos = new FileOutputStream("C:\\1.jpg"); byte[] byf = new byte[1024]; int len = 0; while ((len = fis.read(byf)) != -1) {// 將數據讀取到數組中 fos.write(byf, 0, len);// 寫入數組中的有效數據 } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { // 有多個流不能一起關閉，要分別關閉 if (fis != null) { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } if (fos != null) { try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } } // 千萬不要用，效率沒有！ public static void copy_4() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3"); FileOutputStream fos = new FileOutputStream("c:\\4.mp3"); int ch = 0; while((ch =fis.read())!=-1){ fos.write(ch); } fos.close(); fis.close(); } //不建議。 public static void copy_3() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3"); FileOutputStream fos = new FileOutputStream("c:\\3.mp3"); byte[] buf = new byte[fis.available()]; fis.read(buf); fos.write(buf); fos.close(); fis.close(); } //提高效率 public static void copy_2() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3"); BufferedInputStream bufis = new BufferedInputStream(fis); FileOutputStream fos = new FileOutputStream("c:\\2.mp3"); BufferedOutputStream bufos = new BufferedOutputStream(fos); int ch = 0; while((ch=bufis.read())!=-1){ bufos.write(ch); } bufos.close(); bufis.close(); } 三、字節流緩沖區
* 自定義字節流緩沖區 */ public class MyBufferedInputStream { private InputStream in; private byte[] buf = new byte[1024]; private int pos;// 定義數組的指針 private int count;// 定義計數器 MyBufferedInputStream(InputStream in) { this.in = in; } // 一次讀一個字節，從緩沖區（數組）中取得 public int myRead() throws IOException { // 通過in對象讀取數據并存放在buf數組中 if (count == 0) { count = in.read(buf); if (count < 0) { return -1; } pos = 0; byte b = buf[pos]; count--; pos++; return b & 255;// &255是因為存放的是二進制，也就是可能前八位是11111111，提升為int還是-1，就直接return了， // &255就是讓前面補0 /* * 11111111 11111111 11111111 11111111 * &00000000 00000000 00000000 11111111 * ------------------------------------ * 00000000 00000000 00000000 11111111 */ }else if(count>0){ byte b = buf[pos]; count--; pos++; return b&255;//&0xff } return -1; } public void myClose() throws IOException{ in.close(); } } 注：取出的是byte型，返回的是int型，這里存在提升的動作，
當byte中的八位全為1的時候是byte的-1，提升為int類型，就變為int型的-1，為-1時程序就停止循環了，read循環條件就結束了，變為-1的原因是由于在提升時，將byte的八位前都補的是1，即32位的數都是1，即為int型的-1了。如何保證提升后的最后八位仍為1呢？就需要將前24位補0，就可以保留原字節數據不變，又可以避免轉為int型出現-1的情況；
那么要如何做呢？
這就需要將提升為int的數據和前24位為0，后八位仍為原字節數據的這個值做與運算。即和255做與運算即可。說到了這里應該也明白了為什么Read方法返回值為int類型了。
轉換流的子類和轉換流的區別？InputStreamReader ? 字節-->字符??|--FileReader : 字節流+本地默認碼表。OutputStreamWriter ?字符-->字節?|--FileWriter?
什么時候使用轉換流呢？1，源或者目的對應的設備是字節流，但是操作的卻是文本數據，可以使用轉換作為橋梁。提高對文本操作的便捷。2，一旦操作文本涉及到具體的指定編碼表時，必須使用轉換流 。BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));
? ? ? //獲取鍵盤錄入對象??
?????????InputStream?in?=?System.in;?? ?????????? ?????????//將字節流對象轉換成字符流對象?? ?????????InputStreamReader?isr?=?new?InputStreamReader(in);?? ?????????? ?????????//將字符流對象用緩沖技術高效處理?? ?????????BufferedReader?bufr?=?new?BufferedReader(isr); ? ? ? ? ?//?鍵盤錄入最常見的寫法?? ? ? ? ? ?BufferedReader?bufr?=?new?BufferedReader(new ?InputStreamReader(System.in)); ?
字符流轉字節流：
? ? ? ? //?操作輸出?? ????????//?獲取輸出流?? ?????????OutputStream?out?=?System.out;?? ?????????//將字符流轉換成字節流，OutputStreamWriter字符流通向字節流的橋梁?? ?????????OutputStreamWriter?osw?=?new?OutputStreamWriter(out);?? ?????????BufferedWriter?bfw?=?new?BufferedWriter(osw);//高效緩沖區
獲取鍵盤輸入：鍵盤輸入都是字節，所以用到字節流與標準輸入流相關聯就可以把輸入的數據獲取到流中，以達到數據的操作效果。
* 獲取鍵盤錄入 public class ReadIn { public static void main(String[] args) { // method_1(); // method_2(); InputStreamReaderDemo(); } /* * 獲取鍵盤錄入 */ public static void method_1() { InputStream in = System.in;// 定義輸入流與鍵盤輸入流相關聯 int ch = 0; try { while ((ch = in.read()) != -1) { System.out.println(ch); } } catch (IOException e) { e.printStackTrace(); } } /* * 需求：通過鍵盤錄入數據。 當錄入一行數據后，就將該行數據進行打印。 如果錄入的數據是over，那么停止錄入。 * 1，因為鍵盤錄入只讀取一個字節，要判斷是否是over，需要將讀取到的字節拼成字符串。 * 2，那就需要一個容器。StringBuilder. * 3，在用戶回車之前將錄入的數據變成字符串判斷即可。 */ public static void method_2() { InputStream in = System.in; StringBuilder sb = new StringBuilder();// 定義一個臨時容器 while (true) { int ch = 0; try { ch = in.read(); if (ch == '\r')// windows中換行符為\r\n continue; if (ch == '\n') { String s = sb.toString();// 當讀到一行的結束標記時，把改行數據變成字符串 if ("over".equals(s)) break; System.out.println(s.toUpperCase()); //變成大寫 sb.delete(0, sb.length());// 清空容器 ，不清空會將上次輸入的和這次輸入的都輸出 } else { sb.append((char) ch); //將讀取到的字節存儲到StringBuilder中。 } } catch (IOException e) { e.printStackTrace(); } } } // ************************************************************************** /* * 通過上面錄入一行數據，發現其方法類似于readLine方法 但是readLine方法是字符流緩沖區的方法，所以需要把字節流轉換成字符流進行操作 * 需要用到InputStreamReader方法進行轉換,InputStreamReader字節通向字符的橋梁 * * 轉換流 */ public static void InputStreamReaderDemo() { BufferedReader bufr = null; try { // 源為文件 bufr = new BufferedReader(new InputStreamReader( new FileInputStream("buf.txt"))); } catch (FileNotFoundException e2) { e2.printStackTrace(); } // 操作輸出 // 目的地是控制臺 BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter( System.out)); // 目的地是文件 // BufferedWriter bfw = null; // try { // bfw = new BufferedWriter(new OutputStreamWriter(new // FileOutputStream("out.txt"))); // } catch (FileNotFoundException e1) { // e1.printStackTrace(); // } String line = null; try { while ((line = bufr.readLine()) != null) { if ("over".equals(line)) { break; } bfw.write(line.toUpperCase()); bfw.newLine();// 換行 bfw.flush();// 數據存放在緩沖區，所以需要刷新 } } catch (IOException e) { e.printStackTrace(); } finally { try { bufr.close(); } catch (IOException e) { e.printStackTrace(); } } } } 不處理異常 public class TransStreamDemo2 { public static void main(String[] args) throws IOException { /* * 1,需求：將鍵盤錄入的數據寫入到一個文件中。 * * 2,需求：將一個文本文件內容顯示在控制臺上。 * * 3,需求：將一個文件文件中的內容復制到的另一個文件中。 */ BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt"))); String line = null; while((line=bufr.readLine())!=null){ if("over".equals(line)) break; bufw.write(line.toUpperCase()); //變成大寫 bufw.newLine(); bufw.flush(); } } }
??演示：將一個中文字符串數據按照指定的編碼表寫入到一個文本文件中.?寫： public static void writeText_2() throws IOException { OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream( "gbk_3.txt"), "GBK"); // OutputStreamWriter osw = new OutputStreamWriter(new // FileOutputStream("gbk_3.txt"),"GBK"); // FileWriter fw = new FileWriter("gbk_1.txt"); /* * 這兩句代碼的功能是等同的。 FileWriter：其實就是轉換流指定了本機默認碼表的體現。而且這個轉換流的子類對象，可以方便操作文本文件。 * 簡單說：操作文件的字節流+本機默認的編碼表。 這是按照默認碼表來操作文件的便捷類。 * * 如果操作文本文件需要明確具體的編碼。FileWriter就不行了。必須用轉換流 */ osw.write("你好"); osw.close(); } public static void writeText_3() throws IOException { OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream( "u8_1.txt"), "UTF-8"); osw.write("你好"); osw.close(); }
讀：public static void readText_1() throws IOException { FileReader fr = new FileReader("gbk_1.txt"); char[] buf = new char[10]; int len = fr.read(buf); String str = new String(buf,0,len); System.out.println(str); fr.close(); } //用utf-8讀默認的編碼文件 public static void readText_2() throws IOException, FileNotFoundException { InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk_1.txt"),"utf-8"); char[] buf = new char[10]; int len = isr.read(buf); String str = new String(buf,0,len); System.out.println(str); isr.close(); } } }
?
來自為知筆記(Wiz)
第一 ?IO流概述
一、概述：
IO流是來處理設備間的數據傳輸
1、特點：
1）流操作按照數據可分為字節流(處理所有的數據)和字符流(處理文字，其中包含編碼表，可以指定編碼表防止了編碼表不同而產生亂碼的現象)
2）按照流向分可以分為輸出流和輸入流。
字節流的抽象基類：InputStream（讀）、OutputStream（寫）
字符流的抽象基類：Reader（讀）、Writer（寫）
注：此四個類派生出來的子類名稱都是以父類名作為子類名的后綴，以前綴為其功能；
第二 ?字符流
一、簡述：
1、字符流中的對象融合了編碼表。使用的是默認的編碼，即當前系統的編碼。
2、字符流只用于處理文字數據，而字節流可以任何數據。
3、既然IO流是用于操作數據的，那么數據的最常見體現形式是文件。專門用于操作文件的子類對象：FileWriter、FileReader
二、寫入字符流
- 數據的續寫是通過構造函數 FileWriter(String s,boolean append)，根據給定文件名及指示是否附加寫入數據的boolean值來構造FileWriter對象。為true時就是續寫，為false就是不續寫。?
- 調用write()方法，將字符串寫入到流中。這里他本身沒有特定的寫方法都是繼承自父類的方法有寫單個字符：write(int?c)，寫入字符數組：write(char[]?cbuf)這里的數組一般定義成1024的整數倍，不宜過大，過大容易造成內存溢出。寫入字符數組的某一部分：write(char[]?cbuf, int?off, int?len)，寫入字符串：write(String?str)，寫入字符串的某一部分：write(String?str, int?off, int?len)
?
三、讀取字符流
- 創建一個文件讀取流對象，和指定名稱的文件相關聯。要保證該文件已經存在，若不存在，將會發生異常FileNotFoundException。
- 調用讀取流對象的read()方法。read()：一次讀一個字符，且會繼續往下讀。（方法1）
read()讀取單個字符。read(char[]?cbuf)將字符讀入數組。（方法2）其實都是按照每次只讀取一個字符的方式讀取的，只是讀到數組中會把讀取到的數據存放在數組中，起到一個臨時緩存的作用，提高了讀取效率。
- 演示1：
- public static void main(String[] args) throws IOException {
- FileReader fr = new FileReader("demo.txt");
- int ch = 0;
- while((ch=fr.read())!=-1){// abcde讀5次
- System.out.println((char)ch);
- fr.close();
- }
- 演示2：
- public class FileReaderDemo2 {
- public static void main(String[] args) throws IOException {
- FileReader fr = new FileReader("demo.txt");
- /*
- * 使用read(char[])讀取文本文件數據。
- *
- * 先創建字符數組。
- */
- char[] buf = new char[1024];
- int len = 0;
- while((len=fr.read(buf))!=-1){ // abcde讀1次，提高效率，是一個數組一個數組的讀
- System.out.println(new String(buf,0,len));
- }
- /*
- int num = fr.read(buf);//將讀取到的字符存儲到數組中。讀到幾個幾個變成數組
- System.out.println(num+":"+new String(buf,0,num));
- int num1 = fr.read(buf);//將讀取到的字符存儲到數組中。
- System.out.println(num1+":"+new String(buf,0,num1));
- int num2 = fr.read(buf);//將讀取到的字符存儲到數組中。
- System.out.println(num2+":"+new String(buf));
- */
- ???fr.close();?
- }
四、文件的拷貝：
原理：其實就是將磁盤下的文件數據讀取出來，然后寫入磁盤的一個文件中
步驟：
1、在硬盤上創建一個文件，用于存儲讀取出來的文件數據
2、定義讀取流和文件關聯
3、通過不斷讀寫完成數據存儲
方式一：讀取一個字符，存入一個字符
方式二：先將讀取的數據存入到內存中，再將存入的字符取出寫入硬盤
4、關閉流資源：輸入流資源和輸出流資源。
第三 ?字符緩沖區
一、寫入緩沖區BufferedWriter二、讀取流緩沖區BufferedReader
該緩沖區提供了一個一次讀一行的方法readLine()，方便與對文本數據的獲取，當返回null時，表示讀到文件末尾。
? ? ? readLine()方法返回的時只返回回車符之前的數據內容，并不返回回車符，即讀取的內容中不包含任何行終止符（回車符和換行符）。
--->readLine()方法原理：無論是讀一行，或讀取多個字符，其實最終都是在硬盤上一個一個讀取。所以最終使用的還是read方法一次讀一個
三、通過緩沖技術提高效率復制文件：
四、自定義緩沖區其實就是模擬一個BufferedReader.?* 分析：?* 緩沖區中無非就是封裝了一個數組，并對外提供了更多的方法對數組進行訪問。?其實這些方法最終操作的都是數組的角標。?*?* 緩沖的原理：?* 其實就是從源中獲取一批數據裝進緩沖區中。在從緩沖區中不斷的取出一個一個數據。?*?在此次取完后，在從源中繼續取一批數據進緩沖區。?當源中的數據取光時，用-1作為結束標記。
在BufferedReader中有個直接的子類LineNumberReader，其中有特有的方法獲取和設置行號：
setLineNumber()和getLineNumber()
第四 ?裝飾設計模式
裝飾設計模式： (buffer就是裝飾設計模式)?對一組對象的功能進行增強時，就可以使用該模式進行問題的解決。??裝飾和繼承都能實現一樣的特點：進行功能的擴展增強。?有什么區別呢？?首先有一個繼承體系。Writer （抽取了一個寫的）?|--TextWriter?（隨便寫的）:用于操作文本?|--MediaWriter：用于操作媒體。?想要對操作的動作進行效率的提高。按照面向對象，可以通過繼承對具體的進行功能的擴展。效率提高需要加入緩沖技術。?Writer?|--TextWriter:用于操作文本? |--BufferTextWriter:加入了緩沖技術的操作文本的對象。?|--MediaWriter：用于操作媒體。? |--BufferMediaWriter:到這里就哦了。但是這樣做好像并不理想。如果這個體系進行功能擴展，有多了流對象。那么這個流要提高效率，是不是也要產生子類呢？是。這時就會發現只為提高功能，進行的繼承，導致繼承體系越來越臃腫。不夠靈活。重新思考這個問題？既然加入的都是同一種技術--緩沖。前一種是讓緩沖和具體的對象相結合。可不可以將緩沖進行單獨的封裝，哪個對象需要緩沖就將哪個對象和緩沖關聯。Writer?|--TextWriter:用于操作文本?|--MediaWriter：用于操作媒體。?|--BufferWriter:用于提高效率。
??裝飾比繼承靈活。?特點：裝飾類和被裝飾類都必須所屬同一個接口或者父類。?有個類想要增強，可以用裝飾設計模式，把被裝飾的類往里傳進來就可以
第五 ?字節流
一、概述：
1、字節流和字符流的原理是相似的，而字符流是基于字節流的，字節流可以操作如媒體等其他數據，如媒體（MP3，圖片，視頻）等
2、由于媒體數據中都是以字節存儲的，所以，字節流對象可直接對媒體進行操作，而不用再進行刷流動作。
3、InputStream ? ? ---> ?輸入流（讀） ?OutputStream ?---> ?輸出流（寫）
4、為何不用進行刷流動作：因為字節流操作的是字節，即數據的最小單位，不需要像字符流一樣要進行轉換為字節。可直接將字節寫入到指定文件中，但是需要在寫代碼的時候，如果有字符串，要將字符串轉為字節數組再進行操作。
5、FileInputStream特有方法：int available() ---> ?返回數據字節的長度，包含終止符
在定義字節數組長度的時候，可以用到這個方法：byte[] = new byte[fos.available()] ? （fos為字節流對象）但是，對于這個方法要慎用，如果字節過大，超過jvm所承受的大小（一般內存為64M），就會內存溢出。
實例：思路：
1、用字節流讀取流對象和媒體文件相關聯
2、用字節寫入流對象，創建一個媒體文件，用于存儲獲取到的媒體文件數據
3、通過循環讀寫，完成數據的存儲
4、關閉資源
1、緩沖區的出現無非就是提高了流的讀寫效率，當然也就是因為這樣，所以緩沖區的使用頻率也是相當高的，所以要做必要性的掌握。
2、字節流緩沖區讀寫的特點：
這里沒有什么特殊的讀寫方法，就是read()讀一個字節，read(byte[])讀數組的方法。寫write(int?b)寫一個自己，write(byte[])寫數組的方法。
注：需要注意個地方，write方法只寫出二進制的最后八位。原理：將數據拷貝一部分，讀取一部分，循環，直到數據全部讀取完畢。
1）先從數據中抓取固定數組長度的字節，存入定義的數組中，再通過然后再通過read()方法讀取數組中的元素，存入緩沖區
2）循環這個動作，知道最后取出一組數據存入數組，可能數組并未填滿，同樣也取出包含的元素
3）每次取出的時候，都有一個指針在移動，取到數組結尾就自動回到數組頭部，這樣指針在自增
4）取出的時候，數組中的元素再減少，取出一個，就減少一個，直到減到0即數組取完
5）到了文件的結尾處，存入最后一組數據，當取完數組中的元素，就會減少到0，這是全部數據就取完了
3、自定義字節緩沖區：當byte中的八位全為1的時候是byte的-1，提升為int類型，就變為int型的-1，為-1時程序就停止循環了，read循環條件就結束了，變為-1的原因是由于在提升時，將byte的八位前都補的是1，即32位的數都是1，即為int型的-1了。如何保證提升后的最后八位仍為1呢？就需要將前24位補0，就可以保留原字節數據不變，又可以避免轉為int型出現-1的情況；
那么要如何做呢？
這就需要將提升為int的數據和前24位為0，后八位仍為原字節數據的這個值做與運算。即和255做與運算即可。說到了這里應該也明白了為什么Read方法返回值為int類型了。
第六 ?轉換流
轉換流：轉換流可以實現字節數據和字符數據的相互轉換方便與操作，而且在轉換的時候可以指定編碼，這也是該流最具特色的地方。：InputStreamReader 是字節流通向字符流的橋梁
OutputStreamWriter 是字符流通向字節流的橋梁
轉換流的子類和轉換流的區別？InputStreamReader ? 字節-->字符??|--FileReader : 字節流+本地默認碼表。OutputStreamWriter ?字符-->字節?|--FileWriter?
什么時候使用轉換流呢？1，源或者目的對應的設備是字節流，但是操作的卻是文本數據，可以使用轉換作為橋梁。提高對文本操作的便捷。2，一旦操作文本涉及到具體的指定編碼表時，必須使用轉換流 。BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));
字符流轉字節流：
獲取鍵盤輸入：鍵盤輸入都是字節，所以用到字節流與標準輸入流相關聯就可以把輸入的數據獲取到流中，以達到數據的操作效果。
第七 ?流的操作規律
之所以要弄清楚這個規律，是因為流對象太多，開發時不知道用哪個對象合適。想要知道開發時用到哪些對象。只要通過四個明確即可。1，明確源和目的(匯)?源：InputStream ?Reader?目的：OutputStream ?Writer2，明確數據是否是純文本數據。?源：是純文本：Reader? 否：InputStream?目的：是純文本 Writer? 否：OutputStream??到這里，就可以明確需求中具體要使用哪個體系。?3，明確具體的設備。?源設備：? 硬盤：File? 鍵盤：System.in? 內存：數組? 網絡：Socket流??目的設備：? 硬盤：File? 控制臺：System.out? 內存：數組? 網絡：Socket流4，是否需要其他額外功能。?1，是否需要高效(緩沖區);? 是，就加上buffer.?2，轉換。?需求1：復制一個文本文件。?1,明確源和目的。? 源：InputStream Reader? 目的：OutputStream ?Writer?2,是否是純文本？? 是！? 源：Reader? 目的：Writer??3,明確具體設備。? 源：? ?硬盤：File? 目的：? ?硬盤：File?? FileReader fr = new FileReader("a.txt");? FileWriter fw = new FileWriter("b.txt");??4,需要額外功能嗎？? 需要，需要高效。? BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));? BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));?================================================需求2：讀取鍵盤錄入信息，并寫入到一個文件中。??1,明確源和目的。? 源：InputStream Reader? 目的：OutputStream ?Writer?2，是否是純文本呢？? 是，? 源：Reader? 目的：Writer?3，明確設備? 源：? ?鍵盤。System.in? 目的：? ?硬盤。File? ?? InputStream in = System.in;? FileWriter fw = new FileWriter("b.txt");? 這樣做可以完成，但是麻煩。將讀取的字節數據轉成字符串。再由字符流操作。?4，需要額外功能嗎？? 需要。轉換。 將字節流轉成字符流。因為名確的源是Reader，這樣操作文本數據做便捷。? ?所以要將已有的字節流轉成字符流。使用字節-->字符 。InputStreamReader? InputStreamReader isr = new InputStreamReader(System.in);? FileWriter fw = new FileWriter("b.txt");?? 還需要功能嗎？? 需要：想高效。? BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));? BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));?? ??===================================================?需求3：將一個文本文件數據顯示在控制臺上。?1,明確源和目的。? 源：InputStream Reader? 目的：OutputStream ?Writer?2，是否是純文本呢？? 是，? 源：Reader? 目的：Writer?3，明確具體設備? 源：? ?硬盤：File? 目的：? ?控制臺：System.out? ?? FileReader fr = new FileReader("a.txt");? OutputStream out = System.out;//PrintStream?4，需要額外功能嗎？? 需要，轉換。? FileReader fr= new FileReader("a.txt");? OutputStreamWriter osw = new OutputStreamWriter(System.out);? 需要，高效。? BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));? BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));?================================================================需求4：讀取鍵盤錄入數據，顯示在控制臺上。?1,明確源和目的。? 源：InputStream Reader? 目的：OutputStream ?Writer?2，是否是純文本呢？? 是，? 源：Reader? 目的：Writer?3，明確設備。? 源：? ?鍵盤：System.in? 目的：? ?控制臺：System.out?? InputStream in = System.in;? OutputStream out = System.out;??4，明確額外功能？? 需要轉換，因為都是字節流，但是操作的卻是文本數據。? 所以使用字符流操作起來更為便捷。? InputStreamReader isr = new InputStreamReader(System.in);? OutputStreamWriter osw = new OutputStreamWriter(System.out);?? 為了將其高效。? BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));? BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));??============================================================5，將一個中文字符串數據按照指定的編碼表寫入到一個文本文件中.??1，目的。OutputStream，Writer?2，是純文本，Writer。?3，設備：硬盤File?FileWriter fw = new FileWriter("a.txt");?fw.write("你好");??注意：既然需求中已經明確了指定編碼表的動作。?那就不可以使用FileWriter，因為FileWriter內部是使用默認的本地碼表。?只能使用其父類。OutputStreamWriter.?OutputStreamWriter接收一個字節輸出流對象，既然是操作文件，那么該對象應該是FileOutputStream??OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName（編碼）);??需要高效嗎？?BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));??演示：將一個中文字符串數據按照指定的編碼表寫入到一個文本文件中.?寫：
讀：
?
來自為知筆記(Wiz)
轉載于:https://www.cnblogs.com/sixrain/p/4912372.html
總結
以上是生活随笔為你收集整理的14：IO之字符字节流的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 汤的最好吃的做法 这样做营养又健康
- 下一篇： DP(优化) UVALive 6073