IO流:输入字节流:InputStream 、 输出字节流:OutputStream 、输入字符流:Reader 、输出字符流:Writer、 BufferedInputStream

## 1_ IO流的介绍及其分类
         * IO流:
         *         I: Input 输入
         *         O: Output 输出
         *  分类:
         *      按类型来分:
         *          字节流:以单个字节为基本单位来操作的
         *              输入字节流:InputStream 表示字节输入流的所有类的超类    抽象类
         *              输出字节流:OutputStream 表示输出字节流的所有类的超类    抽象类
         *          字符流:以单个字符为基本单位来操作的
         *              输入字符流:Reader 用于读取字符流的抽象类
         *              输出字符流:Writer 写入字符流的抽象类
         *      按流向来分:
         *          输入流:
         *              输入字节流:InputStream
         *              输入字符流:Reader
         *          输出流:    
         *              输出字节流:OutputStream
         *              输出字符流:Writer
         *  1KB = 1024字节
         *  1MB = 1024KB
         *  1GB = 1024MB
         *  操作系统的最小基本单位就是字节
         *     中文字符在gbk编码下占2个字节,在utf-8编码下占3个字节
         *  eclipse默认情况下是gbk编码
         *  IO流的顶层是抽象类,集合的顶层是接口

 ## 1_字节流读取数据
    
    * read()方法的作用:
        * 读取数据, 一次读取一个字节, 返回该字节对应的ASCII码值, 读不到返回-1.

    private static void method01() throws FileNotFoundException, IOException {
        // 1.创建字节输入流对象
        FileInputStream fis = new FileInputStream("a.txt");
        // 循环条件:  当读取出来的数据等于-1的时候就结束循环
        // 循环次数:    不确定
        // 循环体: 输出
        // abc123abc
        // 定义一个变量用来存储读取到的数据对应的ASCII码值
        int len = 0;
        // 循环读取数据
        while((len = fis.read()) != -1) {//1.读取数据    2.把读取出来的数据赋值给len    3.拿len的值和-1比较
            System.out.println((char)len);
        }
        // 3.关闭流
        fis.close();
        
        // 2. 读取字节对应的ASCII码值
//        int len1 = fis.read();
//        System.out.println(len1);//97
//        
//        // 2. 读取字节对应的ASCII码值
//        int len2 = fis.read();
//        System.out.println(len2);//98
//        
//        // 2. 读取字节对应的ASCII码值
//        int len3 = fis.read();
//        System.out.println(len3);//99
//        
//        // 2. 读取字节对应的ASCII码值
//        int len4 = fis.read();
//        System.out.println(len4);//-1
        
        // 3.关闭流
//        fis.close();
    }

 ## 2 _字节流写出数据

        private static void method02() throws FileNotFoundException, IOException {
        /*
         FileOutputStream(String name) 
                      创建一个向具有指定名称的文件中写入数据的输出文件流。 
        FileOutputStream(String name, boolean append) 
                  创建一个向具有指定 name 的文件中写入数据的输出文件流。 
         */
        // 1.创建一个字节输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("b.txt",true);
        // 2.写入数据
        fos.write(98);
        fos.write(98);
        fos.write(98);
        // 3.关闭流
        fos.close();
        System.out.println("搞定");
    }

