Day 10 2021.3.11-.3.12 递归-过滤器-IO流-缓冲流

Day 10 2021.3.11-3.12

递归

概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yQr5Mtb8-1615530497688)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311125443070.png)]

package com.hong.Day010.Demo01;
/*
    递归:方法自己调用自己
    - 递归的分类:
      - 递归分为两种:直接递归和间接递归
      - 直接递归称为方法自己调用自己
      - 间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法
    - 注意事项:
      - 递归一点要有条件限定,保证递归能够停止下来,否则会发生栈溢出
      - 在递归中虽然有限定条件,但是递归次数不能太多,否则也会发生栈溢出
      - 构造方法,禁止递归
*/
public class Demo01 {
    public static void main(String[] args) {
        //a();
        b(1);
    }

    private static void b(int i) {
        System.out.println(i);
        if (i == 20000){
            return;//结束方法
        }
        b(i++);
        //在递归中虽然有限定条件,但是递归次数不能太多,否则也会发生栈溢出
    }

    private static void a(){
        System.out.println("a方法");
        a();
        //递归一点要有条件限定,保证递归能够停止下来,否则会发生栈溢出
    }
}

练习_使用递归计算1n之间的和

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fUHJvxVx-1615530497690)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311135415323.png)]

package com.hong.Day010.Demo01;
/*
    计算1n之间的和
*/
public class Demo02 {
    public static void main(String[] args) {
        int a = add(2,100);
        System.out.println(a);
    }

    //累加
    public static int add(int i,int n){
        int result = 0;
        if (i==n){
            return result+i;
        }
        result = i + add(i+1,n);
        return result;
    }
}

练习_使用递归计算阶乘

package com.hong.Day010.Demo01;
/*
    计算1n的阶乘
*/
public class Demo02 {
    public static void main(String[] args) {
        int a = add(3,5);
        System.out.println(a);
    }

    //累加
    public static int add(int i,int n){
        int result = 1;
        if (i==n){
            return result*i;
        }
        result = i * add(i+1,n);
        return result;
    }
}

练习_使用递归打印多级目录

//File[] Files = dir.listFiles 用来存储文件目录的表格
//getAllFile()  获得全部文件目录
//endsWith()   判断文件结尾是什么
//getName()    获得文件名字
//getPath()    获得文件目录
//toLowerCase() 忽略大小写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uaSqYmep-1615530497694)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311140253127.png)]

综合案例_文件搜索

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YikLntXh-1615530497696)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311140613528.png)]

FileFilter和FilenameFilter过滤器的原理和使用

/*
    public interface FileFilter 抽象路径名的过滤器。
    boolean    accept(File pathname)
    测试指定的抽象路径名是否应包含在路径名列表中。
        参数:
            File pathname:使用ListFiles方法遍历目录,得到的每一个文件对象

    public interface FilenameFilter 用于实现此接口的类的实例用于过滤文件名。
    boolean    accept(File dir, String name)
    测试指定文件是否应包含在文件列表中。
    
    两个过滤器接口是没有实现类的,需要重写实现类自己定义规则
*/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NiOWTvqm-1615530497697)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311142116571.png)]

判断方法:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cggUwkfc-1615530497699)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311142227122.png)]

使用匿名内部类表达:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wbfsBPJS-1615530497701)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210311142530255.png)]

IO流（字节流）

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g69jbwpH-1615530497701)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312083847507.png)]

字节输出流(OutputStream)

OutputStream类

/*
    java.io.OutputStream:字节输出流
    这个抽象类是表示字节输出流的所有类的超类。 输出流接收输出字节并将其发送到某个接收器。
常用方法:
    1.void close() 关闭此输出流并释放与此流相关联的任何系统资源。
    2.void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
    3.void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
    4.void write(byte[] b, int off, int len)从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
    5.abstract void    write(int b) 将指定的字节写入此输出流。
*/

FileOutputStream类

字节写入与获取字节

package com.hong.Day010.Demo02;

import java.io.FileOutputStream;
import java.io.IOException;

