第十九章 IO 流

一、文件

1. 文件流

文件在程序中是以流的形式来操作的。

流：数据在数据源（文件）和程序（内存）之间经历的路径。
输入流：数据从数据源（文件）到程序（内存）的路径。
输出流：数据从程序（内存）到数据源（文件）的路径。

2. 常用的文件操作

2.1创建文件对象相关构造器和方法

（1）new File(String pathname)：根据路径构建一个File对象

public class Demo {

    public void create01() throws IOException {
        String pathname = "d:\\news1.txt";
        File file = new File(pathname);
        if (file.createNewFile()) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
    }
}

（2）new File(File parent,String child)：根据父目录文件+子路径构建

public class Demo {

    public void create02() throws IOException {
        File parent = new File("d:\\");
        String child = "news2.txt";
        File file = new File(parent, child);
        if (file.createNewFile()) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
    }
}

（3）new File(String parent,String child)：根据父目录+子路径构建

public class Demo {

    public void create03() throws IOException {
        String parent = "d:\\";
        String child = "news3.txt";
        File file = new File(parent, child);
        if (file.createNewFile()) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
    }
}

2.2 获取文件的相关信息

public class Demo {

    public void info() {
        File file = new File("d:\\news1.txt");

        String name = file.getName(); // 文件名字
        String absolutePath = file.getAbsolutePath(); // 文件绝对路径
        String parent = file.getParent(); // 文件父级目录
        long length = file.length(); // 文件大小(字节)
        boolean exists = file.exists(); // 文件是否存在
        boolean b1 = file.isFile(); // 是不是一个文件
        boolean b2 = file.isDirectory(); // 是不是一个目录
    }
}

2.3 目录的操作和文件删除

public class Demo {

    public void m1(){
        File file = new File("d:\\news1.txt");
        if (file.exists()){
            if (file.delete()){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }else {
            System.out.println("文件或目录不存在");
        }
    }
}

public class Demo {

    public void m2(){
        File file = new File("d:\\news1.txt");
        if (file.exists()){
            System.out.println("该文件或目录存在");
        }else {
            // file.mkdir() 创建一级目录
            // file.mkdirs() 创建多级目录
            if (file.mkdirs()){
                System.out.println("该目录创建成功");
            }else {
                System.out.println("该目录创建失败");
            }
        }
    }
}

二、IO 流原理及流的分类

1. Java IO 流原理

（1）I/O 是 input/output 的缩写，I/O 技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。
（2）Java 程序中，对于数据的输入/输出操作以“流（stream）”的方式进行。
（3）java.io 包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。
（4）输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
（5）输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

2. 流的分类

（1）按操作数据单位不同分为：字节流（8bit）【二进制文件】，字符流（按字符）【文本文件】。
（2）按数据流的流向不同分为：输入流，输出流。
（3）按流的角色的不同分为：节点流，处理流/包装流。

（1）Java的 IO 流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
（2）由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

三、IO 流体系图和常用的类

1. IO 流体系图

2. FileInputStream 介绍

2.1 单个字节的读取

单个字节的读取，效率比较低

public class Demo {

    @Test
    public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
            //如果返回-1 , 表示读取完毕
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char) readData);//转成 char 显示
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
}

2.2 字节数组读取

使用 read(byte[] b) 读取文件，提高效率

import org.junit.jupiter.api.Test;

public class Demo {

    @Test
    public void readFile02() {
        String filePath = "e:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8]; //一次读取 8 个字节.
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多 b.length 字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));//显示
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

3. FileOutputStream 介绍

2.1 使用 FileOutputStream 将数据写到文件中

如果文件不存在，会创建文件(注意：前提是目录已经存在)。

import org.junit.jupiter.api.Test;

public class Demo {

    @Test
    public void writeFile() {
        //创建 FileOutputStream 对象
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //得到 FileOutputStream 对象 对象
            //老师说明
            //1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容
            //2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面
            fileOutputStream = new FileOutputStream(filePath, true);
            //写入一个字节
            //fileOutputStream.write('H');//
            //写入字符串
            String str = "hsp,world!";
            //str.getBytes() 可以把 字符串-> 字节数组
            //fileOutputStream.write(str.getBytes());
            /*
            write(byte[] b, int off, int len) 将 len 字节从位于偏移量 off 的指定字节数组写入此文件输出流
            */
            fileOutputStream.write(str.getBytes(), 0, 3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.1 案例 - 文件拷贝

public class Demo {

    public static void main(String[] args) {
        //1. 创建文件的输入流 , 将文件读入到程序
        //2. 创建文件的输出流， 将读取到的文件数据，写入到指定的文件. 
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\Koala3.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            //定义一个字节数组,提高读取效果
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //读取到后，就写入到文件 通过 fileOutputStream
                //即，是一边读，一边写
                fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法
            }
            System.out.println("拷贝 ok~");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流，释放资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4. FileReader 和 FileWriter 介绍

5. FileReader 相关方法

（1）newFileReader（File/String）
（2）read：每次读取单个字符，返回该字符，如果到文件未尾返回-1
（3）read（char[]）：批量读取多个字符到数组，返回读取到的字符数，如果到文件未尾返回-1
相关API:
（1）newString（char[]）：将 chart[] 转换成 String
（2）newString（char[]，off，len）:将 char[] 的指定部分转换成 String

5.1 单个字符读取文件

import org.junit.jupiter.api.Test;

public class Demo {

    @Test
    public void readFile01() {
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        //1. 创建 FileReader 对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用 read, 单个字符读取
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5.2 字符数组读取文件

import org.junit.jupiter.api.Test;

public class Demo {

    @Test
    public void readFile02() {
        System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        //1. 创建 FileReader 对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用 read(buf), 返回的是实际读取到的字符数
            //如果返回-1, 说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6. FileWriter 相关方法

（1）newFileWriter（File/String）：覆盖模式，相当于流的指针在首端
（2）newFileWriter（File/String，true）：追加模式，相当于流的指针在尾端
（3）write（int）：写入单个字符
（4）write（char[]）：写入指定数组
（5）write（char[]，off，len）：写入指定数组的指定部分
（6）write（string）：写入整个字符串
（7）write（string，off，len）：写入字符串的指定部分
相关API:
（1）String类：tocharArray:将String转换成char[]
注意：
FileWriter 使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件！

6.1 使用 FileWriter 写入到文件中

public class Demo {

    public static void main(String[] args) {
        String filePath = "e:\\note.txt";
        //创建 FileWriter 对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
            // 3) write(int):写入单个字符
            fileWriter.write('H');
            // 4) write(char[]):写入指定数组
            fileWriter.write(chars);
            // 5) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("韩顺平教育".toCharArray(), 0, 3);
            // 6) write（string）：写入整个字符串
            fileWriter.write(" 你好北京~");
            fileWriter.write("风雨之后，定见彩虹");
            // 7) write(string,off,len):写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
            //在数据量大的情况下，可以使用循环操作.
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //对应 FileWriter , 一定要关闭流，或者 flush 才能真正的把数据写入到文件
            try {
                //fileWriter.flush();
                //关闭文件流，等价 flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束...");
    }
}

四、节点流和处理流

1. 基本介绍

（1）节点流可以从一个特定的数据源 读写数据，如 FileReader、FileWrite

（2）处理流（也叫 包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如 BufferedReader、BufferedWriter