为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区
image.png

  • 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：
    • BufferedInputStream和BufferedOutputStream
    • BufferedReader和BufferedWriter
  • 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
  • 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
  • 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流
  • 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
  • flush()方法的使用：手动将buffer中内容写入文件
  • 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出。

image.png

1、缓冲流(字节型)实现非文本文件的复制

  1. import org.junit.Test;
  3. import java.io.*;
  5. /**
  6.  * 处理流之一：缓冲流的使用
  7.  *
  8.  *  1.缓冲流：
  9.  *  BufferedInputStream
  10.  *  BufferedOutputStream
  11.  *  BufferedReader
  12.  *  BufferedWriter
  13.  */
  14. public class BufferedTest {
  16.     /**
  17.      * 实现非文本文件的复制
  18.      */
  19.     @Test
  20.     public void BufferedStreamTest(){
  21.         BufferedInputStream bis = null;
  22.         BufferedOutputStream bos = null;
  24.         try {
  25.             //1.造文件
  26.             File srcFile = new File("爱情与友情.jpg");
  27.             File destFile = new File("爱情与友情3.jpg");
  28.             //2.造流
  29.             //2.1 造节点流
  30.             FileInputStream fis = new FileInputStream((srcFile));
  31.             FileOutputStream fos = new FileOutputStream(destFile);
  32.             //2.2 造缓冲流
  33.             bis = new BufferedInputStream(fis);
  34.             bos = new BufferedOutputStream(fos);
  36.             //3.复制的细节：读取、写入
  37.             byte[] buffer = new byte[10];
  38.             int len;
  39.             while((len = bis.read(buffer)) != -1){
  40.                 bos.write(buffer,0,len);
  41. //                bos.flush();//刷新缓冲区
  42.             }
  43.         } catch (IOException e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             //4.资源关闭
  47.             //要求：先关闭外层的流，再关闭内层的流
  48.             if(bos != null){
  49.                 try {
  50.                     bos.close();
  51.                 } catch (IOException e) {
  52.                     e.printStackTrace();
  53.                 }
  55.             }
  56.             if(bis != null){
  57.                 try {
  58.                     bis.close();
  59.                 } catch (IOException e) {
  60.                     e.printStackTrace();
  61.                 }
  62.             }
  63.             //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
  64. //        fos.close();
  65. //        fis.close();
  66.         }
  67.     }
  68. }

2、缓冲流与节点流读写速度对比

  1. import org.junit.Test;
  2. import java.io.*;
  3. /**
  4.  * 处理流之一：缓冲流的使用
  5.  *
  6.  *  1.缓冲流：
  7.  *  BufferedInputStream
  8.  *  BufferedOutputStream
  9.  *  BufferedReader
  10.  *  BufferedWriter
  11.  *
  12.  *  2.作用：提供流的读取、写入的速度
  13.  *    提高读写速度的原因：内部提供了一个缓冲区
  14.  *
  15.  *  3. 处理流，就是“套接”在已有的流的基础上。
  16.  *
  17.  */
  18. public class BufferedTest {
  20.     //实现文件复制的方法
  21.     public void copyFileWithBuffered(String srcPath,String destPath){
  22.         BufferedInputStream bis = null;
  23.         BufferedOutputStream bos = null;
  25.         try {
  26.             //1.造文件
  27.             File srcFile = new File(srcPath);
  28.             File destFile = new File(destPath);
  29.             //2.造流
  30.             //2.1 造节点流
  31.             FileInputStream fis = new FileInputStream((srcFile));
  32.             FileOutputStream fos = new FileOutputStream(destFile);
  33.             //2.2 造缓冲流
  34.             bis = new BufferedInputStream(fis);
  35.             bos = new BufferedOutputStream(fos);
  37.             //3.复制的细节：读取、写入
  38.             byte[] buffer = new byte[1024];
  39.             int len;
  40.             while((len = bis.read(buffer)) != -1){
  41.                 bos.write(buffer,0,len);
  42.             }
  43.         } catch (IOException e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             //4.资源关闭
  47.             //要求：先关闭外层的流，再关闭内层的流
  48.             if(bos != null){
  49.                 try {
  50.                     bos.close();
  51.                 } catch (IOException e) {
  52.                     e.printStackTrace();
  53.                 }
  55.             }
  56.             if(bis != null){
  57.                 try {
  58.                     bis.close();
  59.                 } catch (IOException e) {
  60.                     e.printStackTrace();
  61.                 }
  63.             }
  64.             //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
  65. //        fos.close();
  66. //        fis.close();
  67.         }
  68.     }
  70.     @Test
  71.     public void testCopyFileWithBuffered(){
  72.         long start = System.currentTimeMillis();
  74.         String srcPath = "C:\\Users\\29433\\Desktop\\book.flv";
  75.         String destPath = "C:\\Users\\29433\\Desktop\\book1.flv";
  78.         copyFileWithBuffered(srcPath,destPath);
  81.         long end = System.currentTimeMillis();
  83.         System.out.println("复制操作花费的时间为：" + (end - start));//1
  84.     }
  86. }