/*
    java.io.OutputStream:字节输出流
    这个抽象类是表示字节输出流的所有类的超类。 输出流接收输出字节并将其发送到某个接收器。
常用方法:
    1.void close() 关闭此输出流并释放与此流相关联的任何系统资源。
    2.void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
    3.void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
    4.void write(byte[] b, int off, int len)从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
    5.abstract void    write(int b) 将指定的字节写入此输出流。

    java.io.FileOutputStream
    文件输出流是用于将数据写入到输出流File或一个FileDescriptor
    FileOutputStream:文件字节输出流
    作用:把内存中的数据写入文件中

    构造方法:
        1.FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
        2.FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。
        参数:写入数据的目的地
            String name:目的地是一个文件的路径
            File file:目的地是一个文件
        构造方法的作用:
            1.创建一个FileOutputStream对象
            2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
            3.会把FileOutputStream对象指向创建好的文件
    写入数据的原理(内存-->硬盘)
        java程序-->JVM(java虚拟机)-->os(操作系统)-->os调用写数据的方法-->把数据写入到文件中
    字节输出流的使用步骤(重点):
        1.创建一个FileOutputStream对象,构造方法中写入数据的目的地
        2.使用FileOutputStream对象中的方法write,把数据写入到文件中
        3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空m提高程序的效率)
*/
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象,构造方法中写入数据的目的地
        FileOutputStream fos = new FileOutputStream("E:\\javaIO\\a.txt");
        //2.使用FileOutputStream对象中的方法write,把数据写入到文件中
        fos.write(98);//b   一次写了一个字节
        fos.write(49);//100  需要3个字节
        fos.write(48);
        fos.write(48);

        /*
            void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
            一次写多个字节:
                    如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
                    如果写的第一个字节是负数,那么第一个字节和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK,简体中文)
        */
        byte[] bytes = {65,66,67,68,69};
        fos.write(bytes);//ABCDE

        byte[] bytes1 = {-65,-66,-67,68,69};
        fos.write(bytes1);//烤紻E

        /*
            void write(byte[] b, int off, int len)从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
            把字节数组的一部分写入到文件中
            int off:数组的开始索引
            int len:写几个字节
        */
        fos.write(bytes,1,2);//BC

        /*
            写入字节的方法:
                    String类中有getBytes()方法:
                    把字符串转换为字节数组
        */
        byte[] bytes2 = "你好".getBytes();
        fos.write(bytes2);
        //3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空m提高程序的效率)
        fos.close();
    }
}

续写与换行

package com.hong.Day010.Demo02;

import java.io.FileOutputStream;
import java.io.IOException;

/*
    追加写/续写:使用两个参数的构造方法
    FileOutputStream(String name, boolean append)创建文件输出流以指定的名称写入文件
    FileOutputStream(File file, boolean append)创建文件输出流以写入由指定的 File对象表示的文件
        参数:
            String name,File file:写入数据的目的地
            boolean append :追加开关
              true:创建对象不会覆盖源文件,继续在文件的末尾追加 写数据
              false:创建一个新文件,覆盖源文件
        写换行:写换行符号
            windows:\r\n
            linux:/n
            mac:/r
*/
public class Demo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\javaIO\\b.txt",true);
        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }

        fos.close();
    }
}

字节输入流(InputStream)

/*
    java.io.InputStream:字节输出流
    这个抽象类是表示输入字节流的所有类的超类。需要定义InputStream子类的应用InputStream必须始终提供一种返回输入的下一个字节的方法
常用方法:
    1.void close() 关闭此输入流并释放与流相关联的任何系统资源。
    2.abstract int read() 从输入流读取数据的下一个字节。
    3.int read(byte[] b) 从输入流读取一些字节数，并将它们存储到缓冲区 b 。
    4.int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。
    5.void reset() 将此流重新定位到上次在此输入流上调用 mark方法时的位置。
    6.void mark(int readlimit) 标记此输入流中的当前位置。
*/

FileInputStream

