Java基础（八）——IO流2_缓冲流、转换流

一、缓冲流

1、介绍

　　缓冲流：不能直接作用在文件上，需要包一层，它是一种处理流。用于提高文件的读写效率。它在流的基础上对流的功能进行了增强。提高读写速度的原因：内部提供了一个缓冲区。缺省使用 8192 个字节（8Kb）的缓冲区 。
　　源码示例：BufferedInputStream

1 public class BufferedInputStream extends FilterInputStream {2     // 默认缓冲区的大小3     private static int DEFAULT_BUFFER_SIZE = 8192;4 }

　　要求：先关闭外层的流，再关闭内层的流。而关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，可以省略。

2、BufferedInputStream，BufferedOutputStream（字节流的缓冲区）

　　代码示例：用字节流缓冲区处理非文本文件（图片，视频等）。缓冲流复制图片。

1 // 文件：F:\\\\hello.jpg2 public class Main {34     public static void main(String[] args) {5         try (// 造节点流6ad8FileInputStream fis = new FileInputStream((new File(\"F:\\\\hello.jpg\")));7              FileOutputStream fos = new FileOutputStream(new File(\"F:\\\\hello_1.jpg\"));8              // 造缓冲流9              BufferedInputStream bis = new BufferedInputStream(fis);10              BufferedOutputStream bos = new BufferedOutputStream(fos);) {1112             byte[] buffer = new byte[1024];13             int len;14             while ((len = bis.read(buffer)) != -1) {15                 bos.write(buffer, 0, len);16             }1718             // 刷新缓冲区.必须19             // bos.flush();20         } catch (Exception e) {21         }22     }23 }2425 // 用于copy 3.64G 的文件花费 18.925s

3、BufferedReader、BufferedWriter（字符流的缓冲区）

　　BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者使用默认的大小。在大多数情况下，默认值就足够大了。
　　字符读取流缓冲区，该缓冲区提供了一个一次读一行的方法readLine()，方便于对文本数据的获取。当返回null时，表示读到文件末尾。
　　BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，ad0或者接受默认的大小。在大多数情况下，默认值就足够大了。
　　该缓冲区中提供了一个跨平台的换行符：newLine()。
　　代码示例：用字符流缓冲区处理文本文件。缓冲流复制文本文件。

1 // 文件：F:\\\\hello.txt2 // 内容：任意34 // 方式一：会自动换行5 public class Main {67     public static void main(String[] args) {8         try ( // 造节点流9               FileReader fr = new FileReader(new File(\"F:\\\\hello.txt\"));10               FileWriter fw = new FileWriter(new File(\"F:\\\\hello_1.txt\"));1112               // 造缓冲流13               BufferedReader br = new BufferedRead3b9cer(fr);14               BufferedWriter bw = new BufferedWriter(fw);) {1516             // 使用char[]数组17             char[] cbuf = new char[1024];18             int len;19             while ((len = br.read(cbuf)) != -1) {20                 bw.write(cbuf, 0, len);21             }2223             // bw.flush();24         } catch (Exception e) {25         }26     }27 }282930 // 方式二：不会自动换行31 public class Main {3233     public static void main(String[] args) {34         try ( // 造节点流35               FileReader fr = new FileReader(new File(\"F:\\\\hello.txt\"));36               FileWriter fw = new FileWriter(new File(\"F:\\\\hello_1.txt\"));3738               // 造缓冲流39               BufferedReader br = new BufferedReader(fr);40               BufferedWriter bw = new BufferedWriter(fw);) {4142             // 使用readLine(),一次性读一行43             String data;44             while ((data = br.readLine()) != null) {45                 // data中不包含换行符,读一行写一行,不会自动换行.若想换行,可以:46                 // 方法一：47                 // bw.write(data + \"\\n\");4849                 // 方法二：50                 bw.write(data);51                 bw.newLine();52             }5354             // bw.flush();55         } catch (Exception e) {56         }57     }58 }

4、装饰设计模式

　　自定义的字符读取流缓冲区myReadLine()，将readLine()方法实现了一次。
　　代码示例：

1 class MyBufferedReader {2     private final FileReader fileReader;34     public MyBufferedReader(FileReader fileReader) {5         this.fileReader = fileReader;6     }78     public String myReadLine() throws IOException {9         StringBuilder builder = new StringBuilder();1011         int len;12         while ((len = fileReader.read()) != -1) {13             if (len == \'\\r\') {14                 continue;15             }16             if (len == \'\\n\') {17                 return builder.toString();18             }1920             builder.append((char) len);21         }2223         if (builder.length() != 0) {24             return builder.toString();25         }2627         return null;28     }2930     public void myClose() {31         try {32             fileReader.close();33         } catch (IOException e) {34             e.printStackTrace();35         }36     }37 }3839 // 注意关闭资源40 // 文件：F:\\\\hello1.txt41 // 内容：42 我有a dream!43 you need to have a dream!我有a dream!44 you need to have a dream!45 public class Main {46     public static void main(String[] args) throws Exception {47         MyBufferedReader reader = new MyBufferedReader(new FileReader(new File(\"F:\\\\hello1.txt\")));4849         String temp;50         while ((temp = reader.myReadLine()) != null) {51             System.out.println(temp);52         }5354         reader.myClose();55     }56 }5758 // 结果.打印正常

二、转换流

1、介绍

　　转换流提供了在字节流和字符流之间的转换。
　　InputStreamReader：将InputStream转换为Reader，实现将字节的输入流按指定字符集转换为字符的输入流。解码。
　　OutputStreamWriter：将Writer转换为OutputStream，实现将字符的输出流按指定字符集转换为字节的输出流。编码。
　　很多时候使用转换流来处理文件乱码问题。实现编和解码的功能。

2、InputStreamReader

　　每次调用InputStreamReader中的一个read()方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
　　为了达到最高效率，可要考虑在InputStreamReader外套接一层BufferedReader。
　　键盘录入的标准写法：BufferedReader in = new BufferedReader(new InputStreamReader(System.in))
　　代码示例：读文件。字节流->字符流

1 public class Main {23     public static void main(String[] args) {4         try (FileInputStream fis = new FileInputStream(new File(\"F:\\\\hello.txt\"));5              InputStreamReader isr = new InputStreamReader(fis, \"UTF-8\");) {67             char[] cbuf = new char[1024];8             int len;9             while ((len = isr.read(cbuf)) != -1) {10                 String str = new String(cbuf, 0, len);11                 System.out.print(str);12             }1314         } catch (Exception e) {15         }16     }17 }

　　代码示例：读键盘。缓冲流

1 public class Main {23     public static void main(String[] args) {4         try (// 从标准键盘输入.5              BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));) {67             String linad8e = null;8             while ((line = reader.readLine()) != null) {9                 if (\"over\".equals(line)) {10                     return;11                 }12                 System.out.println(line);13             }14         } catch (Exception e) {15         }16     }17 }

3、OutputStreamWriter

　　每次调用write()方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对数用途来说已足够大。注意，传递给write()方法的字符没有缓冲。
　　为了获得最高效率，可考虑在OutputStreamWriter外套接一层BufferedWriter。以避免频繁调用转换器。例：
　　Writer out = new BufferedWriter(new OutputStreamWriter(System.out))
　　代码示例：写文件。字符流->字节流

1 public class Main {23     public static void ma3a6bin(String[] args) {4         try (FileInputStream fis = new FileInputStream(new File(\"F:\\\\hello.txt\"));5              FileOutputStream fos = new FileOutputStream(new File(\"F:\\\\hello_1.txt\"));67              InputStreamReader isr = new InputStreamReader(fis, \"UTF-8\");8              OutputStreamWriter osw = new OutputStreamWriter(fos, \"gbk\");) {910             char[] cbuf = new char[1024];11             int len;12             while ((len = isr.read(cbuf)) != -1) {13                 osw.write(cbuf, 0, len);14             }1516             isr.close();17             osw.close();18         } catch (Exception e) {19         }20     }21 }

　　代码示例：读\\写键盘。缓冲流

1 public class Main {23     public static void main(String[] args) {4         try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));5              BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));) {67             String line = null;8             while ((line = reader.readLine()) != null) {9                 if (\"over\".equalsIgnoreCase(line)) {10                     break;11                 }12                 writer.write(line.toUpperCase());13                 writer.newLine(); // 换行14                 writer.flush();15             }1617             reader.close();18             writer.close();19         } catch (Exception e) {20         }21     }22 }

4、字符集

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