注意：

这个两个流都是带有缓冲区的，所以就不需要准备自定义的char数组，或者byte数组来缓存数据。

BufferedReader的使用：

        //创建一个字符输入流
        FileReader reader = new FileReader("src/com/io/temp");

        //创建一个带有缓冲区的字符输入流，并把前面的字符输入流输入
        BufferedReader br = new BufferedReader(reader);
        //如果当一个流的构造方法中需要一个流的时候，被传进来的流叫做节点流，即reader为节点流；
        // 外部负责包装的流叫做包装流，即br为包装流；
        // 还有一个名字叫做：处理流，即整体叫做处理流。
        
        //读一行
        String s = null;

        try {//连续读行，这个readLine()方法不带换行符，这个方法一次循环读取一行数据
            // 所以输出数据不会换行，所以println()负责读取的数据换行
            while ((s = br.readLine())!=null){
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


        //关闭流
        try {//关闭流，当br在关闭流的时候，其底层源代码已经关闭了节点流
             // 对于包装流来说，只需要关闭最外层的流就行，里面的节点流会自动关闭（源代码实现关闭）
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

使用转换流，将字节输入流转换为带有缓冲区的字符输入流：

        //现创建一个字节流
        //FileInputStream fis = new FileInputStream("src/com/io/temp");

        //创建一个转换流对象，将字节流转换为字符流
        //InputStreamReader isr = new InputStreamReader(fis);
        //字节流fis转换为字符流isr,此时，fis是节点流，isr是包装流

        //现有一个字符流，输入对象
        //FileReader fir = new FileReader(fis);//不能直接输入字节流
        //BufferedReader br = new BufferedReader(isr);
        //此时isr 是节点流，br是包装流

        //以上代码合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new  FileInputStream("Src/com/io/temp")));
        String s = null;
        while ((s = br.readLine())!=null){
            System.out.println(s);
        }
        //关闭流
        br.close();

BufferWriter的使用：

        /*BufferedWriter bw = new BufferedWriter(new FileWriter("tempfile3"));
        * 上面代码是 将字符输出流 转换为 带缓冲区的字符输出流
        * */
        //将 字节输出流  转换为 带缓冲区的字符输出流，并且不会将原文件中数据清除，而是在其后以追加的方式写入数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("temp1",true)));
        //写数据
        bw.write("hello world");
        bw.write("\n");
        bw.write("hello kitty");

        //刷新，此步是输出流必须要有的部分
        bw.flush();
        //关闭流，这个是每个流都需要关闭的部分
        bw.close();

注意：

以上close()方法只需要关闭BufferedReader/BufferedWriter的流即可，因为底层代码已经关闭了其输入进此流的节点流。

 //BufferedReader中的close()
public void close() throws IOException {
        synchronized (lock) {
            if (in == null)
                return;
            try {
                in.close();
            } finally {
                in = null;
                cb = null;
            }
        }
    }

//BufferedWriter中的close()
public void close() throws IOException {
        synchronized (lock) {
            if (out == null) {
                return;
            }
            try (Writer w = out) {
                flushBuffer();
            } finally {
                out = null;
                cb = null;
            }
        }
    }
void flushBuffer() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (nextChar == 0)
                return;
            out.write(cb, 0, nextChar);
            nextChar = 0;
        }
    }
private void ensureOpen() throws IOException {
        if (out == null)
            throw new IOException("Stream closed");
    }