package com.hong.Day010.Demo02;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/*
    java.io.InputStream:字节输入流
    这个抽象类是表示输入字节流的所有类的超类。需要定义InputStream子类的应用InputStream必须始终提供一种返回输入的下一个字节的方法
常用方法:
    1.void close() 关闭此输入流并释放与流相关联的任何系统资源。
    2.abstract int read() 从输入流读取数据的下一个字节。
    3.int read(byte[] b) 从输入流读取一些字节数，并将它们存储到缓冲区 b 。
    4.int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。
    5.void reset() 将此流重新定位到上次在此输入流上调用 mark方法时的位置。
    6.void mark(int readlimit) 标记此输入流中的当前位置。

    java.io.FileInputStream extends InputStream :文件字节输入流
    FileInputStream用于读取诸如图像数据的原始字节流
    作用:把硬盘文件中的数据读取到内存中使用
构造方法:
    1.FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
    2.FileInputStream(FileDescriptor fdObj) 创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的现有连接到一个实际的文件。
    3.FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
    参数:读取文件的输入源
        String name :文件的路径,File file:文件
    构造方法的作用:
        1.会创建一个FileInputStream对象
        2.会把FileInputStream对象指定构造方法中要读取的文件
读取数据的原理(硬盘-->内存)
    java程序-->JVM-->OS-->OS读取数据的方法-->读取文件
字节输入流的使用步骤(重点):
    1.创建FileInputStream对象,构造方法中指定要读取的文件的数据源
    2.使用FileInputStream对象中的方法read,读取文件
    3.释放资源

*/
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象,构造方法中指定要读取的文件的数据源
        FileInputStream fis = new FileInputStream("E:\\javaIO\\a.txt");
        //2.使用FileInputStream对象中的方法read,读取文件
        //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
/*        System.out.println((char) fis.read());//(a)(97)  可以用循环(while)
        System.out.println(fis.read());//-1  读取到结尾*/
        int len = 0;//记录到读取的字节
        while ((len = fis.read())!= -1){
            System.out.print((char) len);//abc
        }

        //int read(byte[] b) 一次读取多个字节
        byte[] bytes = new byte[2];
        int len1 = fis.read(bytes);
        System.out.println(len1);//2(每次读取的字符个数)【一般定义1024或1024的整数倍】
        System.out.println(Arrays.toString(bytes));//[97,98]
        System.out.println(new String(bytes,0,len1));//ab
        //【可以用while循环】
        //3.释放资源
        fis.close();
    }
}

文件存储和记事本打开的原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lSBOljmV-1615530497702)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312090355547.png)]

练习:文件复制

package com.hong.Day010.Demo02;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
    文件复制练习:一读一写
    步骤:
        1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        3.使用字节输入流对象中的方法read读取文件
        4.使用字节输出流中的方法write,把读取到的字节写入到目的地文件中
        5.释放资源
*/
public class Demo04 {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("E:\\javaIO\\123.jpg");
        FileOutputStream fos = new FileOutputStream("E:\\javaIO\\12345.jpg");
/*        //一次读取一个一次写一个
        int len = 0;
        while ((len = fis.read())!= -1){
            fos.write(len);
        }*/

        //使用数组缓冲地区多个字节,写入多个字节
        byte[] bytes = new byte[1024];
        int len1 = 0;
        while ((len1 = fis.read(bytes))!= -1){
            fos.write(bytes,0,len1);
        }
        //5.释放资源(先关闭写的,后关闭读的)
        fos.close();
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
}

IO流(字符流)

字符输入流(Reader)

package com.hong.Day010.Demo03;

import java.io.FileReader;
import java.io.IOException;

/*
    字符输入流:java.io.Reader
    用于读取字符流的抽象类。 子类必须实现的唯一方法是read（char []，int，int）和close（）。 然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者。
构造方法
    1.protected    Reader()创建一个新的字符流阅读器，其关键部分将在阅读器本身上同步。
    2.protected    Reader(Object lock)创建一个新的字符流阅读器，其关键部分将在给定对象上同步。
常用方法:
    1.abstract void    close()关闭流并释放与之相关联的任何系统资源。
    2.int read()读一个字符
    3.int read(char[] cbuf)将字符读入数组。
注意:
    1.使用字节流读取中文文件时,1个中文:
        GBK:占用两个字节
        UTF-8:占用三个字节
*/

FileReader类

package com.hong.Day010.Demo03;

import java.io.FileReader;
import java.io.IOException;