3、缓冲流(字符型)实现文本文件的复制

  1. import org.junit.Test;
  2. import java.io.*;
  4. public class BufferedTest {
  5.   /**
  6.      * 使用BufferedReader和BufferedWriter实现文本文件的复制
  7.      */
  8.     @Test
  9.     public void test4(){
  10.         BufferedReader br = null;
  11.         BufferedWriter bw = null;
  12.         try {
  13.             //创建文件和相应的流
  14.             br = new BufferedReader(new FileReader(new File("dbcp.txt")));
  15.             bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
  17.             //读写操作
  18.             //方式一：使用char[]数组
  19. //            char[] cbuf = new char[1024];
  20. //            int len;
  21. //            while((len = br.read(cbuf)) != -1){
  22. //                bw.write(cbuf,0,len);
  23. //    //            bw.flush();
  24. //            }
  26.             //方式二：使用String
  27.             String data;
  28.             while((data = br.readLine()) != null){
  29.                 //方法一：
  30. //                bw.write(data + "\n");//data中不包含换行符
  31.                 //方法二：
  32.                 bw.write(data);//data中不包含换行符
  33.                 bw.newLine();//提供换行的操作
  34.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         } finally {
  39.             //关闭资源
  40.             if(bw != null){
  42.                 try {
  43.                     bw.close();
  44.                 } catch (IOException e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.             if(br != null){
  49.                 try {
  50.                     br.close();
  51.                 } catch (IOException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.         }
  56.     }
  57. }

4、缓冲流课后练习

image.png

  1. package git;
  3. import org.junit.Test;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  9. public class PicTest {
  11.     //图片的加密
  12.     @Test
  13.     public void test() {
  14.         FileInputStream fis = null;
  15.         FileOutputStream fos = null;
  16.         try {
  17.             fis = new FileInputStream("爱情与友情.jpg");
  18.             fos = new FileOutputStream("爱情与友情secret.jpg");
  20.             byte[] buffer = new byte[20];
  21.             int len;
  22.             while ((len = fis.read(buffer)) != -1) {
  23.                 //字节数组进行修改
  24.                 //错误的
  25.                 //            for(byte b : buffer){
  26.                 //                b = (byte) (b ^ 5);
  27.                 //            }
  29.                 //正确的
  30.                 for (int i = 0; i < len; i++) {
  31.                     buffer[i] = (byte) (buffer[i] ^ 5);
  32.                 }
  34.                 fos.write(buffer, 0, len);
  35.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         } finally {
  39.             if (fos != null) {
  40.                 try {
  41.                     fos.close();
  42.                 } catch (IOException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.             if (fis != null) {
  47.                 try {
  48.                     fis.close();
  49.                 } catch (IOException e) {
  50.                     e.printStackTrace();
  51.                 }
  52.             }
  53.         }
  55.     }
  57.     //图片的解密
  58.     @Test
  59.     public void test2() {
  61.         FileInputStream fis = null;
  62.         FileOutputStream fos = null;
  63.         try {
  64.             fis = new FileInputStream("爱情与友情secret.jpg");
  65.             fos = new FileOutputStream("爱情与友情4.jpg");
  67.             byte[] buffer = new byte[20];
  68.             int len;
  69.             while ((len = fis.read(buffer)) != -1) {
  70.                 //字节数组进行修改
  71.                 //错误的
  72.                 //            for(byte b : buffer){
  73.                 //                b = (byte) (b ^ 5);
  74.                 //            }
  76.                 //正确的
  77.                 for (int i = 0; i < len; i++) {
  78.                     buffer[i] = (byte) (buffer[i] ^ 5);
  79.                 }
  81.                 fos.write(buffer, 0, len);
  82.             }
  83.         } catch (IOException e) {
  84.             e.printStackTrace();
  85.         } finally {
  86.             if (fos != null) {
  87.                 try {
  88.                     fos.close();
  89.                 } catch (IOException e) {
  90.                     e.printStackTrace();
  91.                 }
  92.             }
  93.             if (fis != null) {
  94.                 try {
  95.                     fis.close();
  96.                 } catch (IOException e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.         }
  102.     }
  103. }