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

一、缓冲流

1、介绍

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

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

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

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

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

// 文件：F:\\hello.jpg
public class Main {

    public static void main(String[] args) {
        try (// 造节点流
             FileInputStream fis = new FileInputStream((new File("F:\\hello.jpg")));
             FileOutputStream fos = new FileOutputStream(new File("F:\\hello_1.jpg"));
             // 造缓冲流
             BufferedInputStream bis = new BufferedInputStream(fis);
             BufferedOutputStream bos = new BufferedOutputStream(fos);) {

            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }

            // 刷新缓冲区.必须
            // bos.flush();
        } catch (Exception e) {
        }
    }
}

// 用于copy 3.64G 的文件花费 18.925s

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

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

// 文件：F:\\hello.txt
// 内容：任意

// 方式一：会自动换行
public class Main {

    public static void main(String[] args) {
        try ( // 造节点流
              FileReader fr = new FileReader(new File("F:\\hello.txt"));
              FileWriter fw = new FileWriter(new File("F:\\hello_1.txt"));

              // 造缓冲流
              BufferedReader br = new BufferedReader(fr);
              BufferedWriter bw = new BufferedWriter(fw);) {

            // 使用char[]数组
            char[] cbuf = new char[1024];
            int len;
            while ((len = br.read(cbuf)) != -1) {
                bw.write(cbuf, 0, len);
            }

            // bw.flush();
        } catch (Exception e) {
        }
    }
}


// 方式二：不会自动换行
public class Main {

    public static void main(String[] args) {
        try ( // 造节点流
              FileReader fr = new FileReader(new File("F:\\hello.txt"));
              FileWriter fw = new FileWriter(new File("F:\\hello_1.txt"));

              // 造缓冲流
              BufferedReader br = new BufferedReader(fr);
              BufferedWriter bw = new BufferedWriter(fw);) {

            // 使用readLine(),一次性读一行
            String data;
            while ((data = br.readLine()) != null) {
                // data中不包含换行符,读一行写一行,不会自动换行.若想换行,可以:
                // 方法一：
                // bw.write(data + "\n");

                // 方法二：
                bw.write(data);
                bw.newLine();
            }

            // bw.flush();
        } catch (Exception e) {
        }
    }
}

4、装饰设计模式

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

class MyBufferedReader {
    private final FileReader fileReader;

    public MyBufferedReader(FileReader fileReader) {
        this.fileReader = fileReader;
    }

    public String myReadLine() throws IOException {
        StringBuilder builder = new StringBuilder();

        int len;
        while ((len = fileReader.read()) != -1) {
            if (len == '\r') {
                continue;
            }
            if (len == '\n') {
                return builder.toString();
            }

            builder.append((char) len);
        }

        if (builder.length() != 0) {
            return builder.toString();
        }

        return null;
    }

    public void myClose() {
        try {
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 注意关闭资源
// 文件：F:\\hello1.txt
// 内容：
我有a dream!
you need to have a dream!我有a dream!
you need to have a dream!
public class Main {
    public static void main(String[] args) throws Exception {
        MyBufferedReader reader = new MyBufferedReader(new FileReader(new File("F:\\hello1.txt")));

        String temp;
        while ((temp = reader.myReadLine()) != null) {
            System.out.println(temp);
        }

        reader.myClose();
    }
}

// 结果.打印正常

二、转换流

1、介绍

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

2、InputStreamReader

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

public class Main {

    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream(new File("F:\\hello.txt"));
             InputStreamReader isr = new InputStreamReader(fis, "UTF-8");) {

            char[] cbuf = new char[1024];
            int len;
            while ((len = isr.read(cbuf)) != -1) {
                String str = new String(cbuf, 0, len);
                System.out.print(str);
            }

        } catch (Exception e) {
        }
    }
}

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

public class Main {

    public static void main(String[] args) {
        try (// 从标准键盘输入.
             BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));) {

            String line = null;
            while ((line = reader.readLine()) != null) {
                if ("over".equals(line)) {
                    return;
                }
                System.out.println(line);
            }
        } catch (Exception e) {
        }
    }
}

3、OutputStreamWriter

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

public class Main {

    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream(new File("F:\\hello.txt"));
             FileOutputStream fos = new FileOutputStream(new File("F:\\hello_1.txt"));

             InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
             OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");) {

            char[] cbuf = new char[1024];
            int len;
            while ((len = isr.read(cbuf)) != -1) {
                osw.write(cbuf, 0, len);
            }

            isr.close();
            osw.close();
        } catch (Exception e) {
        }
    }
}

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

public class Main {

    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));) {

            String line = null;
            while ((line = reader.readLine()) != null) {
                if ("over".equalsIgnoreCase(line)) {
                    break;
                }
                writer.write(line.toUpperCase());
                writer.newLine(); // 换行
                writer.flush();
            }

            reader.close();
            writer.close();
        } catch (Exception e) {
        }
    }
}

4、字符集

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