/*
    字符输入流:java.io.Reader
    用于读取字符流的抽象类。 子类必须实现的唯一方法是read（char []，int，int）和close（）。 然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者。
构造方法
    1.protected    Reader()创建一个新的字符流阅读器，其关键部分将在阅读器本身上同步。
    2.protected    Reader(Object lock)创建一个新的字符流阅读器，其关键部分将在给定对象上同步。
常用方法:
    1.abstract void    close()关闭流并释放与之相关联的任何系统资源。
    2.int read()读一个字符
    3.int read(char[] cbuf)将字符读入数组。
注意:
    1.使用字节流读取中文文件时,1个中文:
        GBK:占用两个字节
        UTF-8:占用三个字节
    文件字符输入流:java.io.FileReader
    作用:把硬盘文件以字符的方式读取
构造方法:
    1.FileReader(File file)创建一个新的 FileReader ，给出 File读取。
    2.FileReader(FileDescriptor fd)创建一个新的 FileReader ，给定 FileDescriptor读取。
    3.FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。
    参数:file:文件     fileName:文件路径
字符输入流使用步骤:
    1.创建FileReader对象,构造方法中绑定要读取的数据源
    2.使用FileReader对象中的方法read读取文件
    3.释放资源
*/
public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("E:\\javaIO\\b.txt");
        //int read()读一个字符
        int len = 0;
        while ((len = fr.read())!= -1){
            System.out.print((char)len);
        }
        //int read(char[] cbuf)将字符读入数组
        char[] chars = new char[1024];
        int len1 = 0;
        while ((len1 = fr.read(chars))!= -1){
            System.out.print(new String(chars,0,len1));
        }
        fr.close();
    }
}

字符输出流(Writer)

package com.hong.Day010.Demo03;
/*
    字符输出流:java.io.Writer
    用于写入字符流的抽象类
构造方法:
    1.protected    Writer()创建一个新的人物流作家，其关键部分将在作者本身上同步。
    2.protected    Writer(Object lock)创建一个新的字符流写入器，其关键部分将在给定对象上进行同步。
常用方法:
    1.void write(char[] cbuf)写入一个字符数组。
    2.abstract void    write(char[] cbuf, int off, int len)写入字符数组的一部分。
    3.void write(int c)写一个字符
    4.void write(String str)写一个字符串
    5.void write(String str, int off, int len)写一个字符串的一部分。
    6.abstract void    close()关闭流，先刷新。
    7.abstract void    flush()刷新流。
*/

FileWriter类

package com.hong.Day010.Demo03;

import java.io.FileWriter;
import java.io.IOException;

/*
    字符输出流:java.io.Writer
    用于写入字符流的抽象类
构造方法:
    1.protected    Writer()创建一个新的人物流作家，其关键部分将在作者本身上同步。
    2.protected    Writer(Object lock)创建一个新的字符流写入器，其关键部分将在给定对象上进行同步。
常用方法:
    1.void write(char[] cbuf)写入一个字符数组。
    2.abstract void    write(char[] cbuf, int off, int len)写入字符数组的一部分。
    3.void write(int c)写一个字符
    4.void write(String str)写一个字符串
    5.void write(String str, int off, int len)写一个字符串的一部分。
    6.abstract void    close()关闭流，先刷新。
    7.abstract void    flush()刷新流。

    文件字符输出流:java.io.FileWriter
    方便课写字符文件
    作用:把内存中的字符写入到文件中
构造方法:
    1.FileWriter(File file)给一个File对象构造一个FileWriter对象。
    2.FileWriter(File file, boolean append)给一个File对象构造一个FileWriter对象。
    3.FileWriter(FileDescriptor fd)构造与文件描述符关联的FileWriter对象。
    4.FileWriter(String fileName)构造一个给定文件名的FileWriter对象。
    5.FileWriter(String fileName, boolean append)构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。
字符输出流使用步骤:
    1.创建FileWriter对象,构造方法中绑定要写入的数据源
    2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区
    3.使用FileWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中
    4.释放资源
*/
public class Demo02 {
    public static void main(String[] args) throws IOException {
        //1.创建FileWriter对象,构造方法中绑定要写入的数据源
        FileWriter fw = new FileWriter("E:\\javaIO\\c.txt");
        //2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区
        fw.write("a");
        //3.使用FileWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中
        fw.flush();
        //4.释放资源
        fw.close();
    }
}

flush与close 的区别

