[TOC] # 字節緩沖流 字節緩沖流根據流的方向，共有2個 * 寫入數據到流中，字節緩沖輸出流 BufferedOutputStream * 讀取流中的數據，字節緩沖輸入流 BufferedInputStream 它們的內部都包含了一個緩沖區，通過緩沖區讀寫，就可以提高了IO流的讀寫速度 ## 字節緩沖輸出流BufferedOutputStream 通過字節緩沖流，進行文件的讀寫操作 寫數據到文件的操作 * 構造方法 public BufferedOutputStream(OutputStream out)創建一個新的緩沖輸出流，以將數據寫入指定的底層輸出流。 ~~~ public class BufferedOutputStreamDemo01 { public static void main(String[] args) throws IOException { //寫數據到文件的方法 write(); } /* * 寫數據到文件的方法 * 1,創建流 * 2，寫數據 * 3，關閉流 */ private static void write() throws IOException { //創建基本的字節輸出流 FileOutputStream fileOut = new FileOutputStream("abc.txt"); //使用高效的流，把基本的流進行封裝，實現速度的提升 BufferedOutputStream out = new BufferedOutputStream(fileOut); //2，寫數據 out.write("hello".getBytes()); //3，關閉流 out.close(); } } ~~~ ## 字節緩沖輸入流 BufferedInputStream 剛剛我們學習了輸出流實現了向文件中寫數據的操作，那么，現在我們完成讀取文件中數據的操作 * 構造方法 public BufferedInputStream(InputStream in) ~~~ /* * 從文件中讀取數據 * 1,創建緩沖流對象 * 2，讀數據，打印 * 3，關閉 */ private static void read() throws IOException { //1,創建緩沖流對象 FileInputStream fileIn = new FileInputStream("abc.txt"); //把基本的流包裝成高效的流 BufferedInputStream in = new BufferedInputStream(fileIn); //2，讀數據 int ch = -1; while ( (ch = in.read()) != -1 ) { //打印 System.out.print((char)ch); } //3，關閉 in.close(); } ~~~ ## 使用基本的流與高效的流完成復制文件 我們一直在說，高效的流速度快并高效，怎么體現呢？需要通過一個復制文件耗時的比較過程，來體驗一下高效流帶來的快感。 ~~~ /* * 需求：將d:\\test.avi文件進行復制 * 采用4種方式復制 * 方式1： 采用基本的流，一次一個字節的方式復制 共耗時 224613毫秒 * 方式2： 采用基本的流，一個多個字節的方式賦值 共耗時 327毫秒 * 方式3： 采用高效的流，一次一個字節的方式復制 共耗時 2047毫秒 * 方式4： 采用高效的流，一個多個字節的方式賦值 共耗時 96毫秒 * * 數據源： d:\\test.avi * 目的地1: d:\\copy1.avi * 目的地2: d:\\copy2.avi * 目的地3: d:\\copy3.avi * 目的地4: d:\\copy4.avi * * 實現的步驟： * 1，指定數據源 * 2，指定目的地 * 3，讀數據 * 4，寫數據 * 5，關閉流 * */ public class CopyAVI { public static void main(String[] args) throws IOException { //開始計時 long start = System.currentTimeMillis(); //方式1： 采用基本的流，一次一個字節的方式復制 //method1("d:\\test.avi", "d:\\copy1.avi"); //方式2： 采用基本的流，一個多個字節的方式賦值 //method2("d:\\test.avi", "d:\\copy2.avi"); //方式3： 采用高效的流，一次一個字節的方式復制 //method3("d:\\test.avi", "d:\\copy3.avi"); //方式4： 采用高效的流，一個多個字節的方式賦值 method4("d:\\test.avi", "d:\\copy4.avi"); //結束計時 long end = System.currentTimeMillis(); //打印耗時多少毫秒 System.out.println("共耗時 " +(end - start)+ "毫秒"); } //方式4： 采用高效的流，一個多個字節的方式賦值 private static void method4(String src, String dest) throws IOException { //1，指定數據源 BufferedInputStream in = new BufferedInputStream(new FileInputStream(src)); //2，指定目的地 BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest)); //3，讀數據 byte[] buffer = new byte[1024]; int len = -1; while ( (len = in.read(buffer)) != -1) { //4,寫數據 out.write(buffer, 0, len); } //5，關閉流 in.close(); out.close(); } //方式3： 采用高效的流，一次一個字節的方式復制 private static void method3(String src, String dest) throws IOException { //1，指定數據源 BufferedInputStream in = new BufferedInputStream(new FileInputStream(src)); //2，指定目的地 BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest)); //3，讀數據 int ch = -1; while ((ch=in.read()) != -1) { //4，寫數據 out.write(ch); } //5，關閉流 in.close(); out.close(); } //方式2： 采用基本的流，一個多個字節的方式賦值 private static void method2(String src, String dest) throws IOException { //1，指定數據源 FileInputStream in = new FileInputStream(src); //2，指定目的地 FileOutputStream out = new FileOutputStream(dest); //3，讀數據 byte[] buffer = new byte[1024]; int len = -1; while ( (len=in.read(buffer)) != -1) { //4，寫數據 out.write(buffer, 0, len); } //5，關閉流 in.close(); out.close(); } //方式1： 采用基本的流，一次一個字節的方式復制 private static void method1(String src, String dest) throws IOException { //1，指定數據源 FileInputStream in = new FileInputStream(src); //2，指定目的地 FileOutputStream out = new FileOutputStream(dest); //3，讀數據 int ch = -1; while (( ch=in.read()) != -1) { //4，寫數據 out.write(ch); } //5，關閉流 in.close(); out.close(); } } ~~~ # 字符緩沖流 * 字符緩沖輸入流 BufferedReader * 字符緩沖輸出流 BufferedWriter 完成文本數據的高效的寫入與讀取的操作 ## 字符緩沖輸出流 BufferedWriter 將文本寫入字符輸出流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入。 * 方法： void newLine() 根據當前的系統，寫入一個換行符 ~~~ /* * BufferedWriter 字符緩沖輸出流 * 方法 * public void newLine()寫入一個行分隔符 * * 需求： 通過緩沖輸出流寫入數據到文件 * 分析： * 1，創建流對象 * 2，寫數據 * 3，關閉流 * */ public class BufferedWriterDemo { public static void main(String[] args) throws IOException { //創建流 //基本字符輸出流 FileWriter fileOut = new FileWriter("file.txt"); //把基本的流進行包裝 BufferedWriter out = new BufferedWriter(fileOut); //2，寫數據 for (int i=0; i<5; i++) { out.write("hello"); out.newLine(); } //3,關閉流 out.close(); } } ~~~ ## 字符緩沖輸入流 BufferedReader 從字符輸入流中讀取文本，緩沖各個字符，從而實現字符、數組和行的高效讀取。 * 方法 public String readLine() 讀取一個文本行，包含該行內容的字符串，不包含任何行終止符，如果已到達流末尾，則返回 null ~~~ /* * BufferedReader 字符緩沖輸入流 * * 方法： * String readLine() * 需求：從文件中讀取數據，并顯示數據 */ public class BufferedReaderDemo { public static void main(String[] args) throws IOException { //1,創建流 BufferedReader in = new BufferedReader(new FileReader("file.txt")); //2，讀數據 //一次一個字符 //一次一個字符數組 //一次讀取文本中一行的字符串內容 String line = null; while( (line = in.readLine()) != null ){ System.out.println(line); } //3,關閉流 in.close(); } } ~~~ ## 使用字符緩沖流完成文本文件的復制 剛剛我們學習完了緩沖流，現在我們就使用字符緩沖流的特有功能，完成文本文件的復制 ~~~ /* * 采用高效的字符緩沖流，完成文本文件的賦值 * * 數據源： file.txt * 目的地： copyFile.txt * * 分析： * 1，指定數據源， 是數據源中讀數據，采用輸入流 * 2,指定目的地，是把數據寫入目的地，采用輸出流 * 3,讀數據 * 4，寫數據 * 5，關閉流 */ public class CopyTextFile { public static void main(String[] args) throws IOException { //1，指定數據源， 是數據源中讀數據，采用輸入流 BufferedReader in = new BufferedReader(new FileReader("file.txt")); //2,指定目的地，是把數據寫入目的地，采用輸出流 BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt")); //3,讀數據 String line = null; while ( (line = in.readLine()) != null ) { //4，寫數據 out.write(line); //寫入換行符號 out.newLine(); } //5，關閉流 out.close(); in.close(); } } ~~~