## 3_字节流一次拷贝一个字节

    public static void main(String[] args) throws IOException {
        /*
             1.创建一个输入流对象,封装数据源文件
             2.创建一个输出流对象,封装目的地文件
             3.定义一个变量,用来存储读取到的字节数据
             4.循环读取数据,满足条件就继续读
             5.写入数据
             6.关闭流
         */
        // 1.创建一个输入流对象,封装数据源文件
        FileInputStream fis = new FileInputStream("D:\\1.mp3");
        // 2.创建一个输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("1.mp3");
        // 3.定义一个变量,用来存储读取到的字节数据
        int len = 0;
        // 4.循环读取数据,满足条件就继续读
        while((len = fis.read()) != -1) {
            // 5.写入数据
            fos.write(len);
        }
        //6.关闭流
        fis.close();
        fos.close();
        System.out.println("搞定");
    }

    private static void method02() throws FileNotFoundException, IOException {
        // 1.创建一个输入流对象,封装数据源文件
        FileInputStream fis = new FileInputStream("D:\\hb.jpg");
        // 2.创建一个输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("hb.jpg");
        // 3.定义一个变量,用来存储读取到的字节数据
        int len = 0;
        // 4.循环读取数据,满足条件就继续读
        while((len = fis.read()) != -1) {
            // 5.写入数据
            fos.write(len);
        }
        // 6.关闭流
        fis.close();
        fos.close();
        System.out.println("搞定");
    }

    private static void method01() throws FileNotFoundException, IOException {
        // D:\\123.txt
        // 1.创建一个输入流对象,封装数据源文件
        FileInputStream fis = new FileInputStream("D:\\123.txt");
        // 2.创建一个输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("123.txt");
        // 3.定义一个变量,用来存储读取到的字节数据
        int len = 0;
        // 4.循环读取数据,满足条件就继续读
        while((len = fis.read()) != -1) {
            // 5.写入数据
            fos.write(len);
        }
        // 6.关闭流
        fis.close();
        fos.close();
        System.out.println("搞定");
    }

    
## 4_字节流一次读写一个字节数组
public static void main(String[] args) throws IOException {
        // 1. 创建一个字节输入流对象,封装数据源文件
        FileInputStream fis = new FileInputStream("c.txt");
        // 2.创建一个字节输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("cCopy.txt");
        // 2.定义一个字节数组用来存储读取到的数据
        byte[] bys = new byte[3];
        // 3.定义一个整型变量,用来存储读取到的有效字节数
        int len = 0;
        // 4.循环读取
        while((len = fis.read(bys)) != -1) {// 1.读取数据 2.把读取到的数据存储到bys字节数组中 3.把读取到的有效字节数
                                            // 赋值给len 4.拿len和-1比较,如果不等于-1就继续读取
//            System.out.println(new String(bys, 0, len));
            // 5.写入数据
            fos.write(bys, 0, len);
        }
        // 6.关闭流
        fis.close();
        fos.close();
        System.out.println("搞定");
        
        
        
//        byte[] bys = new byte[3];
//        int len = fis.read(bys);
//        System.out.println(len);//3
//        System.out.println(new String(bys,0,len));//abc
//        
//        int len2 = fis.read(bys);
//        System.out.println(len2);//3
//        System.out.println(new String(bys,0,len2));//def
//        
//        int len3 = fis.read(bys);
//        System.out.println(len3);//1
//        System.out.println(new String(bys,0,len3));//gef
//        
        int len4 = fis.read(bys);
        System.out.println(len4);//-1
        System.out.println(new String(bys));//gef

    }

    

## 5_高效缓冲字节流拷贝文件

    public static void main(String[] args) throws IOException {
        // 1.创建一个高效字节输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d.txt"));
        // 2.创建一个高效字节输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("dCopy.txt"));
        // 3.定义一个变量用来存储读取到的字节数据
        int len = 0;
        // 4.循环读取数据
        while((len = bis.read()) != -1) {
            // 5.写入文件中
            bos.write(len);
        }
        //6.关闭流
        bis.close();
        bos.close();
    }

