15、IO (轉換流、緩沖流)
阿新 • • 發佈：2019-02-05
windows版本 你好 -- 輸入 rar ole 不包含 ray 效率比較
轉換流概述
* A: 轉換流概述
* a: 轉換流概述
* OutputStreamWriter 是字符流通向字節流的橋梁：可使用指定的字符編碼表，將要寫入流中的字符編碼成字節
* 將字符串按照指定的編碼表轉成字節，在使用字節流將這些字節寫出去?
轉換流_字符轉字節的過程
* A: 轉換流_字符轉字節的過程
* a.圖解
* 詳見day24_source/轉換流.JPG圖片?
OutputStreamWriter寫文本文件
* A: OutputStreamWriter寫文本文件 * a: OutputStreamWriter * java.io.OutputStreamWriter 繼承Writer類 * 就是一個字符輸出流，寫文本文件 * write()字符，字符數組，字符串 * 字符通向字節的橋梁，將字符流轉字節流 * OutputStreamWriter 使用方式 * 構造方法： * OutputStreamWriter(OuputStream out)接收所有的字節輸出流 * 字節輸出流： FileOutputStream * OutputStreamWriter(OutputStream out, String charsetName) * String charsetName 傳遞編碼表名字 GBK UTF-8 * OutputStreamWriter 有個子類， FileWriter * b: 案例代碼 public class OutputStreamWriterDemo { public static void main(String[] args)throws IOException { // writeGBK(); writeUTF(); } /* * 轉換流對象OutputStreamWriter寫文本 * 采用UTF-8編碼表寫入 */ public static void writeUTF()throws IOException{ //創建字節輸出流，綁定文件 FileOutputStream fos = new FileOutputStream("c:\\utf.txt"); //創建轉換流對象，構造方法保證字節輸出流，並指定編碼表是UTF-8 OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8"); osw.write("你好"); osw.close(); } /* * 轉換流對象 OutputStreamWriter寫文本 * 文本采用GBK的形式寫入 */ public static void writeGBK()throws IOException{ //創建字節輸出流，綁定數據文件 FileOutputStream fos = new FileOutputStream("c:\\gbk.txt"); //創建轉換流對象，構造方法，綁定字節輸出流，使用GBK編碼表 OutputStreamWriter osw = new OutputStreamWriter(fos); //轉換流寫數據 osw.write("你好"); osw.close(); } }
轉換流_字節轉字符流過程
* A: 轉換流_字節轉字符流過程 * a: InputStreamReader * java.io.InputStreamReader 繼承 Reader * 字符輸入流，讀取文本文件 * 字節流向字符的敲了，將字節流轉字符流 * 讀取的方法: * read() 讀取1個字符，讀取字符數組 * 技巧 * OuputStreamWriter寫了文件 * InputStreamReader讀取文件 * OutputStreamWriter(OutputStream out)所有字節輸出流 * InputStreamReader(InputStream in) 接收所有的字節輸入流 * 可以傳遞的字節輸入流： FileInputStream * InputStreamReader(InputStream in,String charsetName) 傳遞編碼表的名字 * b: 圖解 * 詳見day24_source/轉換流.JPG圖片
InputSteamReader讀取文本文件
* A: InputSteamReader讀取文本文件 * a: 案例代碼 public class InputStreamReaderDemo { public static void main(String[] args) throws IOException { // readGBK(); readUTF(); } /* * 轉換流,InputSteamReader讀取文本 * 采用UTF-8編碼表,讀取文件utf */ public static void readUTF()throws IOException{ //創建自己輸入流,傳遞文本文件 FileInputStream fis = new FileInputStream("c:\\utf.txt"); //創建轉換流對象,構造方法中,包裝字節輸入流,同時寫編碼表名 InputStreamReader isr = new InputStreamReader(fis,"UTF-8"); char[] ch = new char[1024]; int len = isr.read(ch); System.out.println(new String(ch,0,len)); isr.close(); } /* * 轉換流,InputSteamReader讀取文本 * 采用系統默認編碼表,讀取GBK文件 */ public static void readGBK()throws IOException{ //創建自己輸入流,傳遞文本文件 FileInputStream fis = new FileInputStream("c:\\gbk.txt"); //創建轉換流對象,構造方法,包裝字節輸入流 InputStreamReader isr = new InputStreamReader(fis); char[] ch = new char[1024]; int len = isr.read(ch); System.out.println(new String(ch,0,len)); isr.close(); } }
?
轉換流子類父類的區別
* A: 轉換流子類父類的區別
* a: 繼承關系
OutputStreamWriter:
|--FileWriter:
InputStreamReader:
|--FileReader;
* b: 區別
* OutputStreamWriter和InputStreamReader是字符和字節的橋梁：也可以稱之為字符轉換流。字符轉換流原理：字節流+編碼表。
* FileWriter和FileReader：作為子類，僅作為操作字符文件的便捷類存在。
當操作的字符文件，使用的是默認編碼表時可以不用父類，而直接用子類就完成操作了，簡化了代碼。
* 以下三句話功能相同
* InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默認字符集。
* InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。
* FileReader fr = new FileReader("a.txt");緩沖流概述
* A: 緩沖流概述
* a: 概述
* 可提高IO流的讀寫速度
* 分為字節緩沖流與字符緩沖流 ?
字節輸出流緩沖流BufferedOutputStream
* A: 字節輸出流緩沖流BufferedOutputStream
* a: BufferedOutputStream
* 字節輸出流的緩沖流
* java.io.BufferedOuputStream 作用: 提高原有輸出流的寫入效率
* BufferedOuputStream 繼承 OutputStream
* 方法,寫入 write 字節,字節數組
* 構造方法:
* BufferedOuputStream(OuputStream out)
* 可以傳遞任意的字節輸出流, 傳遞的是哪個字節流,就對哪個字節流提高效率
* b: 案例代碼
public class BufferedOutputStreamDemo {
public static void main(String[] args)throws IOException {
//創建字節輸出流,綁定文件
//FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");
//創建字節輸出流緩沖流的對象,構造方法中,傳遞字節輸出流
BufferedOutputStream bos = new
BufferedOutputStream(new FileOutputStream("c:\\buffer.txt"));
bos.write(55);
byte[] bytes = "HelloWorld".getBytes();
bos.write(bytes);
bos.write(bytes, 3, 2);
bos.close();
}
}字節輸入流緩沖流BufferedInputStream
* A: 字節輸入流緩沖流BufferedInputStream
* a: BufferedInputStream
* 字節輸入流的緩沖流
* 繼承InputStream,標準的字節輸入流
* 讀取方法 read() 單個字節,字節數組
* 構造方法:
* BufferedInputStream(InputStream in)
* 可以傳遞任意的字節輸入流,傳遞是誰,就提高誰的效率
* 可以傳遞的字節輸入流 FileInputStream
* b: 案例代碼
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException{
//創建字節輸入流的緩沖流對象,構造方法中包裝字節輸入流,包裝文件
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
byte[] bytes = new byte[10];
int len = 0 ;
while((len = bis.read(bytes))!=-1){
System.out.print(new String(bytes,0,len));
}
bis.close();
}
}
?
四種文件復制方式的效率比較
* A：四種文件復制方式的效率比較
* a: 四中復制方式
* 字節流讀寫單個字節 125250 毫秒
* 字節流讀寫字節數組 193 毫秒 OK
* 字節流緩沖區流讀寫單個字節 1210 毫秒
* 字節流緩沖區流讀寫字節數組 73 毫秒 OK
* b: 案例代碼
public class Copy {
public static void main(String[] args)throws IOException {
long s = System.currentTimeMillis();
copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
long e = System.currentTimeMillis();
System.out.println(e-s);
}
/*
* 方法,實現文件復制
* 4. 字節流緩沖區流讀寫字節數組
*/
public static void copy_4(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.close();
bis.close();
}
/*
* 方法,實現文件復制
* 3. 字節流緩沖區流讀寫單個字節
*/
public static void copy_3(File src,File desc)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
int len = 0 ;
while((len = bis.read())!=-1){
bos.write(len);
}
bos.close();
bis.close();
}
/*
* 方法,實現文件復制
* 2. 字節流讀寫字節數組
*/
public static void copy_2(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = fis.read(bytes))!=-1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}
/*
* 方法,實現文件復制
* 1. 字節流讀寫單個字節
*/
public static void copy_1(File src,File desc)throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0 ;
while((len = fis.read())!=-1){
fos.write(len);
}
fos.close();
fis.close();
}
}
?
字符輸出流緩沖流BufferedWriter
* A: 字符輸出流緩沖流BufferedWriter
* a: BufferedWriter
* 字符輸出流緩沖區流
* java.io.BufferedWriter 繼承 Writer
* 寫入方法 write () 單個字符,字符數組,字符串
* 構造方法:
* BufferedWriter(Writer w)傳遞任意字符輸出流
* 傳遞誰,就高效誰
* 能傳遞的字符輸出流 FileWriter, OutputStreamWriter
* b: 案例代碼
public class BufferedWrierDemo {
public static void main(String[] args) throws IOException{
//創建字符輸出流,封裝文件
FileWriter fw = new FileWriter("c:\\buffer.txt");
BufferedWriter bfw = new BufferedWriter(fw);
bfw.write(100);
bfw.flush();
bfw.write("你好".toCharArray());
bfw.flush();
bfw.write("你好");
bfw.flush();
bfw.write("我好好");
bfw.flush();
bfw.write("大家都好");
bfw.flush();
bfw.close();
}
}
字符輸出流緩沖流BufferedWriter特有方法newLine
* A: 字符輸出流緩沖流BufferedWriter特有方法newLine
* a: 方法介紹
* void newLine() 寫換行
* newLine()文本中換行, \r\n也是文本換行
* 方法具有平臺無關性
* Windows \r\n
* Linux \n
* newLine()運行結果,和操作系統是相互關系
* JVM: 安裝的是Windows版本,newLine()寫的就是\r\n
* 安裝的是Linux版本,newLine()寫的就是\n
/*
* 將數據源 c:\\a.txt
* 復制到 d:\\a.txt 數據目的
* 字節輸入流,綁定數據源
* 字節輸出流,綁定數據目的
*
* 輸入,讀取1個字節
* 輸出,寫1個字節
*/
* b: 案例代碼
public class BufferedWrierDemo {
public static void main(String[] args) throws IOException{
//創建字符輸出流,封裝文件
FileWriter fw = new FileWriter("c:\\buffer.txt");
BufferedWriter bfw = new BufferedWriter(fw);
bfw.write(100);
bfw.flush();
bfw.write("你好".toCharArray());
bfw.flush();
bfw.write("你好");
bfw.newLine();
bfw.flush();
bfw.write("我好好");
bfw.newLine();
bfw.flush();
bfw.write("大家都好");
bfw.flush();
bfw.close();
}
}
字符輸入流緩沖流BufferedReader
* A: 字符輸入流緩沖流BufferedReader
* a: 概述
* 從字符輸入流中讀取文本，緩沖各個字符，從而實現字符、數組和行的高效讀取
* public String readLine() 讀取一個文本行，包含該行內容的字符串，不包含任何行終止符，如果已到達流末尾，則返回 null
字符輸入流緩沖流BufferedReader讀取文本行
* A: 字符輸入流緩沖流BufferedReader讀取文本行
* a: BufferedReader
* 字符輸入流緩沖流
* java.io.BufferedReader 繼承 Reader
* 讀取功能 read() 單個字符,字符數組
* 構造方法:
* BufferedReader(Reader r)
* 可以任意的字符輸入流
FileReader InputStreamReader
* BufferedReader自己的功能
* String readLine() 讀取文本行 \r\n
* 方法讀取到流末尾,返回null
* b: 小特點
* 獲取內容的方法一般都有返回值
* int 沒有返回的都是負數
* 引用類型 找不到返回null
* boolean 找不到返回false
* c: 案例代碼
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
int lineNumber = 0;
//創建字符輸入流緩沖流對象,構造方法傳遞字符輸入流,包裝數據源文件
BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
//調用緩沖流的方法 readLine()讀取文本行
//循環讀取文本行, 結束條件 readLine()返回null
String line = null;
while((line = bfr.readLine())!=null){
lineNumber++;
System.out.println(lineNumber+" "+line);
}
bfr.close();
}
}
/*
* String line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
line = bfr.readLine();
System.out.println(line);
*/
字符流緩沖區流復制文本文件
* A: 字符流緩沖區流復制文本文件
* a: 案例代碼
/*
* 使用緩沖區流對象,復制文本文件
* 數據源 BufferedReader+FileReader 讀取
* 數據目的 BufferedWriter+FileWriter 寫入
* 讀取文本行, 讀一行,寫一行,寫換行
*/
public class Copy_1 {
public static void main(String[] args) throws IOException{
BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));
BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
//讀取文本行, 讀一行,寫一行,寫換行
String line = null;
while((line = bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
bfw.close();
bfr.close();
}
}
?
IO流對象的操作規律
* A: IO流對象的操作規律
* a: 明確一：要操作的數據是數據源還是數據目的。
* 源：InputStream Reader
* 目的：OutputStream Writer
* 先根據需求明確要讀，還是要寫。
* b: 明確二：要操作的數據是字節還是文本呢？
* 源：
* 字節：InputStream
* 文本：Reader
* 目的：
* 字節：OutputStream
* 文本：Writer
* c: 明確三：明確數據所在的具體設備。
* 源設備：
* 硬盤：文件 File開頭。
* 內存：數組，字符串。
* 鍵盤：System.in;
* 網絡：Socket
* 目的設備：
* 硬盤：文件 File開頭。
* 內存：數組，字符串。
* 屏幕：System.out
* 網絡：Socket
* 完全可以明確具體要使用哪個流對象。
* d: 明確四：是否需要額外功能呢？
* 額外功能：
* 轉換嗎？轉換流。InputStreamReader OutputStreamWriter
* 高效嗎？緩沖區對象。BufferedXXX
* 已經明確到了具體的體系上。
總結
15、IO (轉換流、緩沖流)