java IO缓冲字节流：

一，缓冲字节流：

缓冲区字节输入流：BufferedInputStream,缓冲区字节输出流：BufferedOutputStream,之所以快，因为他们内部由一个缓冲区数组，长度8192，在一次读取或者写出的时候通过数组完成，一次读取或者写出多个，使用缓冲区输入/输出流，需要给构造方法传入对应输入/输出流。

二，字符流：

字节流适合读取二进制文件，读取字符数据可能会乱码，读取字符建议采用字符流，

字符流有两个抽象父类，Reader(字符输入流)，Writer(字符输出流)

一般使用其子类，FileReader,FileWriter

2.1FileReader:

构造方法：

• FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader。
• FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。

方法：

• int read() 读取单个字符。 读完末尾返回-1
• int read(char[] cbuf) 将字符读入数组。
• void close() 关闭该流并释放与之关联的所有资源。

FileReader reader = new FileReader("D:\\新建文件夹\\qfjava\\src\\com\\qf\\A.text");
        //int read = reader.read();
       // System.out.println(read);
//        int a = -1;
//        while ((a = reader.read()) != -1){
//            System.out.println((char) a);
//        }
//        reader.close();
        char[] chars = new char[13];
        reader.read(chars);
        System.out.println(Arrays.toString(chars));

2.2FileWriter:

在创建时，内部默认构造一个缓冲数组，用于一次写出多个，大小是1024字节

构造方法：

• FileWriter(File file) 根据给定的 File 对象构造一个 FileWriter 对象。
• FileWriter(File file, boolean append) 根据给定的 File 对象构造一个 FileWriter 对象。
• FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
• FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

append指定成true,在原文件后面追加,指定成false,覆盖原文件
如果不知道,默认就是false

方法：

• void close() 关闭此流，但要先刷新它。
• void flush() 刷新该流的缓冲。
• void write(char[] cbuf) 写入字符数组。
• void write(int c) 写入单个字符。
• void write(String str) 写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分。

FileReader reader = new FileReader("D:\\javaFile\\雪中悍刀行.txt");
        FileWriter writer = new FileWriter("D:\\javaFile\\B\\雪中悍刀行.txt");
        int R = 0;
        while ((R = reader.read()) != -1){
            writer.write((char)R);
        }
        reader.close();
        writer.close();

三，缓冲字符流：

3.1 BufferedReader:

缓冲区字符输入输出流，在内部创建对象时会构建一个长度为8192的缓冲数组

构造方法：

BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流

方法：

String readLine() 读取一个文本行
int read() 读取单个字符
void close() 关闭该流并释放与之关联的所有资源

3.2BufferedWriter：

构造方法：

BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流

方法：

void close() 关闭此流，但要先刷新它。
void flush() 刷新该流的缓冲。
void newLine() 写入一个行分隔符。
void write(int c) 写入单个字符。
void write(String s, int off, int len) 写入字符串的某一部分。

  public static void main(String[] args) {

        long begin = System.currentTimeMillis( );

        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            fr = new FileReader("E:\\《雪中悍刀行》.txt");
            fw = new FileWriter("E:\\血刀.txt");

            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);


            int ch  = -1;
            // 一次读一个放入缓冲区
            // while((ch = br.read()) != -1) {
            //     bw.write(ch);// 写一个字符
            // }

            String line = null;
            // 一次读取一行,读取到换行终止符结束并返回,但是不包含终止符
            while((line = br.readLine()) != null) {
                bw.write(line); // 写一行字符串
                // 写出一个换行符
                // bw.write("\r\n");
                bw.newLine();
            }


        } catch (Exception e) {
            e.printStackTrace( );
        } finally {

            try {
                br.close();
                bw.close();
            } catch (IOException e) {
                e.printStackTrace( );
            }
        }
        long end = System.currentTimeMillis( );
        System.out.println("拷贝小说,耗时 " + (end - begin) + "毫秒" );
    }

读取一个文本,按行倒着输出,即读取的第一行输出在最后一行,读取的第二行,输出在倒数第二行.

思路: 不能读完直接输出了,而是读一行,向集合中存一行.读取完毕后,倒着遍历集合即可

  public static void main(String[] args) {

        long begin = System.currentTimeMillis( );

        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("E:\\a.txt"));
            bw = new BufferedWriter(new FileWriter("E:\\a2.txt"));

            ArrayList<String> list = new ArrayList<>( );
            // 读取每一行,转入集合
            String line = null;
            while((line = br.readLine()) != null) {
                list.add(line);
            }

            // 倒着遍历集合
            for (int i = list.size() - 1;i >= 0;i--) {
                String s = list.get(i);
                bw.write(s);
                bw.newLine();
            }

        } catch (Exception e) {
            e.printStackTrace( );
        } finally {
            try {
                br.close();
                bw.close();
            } catch (IOException e) {
                e.printStackTrace( );
            }
        }
        long end = System.currentTimeMillis( );
        System.out.println("倒着拷贝,耗时 " + (end - begin) + "毫秒" );
    }

四，匿名内部类：

 public static void main(String[] args) {
        // 有一个接口,现在让你创建一个接口的实现类对象
        // new USBImpl();
        // test(new USBImpl());
        // 就相当于是创建了USB接口的实现类,并且重写了方法
        // 这就是匿名内部类
        USBImpl(new USB() {
            @Override
            public void run() {
                System.out.println("匿名内部类");

            }
        });
    }

    public static void USBImpl(USB usb) {
        usb.run();
    }