## 6_字符流一次拷贝一个字符&&一次拷贝一个字符数组
            public static void main(String[] args) throws IOException {
        /*
             字节流一次读写一个字节拷贝文件
             字节流一次读写一个字节数组拷贝文件
             高效字节流一次读写一个字节拷贝文件
             高效字节流一次读写一个字节数组拷贝文件
             字符流一次读写一个字符拷贝文件
             字符流一次读写一个字符数组拷贝文件
             高效字符流一次读写一个字符拷贝文件
             高效字符流一次读写一个字符数组拷贝文件
         */
        
        /*
         * 字符流:以单个字符为基本单位来操作的
         *      输入字符流:Reader 用于读取字符流的抽象类
         *      输出字符流:Writer 写入字符流的抽象类
         * */ 
        // 字符流一次读写一个字符数组
        //1.创建一个字符输入流对象,封装数据源文件
        FileReader fr = new FileReader("f.txt");
        //2.创建一个字符输出流对象,封装目的地文件
        FileWriter fw = new FileWriter("fCopy.txt");
        //3.定义一个字符数组,用来存储读取到的字符数据
        // 定义一个变量,用来存储读取到的有效字符数
        char[] chs = new char[3];
        int len = 0;
        // 4. 循环读取,满足条件就继续读
        while((len = fr.read(chs)) != -1) {// 1.读取数据 2.把读取到的字符数据存储在chs字符数组中, 3.把读取到有效字符数
                                          // 赋值给len 4. 拿len和-1比较
            // 5.写入文件中
            fw.write(chs, 0, len);
        }
        // 6.关闭流
        fr.close();
        fw.close();
        System.out.println("搞定");
    }

    private static void method01() throws FileNotFoundException, IOException {
        // 字符流一次读写一个字符
        
        // 1.创建一个字符输入流对象,封装数据源文件
        FileReader fr = new FileReader("e.txt");
        // 2.创建一个字符输出流对象,封装目的地文件
        FileWriter fw = new FileWriter("eCopy.txt");
        // 3. 定义一个变量,用来存储读取到的字符数据
        int len = 0;
        // 4.循环读取数据
        while((len = fr.read()) != -1) {
            // 5.写入文件中
            fw.write(len);
        }
        // 6.关闭流
        fr.close();
        fw.close();
        System.out.println("搞定");
    }

## 7_InputStreamReader 和OutputStreamWriter  ---> 转换流
    InputStreamReader :把字节流转换成字符流,方便文本内容读取
    OutputStreamWriter:把字节流转换成字符流,方便文本内容写入
    public static void main(String[] args) throws IOException {
        /*
             InputStreamReader :把字节流转换成字符流,方便文本内容读取
            OutputStreamWriter:把字节流转换成字符流,方便文本内容写入
         */
        // 需求: 用字节输出流写入一串字符串("我爱学习,我爱Java")到h.txt文件中去
        String str = "我爱学习,我爱Java";
        // 1.字节输出流对象
        FileOutputStream fos = new FileOutputStream("h.txt");
        // 2.把字节输出流转换成字符输出流
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        osw.write(str);
        // 3.关闭流
        osw.close();
        fos.close();
        System.out.println("搞定");
        
    }

    private static void method01() throws FileNotFoundException, IOException {
        //需求: 用字节流读取g.txt中的数据,并输出来
        // 1.创建一个字节输入流读写,封装数据源文件
        FileInputStream fis = new FileInputStream("g.txt");
        // 把字节输入流转换成字符输入流
        InputStreamReader isr = new InputStreamReader(fis);
        
        //2.定义一个变量用来存储读取到的字节数据
        int len = 0;
        // 3.循环读取
        while((len = isr.read()) != -1) {
            // 输出读取到的数据
            System.out.println((char)len);
        }
        // 5.关闭流
        fis.close();
        System.out.println("搞定");
    }

## 8 _字节流和字符流的应用场景

    * 字节流: 
         * 可以操作任意类型的文件, 但是操作中文的时候有可能出现乱码情况.
         * 常用与拷贝图片, 音频, 视频等.
     * 字符流: 专门用来操作中文文件的
         * 当一个文件能用微软自带的记事本打开, 并且里边的内容你也能看得懂, 就可以考虑使用字符流.