//flush()  :刷新后可以继续使用
//close()  :先刷新后关闭,关闭之后不可继续使用

续写与换行

/*
    追加写/续写:使用两个参数的构造方法
    FileWriter(String name, boolean append)创建文件输出流以指定的名称写入文件
    FileWriter(File file, boolean append)创建文件输出流以写入由指定的 File对象表示的文件
        参数:
            String name,File file:写入数据的目的地
            boolean append :追加开关
              true:创建对象不会覆盖源文件,继续在文件的末尾追加 写数据
              false:创建一个新文件,覆盖源文件
        写换行:写换行符号
            windows:\r\n
            linux:/n
            mac:/r
*/

Properties集合

/*
    java.util.Properties
    Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串。
构造方法:
    1.Properties()创建一个没有默认值的空属性列表。
    2.Properties(Properties defaults)创建具有指定默认值的空属性列表。
常用方法:
    1.String getProperty(String key)使用此属性列表中指定的键搜索属性。
    2.String getProperty(String key, String defaultValue)使用此属性列表中指定的键搜索属性。
    3.Object setProperty(String key, String value)致电 Hashtable方法 put 。
    4.Set<String> stringPropertyNames()返回此属性列表中的一组键，其中键及其对应的值为字符串，包括默认属性列表中的不同键，如果尚未从主属性列表中找到相同名称的键。
    5.void list(PrintStream out)将此属性列表打印到指定的输出流。
    6.void list(PrintWriter out)将此属性列表打印到指定的输出流。
    7.void load(InputStream inStream)从输入字节流读取属性列表（键和元素对）。
    8.void load(Reader reader)以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。
    9.void store(OutputStream out, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。
    10.void	store(Writer writer, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式输出到输出字符流。
*/

store存储Properties集合表的数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5vnwTYLb-1615530497703)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312134313453.png)]

load加载文件中的数据到Properties集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gWf7IC0c-1615530497703)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312134703560.png)]

缓冲流

原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2NXW6ct-1615530497703)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312135147743.png)]

	输入流	输出流
字节缓冲流	BufferedInputStream	BufferedOutputStream
字符缓冲流	BufferedReader	BufferedWriter

/*
构造方法:
    1.BufferedInputStream(InputStream in, int size)创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。
    2.BufferedOutputStream(OutputStream out, int size)创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。
    3.BufferedReader(Reader in, int sz)创建使用指定大小的输入缓冲区的缓冲字符输入流。
    4.BufferedWriter(Writer out, int sz)创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
*/

BufferedOutputStream

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1whDSsLA-1615530497705)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312140001770.png)]

BufferedOutputStream

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rQSd87oi-1615530497705)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312140347346.png)]

练习：文件复制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omwAXYKd-1615530497706)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312140807598.png)]

BufferedWriter

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p7dqYol2-1615530497706)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312141215681.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZWIKOuri-1615530497707)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312141301138.png)]

BufferedReader

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5D2o0cc7-1615530497707)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312141640767.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xt9lyU3L-1615530497708)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312141708303.png)]

练习:文本排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-df8M31tb-1615530497709)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312142127853.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fYyzNIwZ-1615530497710)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312142331942.png)]

数据写入指定的底层输出流。
3.BufferedReader(Reader in, int sz)创建使用指定大小的输入缓冲区的缓冲字符输入流。
4.BufferedWriter(Writer out, int sz)创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
*/

## BufferedOutputStream

[外链图片转存中...(img-1whDSsLA-1615530497705)]

## BufferedOutputStream

[外链图片转存中...(img-rQSd87oi-1615530497705)]

## 练习：文件复制

[外链图片转存中...(img-omwAXYKd-1615530497706)]

## BufferedWriter

[外链图片转存中...(img-p7dqYol2-1615530497706)]

[外链图片转存中...(img-ZWIKOuri-1615530497707)]

## BufferedReader

[外链图片转存中...(img-5D2o0cc7-1615530497707)]

[外链图片转存中...(img-Xt9lyU3L-1615530497708)]

## 练习:文本排序

[外链图片转存中...(img-df8M31tb-1615530497709)]

[外链图片转存中...(img-fYyzNIwZ-1615530497710)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNVlrE4l-1615530497710)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210312142408892.png)]