javajavase

缓冲流

引入目的

  • 作用：提升流的读取、写入的速度
  • 提高读写速度的原因：内部提供了一个缓冲区，默认情况下是8kb

缓冲流、转换流 - 图1
处理流与节点流的对比图示
缓冲流、转换流 - 图2
缓冲流、转换流 - 图3
缓冲流涉及到的类
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

使用说明

  • 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
  • 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组
  • 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流
  • 关闭流的顺序和打开流的顺序相反，只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
  • flush()方法的使用：手动将buffer中内容写入文件

  • 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

    使用BufferInputStream和BufferOutputStream实现文件的复制

    1. @Test
    2. public void BufferedStreamTest() throws FileNotFoundException {
    3.   BufferedInputStream bis = null;
    4.   BufferedOutputStream bos = null;
    5.   try {
    6.       // 1.造文件
    7.       File srcFile = new File("爱情与友情.jpg");
    8.       File destFile = new File("爱情与友情3.jpg");
    10.       // 2.造流
    11.       // 2.1 造节点流
    12.       FileInputStream fis = new FileInputStream((srcFile));
    13.       FileOutputStream fos = new FileOutputStream(destFile);
    14.       // 2.2 造缓冲流
    15.       bis = new BufferedInputStream(fis);
    16.       bos = new BufferedOutputStream(fos);
    18.       // 3.复制的细节：读取、写入
    19.       byte[] buffer = new byte[10];
    20.       int len;
    21.       while((len = bis.read(buffer)) != -1) {
    22.           bos.write(buffer, 0, len);
    23.           //                bos.flush();    // 刷新缓冲区
    24.       }
    26.   } catch (IOException e) {
    27.       e.printStackTrace();
    28.   } finally {
    29.       // 4.资源关闭
    30.       // 要求：先关闭外层的流，再关闭内层的流
    31.       if(bos != null){
    32.           try {
    33.               bos.close();
    34.           } catch (IOException e) {
    35.               e.printStackTrace();
    36.           }
    37.       }
    38.       if(bis != null){
    39.           try {
    40.               bis.close();
    41.           } catch (IOException e) {
    42.               e.printStackTrace();
    43.           }
    44.       }
    45.       // 说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
    46.       //        fos.close();
    47.       //        fis.close();
    48.   }
    49. }

    实现文件复制的方法 ```java public void copyFileWithBuffered(String srcPath, String destPath) { BufferedInputStream bis = null; BufferedOutputStream bos = null; try {

    1.   File srcFile = new File(srcPath);
    2.   File destFile = new File(destPath);
    4.   FileInputStream fis = new FileInputStream((srcFile));
    5.   FileOutputStream fos = new FileOutputStream(destFile);
    7.   bis = new BufferedInputStream(fis);
    8.   bos = new BufferedOutputStream(fos);
    10.   byte[] buffer = new byte[1024];
    11.   int len;
    12.   while((len = bis.read(buffer)) != -1){
    13.       bos.write(buffer,0,len);
    14.   }

    } catch (IOException e) {

    1.   e.printStackTrace();

    } finally {

    1.   if(bos != null){
    2.       try {
    3.           bos.close();
    4.       } catch (IOException e) {
    5.           e.printStackTrace();
    6.       }
    7.   }
    8.   if(bis != null){
    9.       try {
    10.           bis.close();
    11.       } catch (IOException e) {
    12.           e.printStackTrace();
    13.       }
    14.   }

    } }

@Test public void testCopyFileWithBuffered(){ long start = System.currentTimeMillis(); String srcPath = “C:\Users\Administrator\Desktop\01-视频.avi”; String destPath = “C:\Users\Administrator\Desktop\03-视频.avi”; copyFileWithBuffered(srcPath,destPath); long end = System.currentTimeMillis(); System.out.println(“复制操作花费的时间为：” + (end - start)); // 176 }

  1. <a name="xCWlf"></a>
  2. ### 使用BufferedReader和BufferedWriter实现文本文件的复制
  3. ```java
  4. @Test
  5. public void testBufferedReaderBufferedWriter(){
  6.     BufferedReader br = null;
  7.     BufferedWriter bw = null;
  8.     try {
  9.         br = new BufferedReader(new FileReader(new File("dbcp.txt")));
  10.         bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
  12.         // 读写操作
  13.         // 方式一：使用char[]数组
  14.         //            char[] cbuf = new char[1024];
  15.         //            int len;
  16.         //            while((len = br.read(cbuf)) != -1) {
  17.         //                bw.write(cbuf, 0, len);
  18.         //            }
  19.         //            bw.flush();
  21.         // 方式二：使用String
  22.         String data;
  23.         while((data = br.readLine()) != null){    //🔴
  24.             //方法一：
  25.             //            bw.write(data + "\n");    // data中不包含换行符
  26.             //方法二：
  27.             bw.write(data);    // data中不包含换行符
  28.             bw.newLine();    // 🔴提供换行的操作
  29.         }
  31.     } catch (IOException e) {
  32.         e.printStackTrace();
  33.     } finally {
  34.         if(bw != null){
  35.             try {
  36.                 bw.close();
  37.             } catch (IOException e) {
  38.                 e.printStackTrace();
  39.             }
  40.         }
  41.         if(br != null){
  42.             try {
  43.                 br.close();
  44.             } catch (IOException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }
  49. }

缓冲流实现复制操作

  1. public void copyFileWithBuffered(String srcPath,String destPath) {
  2.     BufferedInputStream bis = null;
  3.     BufferedOutputStream bos = null;
  4.     try {
  5.         File srcFile = new File(srcPath);
  6.         File destFile = new File(destPath);
  8.         FileInputStream fis = new FileInputStream((srcFile));
  9.         FileOutputStream fos = new FileOutputStream(destFile);
  11.         bis = new BufferedInputStream(fis);
  12.         bos = new BufferedOutputStream(fos);
  14.         byte[] buffer = new byte[1024];
  15.         int len;
  16.         while((len = bis.read(buffer)) != -1) {
  17.             bos.write(buffer, 0, len);
  18.         }
  19.     } catch (IOException e) {
  20.         e.printStackTrace();
  21.     } finally {
  22.         if(bos != null){
  23.             try {
  24.                 bos.close();
  25.             } catch (IOException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.         if(bis != null){
  30.             try {
  31.                 bis.close();
  32.             } catch (IOException e) {
  33.                 e.printStackTrace();
  34.             }
  35.         }
  36.     }
  37. }

练习

加密操作
将图片文件通过字节流读取到程序中
将图片的字节流逐一进行^5操作
将处理后的图片字节流输出

  1. @Test
  2. public void test1() {
  3.     FileInputStream fis = null;
  4.     FileOutputStream fos = null;
  5.     try {
  6.         fis = new FileInputStream("爱情与友情.jpg");
  7.         fos = new FileOutputStream("爱情与友情secret.jpg");
  8.         byte[] buffer = new byte[20];
  9.         int len;
  10.         while ((len = fis.read(buffer)) != -1) {
  11.             //字节数组进行修改
  12.             //错误的
  13.             //            for(byte b : buffer){
  14.             //                b = (byte) (b ^ 5);
  15.             //            }
  17.             //正确的
  18.             for (int i = 0; i < len; i++) {
  19.                 buffer[i] = (byte) (buffer[i] ^ 5);
  20.             }
  21.             fos.write(buffer, 0, len);
  22.         }
  23.     } catch (IOException e) {
  24.         e.printStackTrace();
  25.     } finally {
  26.         if (fos != null) {
  27.             try {
  28.                 fos.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.         if (fis != null) {
  34.             try {
  35.                 fis.close();
  36.             } catch (IOException e) {
  37.                 e.printStackTrace();
  38.             }
  39.         }
  40.     }
  41. }

解密操作
将加密后图片文件通过字节流读取到程序中
将图片的字节流逐一进行^操作（原理：A^B^B = A）
将处理后的图片字节流输出

  1. @Test
  2. public void test2() {
  3.     FileInputStream fis = null;
  4.     FileOutputStream fos = null;
  5.     try {
  6.         fis = new FileInputStream("爱情与友情secret.jpg");
  7.         fos = new FileOutputStream("爱情与友情4.jpg");
  8.         byte[] buffer = new byte[20];
  9.         int len;
  10.         while ((len = fis.read(buffer)) != -1) {
  11.             for (int i = 0; i < len; i++) {
  12.                 buffer[i] = (byte) (buffer[i] ^ 5);
  13.             }
  14.             fos.write(buffer, 0, len);
  15.         }
  16.     } catch (IOException e) {
  17.         e.printStackTrace();
  18.     } finally {
  19.         if (fos != null) {
  20.             try {
  21.                 fos.close();
  22.             } catch (IOException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }
  26.         if (fis != null) {
  27.             try {
  28.                 fis.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }
  • 统计文本字符出现次数

实现思路：

  1. 遍历文本每一个字符
  2. 字符出现的次数存在Map中

  3. 把map中的数据写入文件

    1. @Test
    2. public void testWordCount() {
    3. FileReader fr = null;
    4. BufferedWriter bw = null;
    5. try {
    6.   // 1.创建Map集合
    7.   Map<Character, Integer> map = new HashMap<>();
    9.   // 2.遍历每一个字符，每一个字符出现的次数放到map中
    10.   fr = new FileReader("dbcp.txt");
    11.   int c = 0;
    12.   while ((c = fr.read()) != -1) {
    13.       // int 还原 char
    14.       char ch = (char) c;
    15.       // 判断char是否在map中第一次出现
    16.       if (map.get(ch) == null) {
    17.           map.put(ch, 1);
    18.       } else {
    19.           map.put(ch, map.get(ch) + 1);
    20.       }
    21.   }
    23.   // 3.把map中数据存在文件count.txt
    24.   // 3.1 创建Writer
    25.   bw = new BufferedWriter(new FileWriter("wordCount.txt"));
    26.   // 3.2 遍历map,再写入数据
    27.   Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
    28.   for (Map.Entry<Character, Integer> entry : entrySet) {
    29.       switch (entry.getKey()) {
    30.           case ' ':
    31.               bw.write("空格=" + entry.getValue());
    32.               break;
    33.           case '\t':
    34.               bw.write("tab键=" + entry.getValue());
    35.               break;
    36.           case '\r':
    37.               bw.write("回车=" + entry.getValue());
    38.               break;
    39.           case '\n':
    40.               bw.write("换行=" + entry.getValue());
    41.               break;
    42.           default:
    43.               bw.write(entry.getKey() + "=" + entry.getValue());
    44.               break;
    45.       }
    46.       bw.newLine();
    47.   }
    48. } catch (IOException e) {
    49.   e.printStackTrace();
    50. } finally {
    51.   if (fr != null) {
    52.       try {
    53.           fr.close();
    54.       } catch (IOException e) {
    55.           e.printStackTrace();
    56.       }
    57.   }
    58.   if (bw != null) {
    59.       try {
    60.           bw.close();
    61.       } catch (IOException e) {
    62.           e.printStackTrace();
    63.       }
    64.   }
    65. }
    66. }

转换流

转换流提供了在字节流和字符流之间的转换，属于字符流

  • InputstreamReader 将Inputstream转换为Reader
  • OutputStreamWriter 将Writer转换为OutputStream
  • 字节流中的数据都是字符时，转成字符流操作更高效
  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能

缓冲流、转换流 - 图4
InputStreamReader

  • InputStreamReader将一个字节输入流转换为字符输入流

解码：字节、字节数组 —->字符数组、字符串

  • 构造器

**public InputStreamReader(InputStream in)**
**public InputStreamReader(Inputstream in,String charsetName)** 可以指定编码集
OutputStreamWriter

  • OutputStreamWriter将一个字符的输出流转换为字节的输出流

编码：字符数组、字符串 —-> 字节、字节数组

  • 构造器

**public OutputStreamWriter(OutputStream out)**
**public OutputStreamWriter(Outputstream out,String charsetName)** 可以指定编码集

  1. // 此时处理异常的话，仍然应该使用try-catch-finally
  2. // InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
  3. @Test
  4. public void test1() throws IOException {
  5.     FileInputStream fis = new FileInputStream("dbcp.txt");
  6.     //        InputStreamReader isr = new InputStreamReader(fis);    //使用系统默认的字符集
  7.     // 参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt当初保存时使用的字符集
  8.     InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
  10.     char[] cbuf = new char[20];
  11.     int len;
  12.     while((len = isr.read(cbuf)) != -1) {
  13.         String str = new String(cbuf, 0, len);
  14.         System.out.print(str);
  15.     }
  16.     isr.close();
  17. }
  19. // 此时处理异常的话，仍然应该使用try-catch-finally
  20. // 综合使用InputStreamReader和OutputStreamWriter
  21. @Test
  22. public void test2() throws Exception {
  23.     // 1.造文件、造流
  24.     File file1 = new File("dbcp.txt");
  25.     File file2 = new File("dbcp_gbk.txt");
  26.     FileInputStream fis = new FileInputStream(file1);
  27.     FileOutputStream fos = new FileOutputStream(file2);
  28.     InputStreamReader isr = new InputStreamReader(fis, "utf-8");
  29.     OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
  31.     // 2.读写过程
  32.     char[] cbuf = new char[20];
  33.     int len;
  34.     while((len = isr.read(cbuf)) != -1){
  35.         osw.write(cbuf, 0, len);
  36.     }
  38.     // 3.关闭资源
  39.     isr.close();
  40.     osw.close();
  41. }

说明：文件编码的方式比如GBK，决定了解析时使用的字符集也只能是GBK

编码集

常见的编码表

  • ASCII：美国标准信息交换码，用一个字节的7位可以表示
  • ISO8859-1：拉丁码表，欧洲码表用一个字节的8位表示
  • GB2312：中国的中文编码表，最多两个字节编码所有字符
  • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
  • Unicode：国际标准码，融合了目前人类使用的所字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示
  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符

缓冲流、转换流 - 图5
说明

  • 面向传输的众多UTF(UCS Transfer Format)标准出现了，顾名思义，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。
  • Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。

UTF-8变长编码表示
缓冲流、转换流 - 图6
编码应用

  • 编码：字符串—>字节数组
  • 解码：字节数组—>字符串
  • 转换流的编码应用
    • 可以将字符按指定编码格式存储
    • 可以对文本数据按指定编码格式来解读
    • 指定编码表的动作由构造器完成

使用要求
客户端/浏览器端 <——> 后台(java,GO,Python,Node.js,php) <——> 数据库
要求前前后后使用的字符集都要统一：UTF-8