## 9_字符高效流一次读写一行数据
    public static void main(String[] args) throws IOException {
        // 高效字符流一次读取一行拷贝文件
        // 1.高效字符输入流对象,封装数据源文件
        // 2.高效字符输出流对象,封装目的地文件
        // 3.定义一个字符串变量,用来记录读取到的行数据
        // 4.循环读取数据,满足条件就一直读
        // 5.写入数据
        // 6.关闭流
        BufferedReader br = new BufferedReader(new FileReader("userInfo.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("ui.txt"));
        String str = null;
        while((str = br.readLine()) != null) {
            bw.write(str);
            // 换行  写一个换行符到文件汇总
            bw.newLine();
//            bw.write("\r\n");
            
        }
        br.close();
        bw.close();
        System.out.println("搞定");
        
    }
    
## 10_IO流的标准异常处理代码
        public static void main(String[] args) {
        // 1.创建一个字节输入流对象,封装数据源文件
        // 2.创建一个字节输出流对象,封装目的地文件
        // 3.定义一个字节数组,用来存储读取到的字节数据
        // 定义一个整型变量,用来存储读取到的有效字节数
        // 4.循环读取,满足条件就一直读取
        // 5.写入数据
        // 6.关闭流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("j.txt");
            fos = new FileOutputStream("jCopy.txt");
            byte[] bys = new byte[3];
            int len = 0;
            while((len = fis.read(bys)) != -1) {
                fos.write(bys, 0, len);
            }
        } catch (Exception e) {
            System.out.println("出现了异常");
        }finally {
            // 一般用来释放资源的,,正常情况下,永远都会执行
            // null 是不可以调用方法的
            try {
                if(fis != null) {
                    fis.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }finally {
                try {// 自动生成try代码块 快捷键: alt + shift + z
                    if(fos != null) {
                        fos.close();
                    }
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }
        System.out.println("搞定");
    }

## 11_使用IO流统计代码行数
    
public static int getFileLine2(String path)  {
        // 1.获取到该路径下的所有.java文件
        // 1.1 把路径封装成一个File对象
        File file = new File(path);
        // 1.2 获取该路径下的所有文件\文件夹
        File[] listFiles = file.listFiles();
        
        //定义一个变量用来记录行数
        int countLine = 0;
        BufferedReader br = null;
        // 1.3 判断listFiles数组是否为空 以及遍历该数组
        if(listFiles != null) {
            for(File file2 : listFiles) {
                // 1.4 判断是文件还是文件夹
                if(file2.isFile() && file2.getName().endsWith(".java")) {
//                    System.out.println(file2);// 说明是一些.java文件
                    
                    // 2.每获取到一个.java文件就计算该文件有多少行
                    try {
                        // 2.1 创建一个高效字符输入流对象
                        br = new BufferedReader(new FileReader(file2));
                        // 2.2 定义一个字符串变量,用来存储读取到的行数据
                        String  str = "";
                        
                        // 2.3 循环读取
                        while((str = br.readLine()) != null) {
                            // 记录行数
                            countLine++;
                        }
                    } catch (Exception e) {
                        System.out.println("出现了异常");
                    }finally {
                        // 2.5 关闭流
                        try {
                            if(br != null) {
                                br.close();
                            }
                        } catch (Exception e) {
                            // TODO 自动生成的 catch 块
                            e.printStackTrace();
                        }
                    }
                }
                
                if(file2.isDirectory()) {
                    countLine += getFileLine2(file2.getAbsolutePath());
                }
            }
        }
        return countLine;
    }

## 12_创建指定大小的空文件
     * 需求: 
         * 在D盘下创建一个2G大小的后缀名为avi的电影

        public static void main(String[] args) throws IOException {
        // 创建一个 苍老师.avi的文件
        // 创建一个字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\苍老师.avi");
        byte[] bys = new byte[1024];//1kb
        for(int i = 0;i< 1024*1024*2 ;i++) {
            fos.write(bys);
        }
        fos.close();
        System.out.println("搞定");
        
    }

## 13_ 从网络中下载资源

        public static void main(String[] args) throws IOException {
        // 从网络中下载资源
        // https://www.baidu.com/img/bd_logo1.png
        // URL 
        // 网络路径
        String path = "https://www.baidu.com/img/bd_logo1.png";
        // 把网络字符串路径封装成URL对象
        URL url = new URL(path);
        // 拷贝文件
        // 通过url对象调用openStream方法得到字节输入流对象
        InputStream is = url.openStream();
        // 创建一个字节输出流对象,封装目的地文件
        FileOutputStream fos = new FileOutputStream("baidu.png");
        // 定义一个变量用来存储读取到的字节数据
        int len = 0;
        // 循环读取数据
        while((len = is.read()) != -1) {
            // 写入文件中
            fos.write(len);
        }
        is.close();
        fos.close();
        System.out.println("搞定了");
    }