IO流

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("搞定了");
}