Java进阶6 IO流

---

---

IO

File类的缺陷：File类可以对文件进行操作，但是不能操作文件中的内容。

若想要操作文件的内容，要通过现在即将接触的IO来实现，但在正式接触IO之前，还要了解一个前置的内容：字符集。

一、字符集

● ASCII字符集

计算机发明之初，设计了0和1组成的二进制数据来操作计算机，为了能让计算机能够处理字符，于是在计算机科学家们把会用到的每一个字符进行了编码（所谓编码，就是为一个字符编一个二进制数据），这就是ASCII码的由来。

随着计算机的普及，也由于语言的限制，ASCII字符集已经不够用了，拿中国来说，汉字就是一种特殊的存在。

● GBK字符集

于是国人为了在计算机中存储中文，也编写了一个方便中国人使用的字符集：GBK字符集，里面包含了2万多个汉字字符，GBK中一个汉字采用两个字节来存储， 为了能够显示英文字母，GBK字符集也兼容了ASCII字符集，所以在GBK字符集中，一个字母还是采用一个字节来存储。

● 注意：汉字和字母的编码特点为：

1. 如果是存储字母，采用1个字节来存储，一共8位，其中第1位是0。
2. 如果是存储汉字，采用2个字节来存储，一共16位，其中第1位是1。

当读取文件中的字符时，通过识别读取到的第1位是0还是1来判断是字母还是汉字。

• 如果读取到第1位是0，就认为是一个字母，此时往后读1个字节。
• 如果读取到第1位是1，就认为是一个汉字，此时往后读2个字节。

● Unicode字符集

ASCII字符集代表了使用英语的国家，GBK代表了使用汉语的中国，世界上还有很多的其他语言国家，他们也会有自己的文字，都想用自己熟悉的语言去编码，所以造成了各个国家字符集互不兼容的乱象。

为了解决这个问题，由国际化标准组织牵头，设计了一套全世界通用的字符集，叫做：Unicode字符集。

Unicode字符集中的字符一共有三种编码方案。分别是：UTF-32、UTF-16、UTF-8；其中较为常用的编码方案是UTF-8。

UTF-8的特点：

1.UTF-8是一种可变长的编码方案，工分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节

---

● 字符集小结

ASCII字符集：《美国信息交换标准代码》，包含英文字母、数字、标点符号、控制字符
	特点：1个字符占1个字节

GBK字符集：中国人自己的字符集，兼容ASCII字符集，还包含2万多个汉字
	特点：1个字母占用1个字节；1个汉字占用2个字节

Unicode字符集：包含世界上所有国家的文字，有三种编码方案，最常用的是UTF-8
    UTF-8编码方案：英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节

---

● 解码和编码

了解完字符集之后，再了解如何使用Java代码完成编码和解码的操作。

• 编码：把字符串按照指定的字符集转换为字节数组。
• 解码：把字节数组按照指定的字符集转换为字符串。

/**
 * 目标：掌握如何使用Java代码完成对字符的编码和解码。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、编码
        String data = "a我b";
        byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。
        System.out.println(Arrays.toString(bytes));

        // 按照指定字符集进行编码。
        byte[] bytes1 = data.getBytes("GBK");
        System.out.println(Arrays.toString(bytes1));

        // 2、解码
        String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码
        System.out.println(s1);

        String s2 = new String(bytes1, "GBK");
        System.out.println(s2);
    }
}

---

二、字节流

IO流的作用：

• 把数据从磁盘、网络中读取到程序中来，用到的是输入流。
• 把程序中的数据写入磁盘、网络中，用到的是输出流。
• 简单来说：输入流（读数据）、输出流（写数据）。

IO流分为两大流派：

1. 字节流：字节流又分为字节输入流、字节输出流。
2. 字符流：字符流由分为字符输入流、字符输出流。

IO体系

---

2.1、FileInputStream读取一个字节

了解了IO体系后，接下来介绍字节流中的字节输入流：InputStream，但InputStream是抽象类，那就使用它的子类：FileputStream。

FilepuStream常用的方法如有：构造方法、成员方法。

FilepuStream读取文件的字节数据步骤如下：

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码实现

public static void main(String[] args) throws IOException {
        //1.创建文件字节输入流管道,与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\01.txt"));

        //2.开始读取文件的字节数据
        //public int read(): 每次读取一个字节返回,如果没有数据,则返回-1
        int b = 0; //用于记住读取的字节。
        while((b = is.read()) != -1){
            System.out.println((char)b);
        }
        
        //3.流使用完毕后,必须关闭!释放系统资源!
        is.close();
}

注意：

由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。

2.2、FileInputStream读取多个字节

FileInputStream 调用 read() 方法，可以一次读取一个字节，但这种方法读取效率是非常低的。为了提高效率，我们可以使用另一个read(byte[] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，取决于传递的数组有多大。

FileInputStream一次读取多个字节的步骤

第一步: 创建FIleInputStream文件字节输入管道,与源文件接通。
第二步: 调用read(byte[] bytes)方法开始读取文件的字节数据。
第三步: 调用close() 方法释放资源。

代码实现

public static void main(String[] args) throws IOException {
        //1.创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\\\src\\\\02.txt");

        //2.开始读取文件中的字节数据:每次读取多个字节
        //public int read(byte[] b) throws IOException
        //每次读取多个字节到字节数组中去,返回读取的字节数量,读取完毕会返回-1
        
        //3.使用循环改造
        byte[] bytes = new byte[3];
        int len; //记住每次读取了多少个字节。 
        while((len = is.read(bytes)) != -1){
            //注意:读取多少,就倒出多少。
            String rs = new String(bytes,0,len);
            System.out.println(rs);
        }
        
        is.close(); //关闭流
}

注意：

read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。

假设现在有一个a.txt文件如下：

abcde

每次读取过程如下：

并不是每次读取的时候都把数组装满,比如数组是: byte[] bytes = new byte[3];

第一次调用read(bytes)： 读取了3个字节(分别是97,98,99),并且往数组中村,此时返回值就是3。
第二次调用read(bytes)：读取了2个字节(分别是99,100),并且往数组中村,此时返回值是2。
第三次调用read(bytes)：文件中后面已经没有数据了,此时返回值为-1。

• 还需要注意一个问题：采用一次读取多个字节的方式，也是可能有乱码的。因为也有可能读取到半个汉字的情况。

---

2.3、FileInputStream读取全部字节

不论是一次读取一个字节，还是一次读取多个字节，都有可能有乱码。那么该如何避免这种情况的发生？

一次读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码的出现了。

FIleInputStream 读取全部字节

• 方式一：

自己定义一个字节数组与被读取的文件大小一样大，然后使用该字节数组，一次读完文件的全部字节。

代码实现

public static void main(String[] args) throws IOException {
        //1.一次性读取完文件的全部字节到一个字节数组中去。
        //创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("file-io-app\\src\\03.txt");
        
        //2.准备一个字节数组,大小与文件的大小刚好一样大。
        File f = new File("file-io-app\\src\\03.txt");
        long size = f.length();
        byte[] buffer = new byte[(int) size];
        
        int len = is.read(buffer);
        System.out.println(new String(buffer));
        
        //3.关闭流
        is.close();
    }

• 方式二：

java官方为InputStream提供了如下方法，可以直接把文件的全部字节读取到应该字节数组中返回。

代码实现

public static void main(String[] args) throws IOException {
        //1.一次性读取完文件的全部字节到一个字节数组中去。
        //创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("file-io-app\\src\\03.txt");

        //2.调用方法读取所有字节,返回一个存储所有字节的字节数组。
        byte[] bytes = is.readAllBytes();
        System.out.println(new String(bytes));
        
        //3.关闭流
        is.close();
}

最后，要是要注意一个问题：

一次读取所有字节虽然可以解决乱码问题，但文件不能过大，因为文件过大，可能会导致内存溢出。

---

2.4、FileOutputStream写字节

前面使用了FIleInputStream读取文件中的字节数据。现在往文件中写数据又该怎么做呢？

往文件中写数据就需要用到OutputStream下面的一个子类FIleOutputStream。写输入的流程如下所示：

使用FIleOutputStream往文件中写数据的步骤如下：

第一步: 创建FIleOutputStream文件字节流输出流管道，与目标文件接通。
第二步: 调用wirte()方法往文件中写数据。
第三步: 调用close()方法释放资源。

代码实现

public static void main(String[] args) throws IOException {
        //1.创建FIleOutputStream文件字节输出流管道,与目标文件接通
        OutputStream fileOutputStream = new FileOutputStream("file-io-app/src/04out.txt");

        //2.调用wirte()方法往文件中写数据
        fileOutputStream.write(97); //97是一个字节,代表a
        fileOutputStream.write('b'); //'b'也是一个字节
        //fileOutputStream.write('累'); [ooo] 默认只能写出去一个字节
        byte[] bytes = "中华".getBytes();
        fileOutputStream.write(bytes);
        
        fileOutputStream.write(bytes,0,15);
        
        //3.调用close()方法释放资源
        fileOutputStream.close();

}

---

2.5、字节流复制文件

了解完字节流输入流和字节输出流，现在可以用这两种流配合起来使用，做一个文件复制的综合案例。

复制文件的思路如下图所示：

1. 需要创建一个FIleInputStream流与源文件接通，创建FIleOutputStream与目标文件接通。
2. 然后创建一个数组，使用FIleInputStream每次读取一个字节数组的数据,存入数组中。
3. 然后再使用FIleOutputStream把字节数组中的有效元素,写入目标文件中。

比如：现在要复制一张图片，从磁盘D:/resource/meinv.png的一个位置，复制到C:/data/meinv.png位置。

代码实现

public static void main(String[] args) throws IOException {
        //1.需要创建一个FIleInputStream流与源文件接通,创建FIleOutputStream
        //与目标文件接通。
        FileInputStream fileInputStream = new FileInputStream("D:/resource/meinv.png");
        FileOutputStream fileOutputStream = new FileOutputStream("C:/data/meinv.png");

        //2.创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
        byte[] bytes = new byte[1024];
        int len;

        while((len = fileInputStream.read(bytes)) != -1){
            //3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中
            fileOutputStream.write(bytes,0,len);
        }
        
        //4.关闭流
        fileOutputStream.close();
        fileInputStream.close();
}

---

三、IO流资源释放

之前我们关闭流一般都写在程序的最后，但这种写法会因为一种情况的出现而导致运行不到。

这种问题该怎么解决？

在JDK7前和JDK7后分别给出了不同的处理方案。

3.1、JDK7前的资源释放

在JDK7以前，使用的是try…catch…finally语句来处理，格式如下：

try{
	//有可能产生异常的代码
}catch(异常类 e){
	//处理异常的代码
}fianlly{
	//释放资源的代码
	//finally里面的代码有一个特点,不论异常是否发生,finally里面的代码都会运行。
}

资源释放的代码实现

 public static void main(String[] args) throws IOException {
        //1.需要创建一个FIleInputStream流与源文件接通,创建FIleOutputStream
        //与目标文件接通。
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream("D:/resource/meinv.png");
            fileOutputStream = new FileOutputStream("C:/data/meinv.png");

            System.out.println(10/0);

            //2.创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
            byte[] bytes = new byte[10];
            int len;

            while((len = fileInputStream.read(bytes)) != -1){
                //3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try{
                if (fileOutputStream != null){
                    //关闭输出流
                    fileOutputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
            
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

但JDK7前的代码就会有一个问题：可读性差，在JDK后就有了优化的代码。

---

3.2、JDK后的资源释放

JDK7前的资源处理方式繁琐、可读性差，但从JDK7后Java为我们提供了一种简化的释放资源的操作，它会自动释放资源，代码写起来也比较简单。

语法格式

try(资源对象1;资源对象2;){
	使用资源的代码
}catch(异常类 e){
	处理异常的代码
}
//注意:这里没有释放资源的代码，因为它会自动释放资源。

JDK7后的资源释放演示

public static void main(String[] args) throws IOException {
        //1.需要创建一个FIleInputStream流与源文件接通,创建FIleOutputStream
        //与目标文件接通。
            try(
                FileInputStream  fileInputStream = new FileInputStream("D:/resource/meinv.png");
                FileOutputStream fileOutputStream = new FileOutputStream("C:/data/meinv.png");

                ) {

            //2.创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
            byte[] bytes = new byte[10];
            int len;

            while((len = fileInputStream.read(bytes)) != -1){
                //3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e){
            e.printStackTrace();
        }
    }

---

四、字符流

字节流可以读取文件中的字节数据，但是如果文件中存在中文，使用字节流来读取，就有可能遇到读取半个汉字的情况，这样就会导致乱码，虽然使用读取全部字节的方法不会出现乱码，但是如果文件过大的话又不太合适。

所以Java专门为我们提供了另外一种流：字符流，可以说字符流是专门为读取文本数据而生的。

---

4.1、FileReader类

IO流的体系

FIleReader类：字符输入流，用来将文件中的字符数据读取到程序中的。

FileReader读取文件的步骤：

第一步: 创建FIleReader对象与要读取的源文件接通。
第二步: 调用read()方法读取文件中的字符。
第三步: 调用close() 方法关闭流。

使用字符输出流（FileReader）需要用到的方法：先通过构造器创建对象，再通过read方法读取数据（注意：两个read方法的返回值，含义不一样。）

FileReader的代码使用演示

public static void main(String[] args) throws IOException {
//        第一步：创建FileReader对象与要读取的源文件接通
//        第二步：调用read()方法读取文件中的字符
//        第三步：调用close()方法关闭流
        FileReader fileReader = new FileReader("day09/csb.txt");

        char[] chars = new char[1024];
        int len;//记住每次取了多少个字符

        while ((len = fileReader.read(chars)) != -1){
        	//读取多少就输出多少
            System.out.println(new String(chars,0,len));
        }

          fileReader.close();
    }

---

4.2、FileWriter类

FileReader是字符输入流，可以将文件中的字符数据读取到程序中，接下来，就开始了解FileWriter：它可以将程序中的字符数据写入文件中。

FileWriter往文件中写字符数据的步骤如下：

第一步: 创建FileWirter对象与要读取的目标文件接通。
第二步: 调用write(字符数据/字符数组/字符串)方法读取文件中的字符。
第三步: 调用close() 方法关闭流。

FileWriter需要用到的方法：构造器是用来创建FileWriter对象的，有了对象才能调用write方法写数据到文件。

FileWriter的使用演示

public static void main(String[] args) throws IOException {
//        第一步：创建FileWirter对象与要读取的目标文件接通
//        第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
//        第三步：调用close()方法关闭流
        FileWriter fileWriter = new FileWriter("day09/console.txt");

        // 1、public void write(int c):写一个字符出去
        fileWriter.write('a');
        fileWriter.write(97);
        //fw.write('磊'); // 写一个字符出去
        fileWriter.write("\r\n"); // 换行

        // 2、public void write(String c)写一个字符串出去
        fileWriter.write("我爱你中国abc");
        fileWriter.write("\r\n");

        // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
        fileWriter.write("我爱你中国abc", 0, 5);
        fileWriter.write("\r\n");

        // 4、public void write(char[] buffer):写一个字符数组出去
        char[] buffer = {'我','爱','J','a','v','a'};
        fileWriter.write(buffer);
        fileWriter.write("\r\n");

        // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        fileWriter.write(buffer, 0, 2);
        fileWriter.write("\r\n");

        fileWriter.close();
    }

4.3、FileWriter的注意事项

FileWriter在写完数据之后，必须刷新或者关闭，写出去的数据才能生效。

比如：下面的代码只调用了写数据的方法，没有关流的方法，当我们打开目标文件的时候，是看不到任何数据的。

//1.创建FileWriter对象
Writer fw = new FileWriter("day09/console.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

没有关闭或刷新的console界面

而想要刷新或者关闭，使用flush（）与close（）方法就能实现。

使用flush（）方法来刷新数据

//1.创建FileWriter对象
Writer fw = new FileWriter("day09/console.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.刷新
fw.flush(); 

使用close（）方法关闭程序：因为close（）方法在关闭流之前，会将内存中缓存的数据线刷新到文件中，再关流。

//1.创建FileWriter对象
Writer fw = new FileWriter("day09/console.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.刷新
fw.flush(); 

效果图

注意！！！

关闭流后，就不能再对流进行操作了，否则会出异常。

---

五、缓冲流

导图

字节流与字符流的了解过后，再接下来的就是缓冲流。

缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。

5.1、字节缓冲流

缓冲流式如何提高读写数据的性能的？是因为在缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但缓冲流不能单独使用，需要依赖于原始流。原理如下所示。

• 读数据时：它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中，再从8KB的字节数组中读取一个字节或者多个字节。

• 写数据时：它是先把数据写到缓冲流内部的8KB的数组中，等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去。

在创建缓冲字节流对象时，需封装一个原始流对象进来。

使用缓冲流赋值文件代码演示：

public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("day09/console.txt");
        //1.定义一个字节缓冲输入流包装原始的字节输入流
        InputStream bs = new BufferedInputStream(is);

        OutputStream os = new FileOutputStream("day09/newConsole.txt");
        //2.定义一个字节缓冲输出流包装原始的字节输出流
        OutputStream bos = new BufferedOutputStream(os);

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bs.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        bs.close();
        bos.close();
    }

---

5.2、字符缓冲流

字符缓冲流：它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组，字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。

• BufferedReader读取数据时：原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中，再从8KB的字符数组中读取一个字符或者多个字符。

创建BufferedReader对象需要用到BufferedReader的构造方法，内部需要封装一个原始的字符输入流，我们可以传入FileReader。

而且BufferedReader要有特定的方法，一次可以读取文本文件中的一行。

BufferedReader读取代码的演示

public static void main(String[] args) throws IOException {
        try (
                Reader reader = new FileReader("day09/console.txt");
                //创建一个字符缓冲流包装原始的字符输入流
                BufferedReader bufferedReader = new BufferedReader(reader);
            ){
                String line; //记录每次读取的一行数据
                while ((line = bufferedReader.readLine()) != null){
                    System.out.println(line);
                }
            }catch (Exception e){
                e.printStackTrace();
        }
    }

• BufferedWriter写数据时：它是先把数据写到字符缓冲流内部的8KB的数组中，等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去。如下所示：

创建BufferedWriter对象时需要用到BufferedWriter的构造方法，而且内部需要封装一个原始的字符输出流，这里就可以传递FileWriter。

而且BufferedWriter新增了一个功能，可用来写一个换行符。

使用BufferedWriter往文件中写入字符数据演示

public static void main(String[] args) {
        try (
                Writer writer = new FileWriter("day09/console.txt");
                BufferedWriter bufferedWriter = new BufferedWriter(writer);
            ){
                bufferedWriter.write("ACC");
                bufferedWriter.write("\r\n");
                bufferedWriter.write("BCC");
                bufferedWriter.write("\r\n");
                bufferedWriter.write("DCC");

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

---

5.3、缓冲流性能分析

缓冲流内部多了一个数组，可以提高原始流的读写性能。但是！！它和我们使用原始流，自己加一个8KB数组不是一样的吗？缓冲流就一定能提高性能？答案是：缓冲流不一定能提高性能！！

下面使用一个比较大的文件（889MB）复制，做性能测试，分别使用下面四种方式来完成文件复制，并记录文件复制的时间。

1. 使用低级流一个字节一个字节的复制。
2. 使用低级流按照字节数组的形式复制。
3. 使用缓冲流一个字节一个字节的复制。
4. 使用缓冲流按照字节数组的形式复制。

低级流一个字节复制:慢的让人发指。
低级流按照字节数组复制(数组长度1024) : 12.117s
缓冲流一个字节复制: 11.058s
缓冲流按照字节数组复制(数组长度1024) : 2.163s
【注意：这里的测试只能做一个参考，和电脑性能也有直接关系】

由此我们可以得出结论：默认情况下，采用一次复制1024个字节，缓冲流完胜。

这次采用一次复制8192个字节试试

低级流按照字节数组复制(数组长度8192): 2.535s
缓冲流按照字节数组复制(数组长度8192): 2.088s

由此我们可以得到另一个结论：一次读取8192个字节时，低级流和缓冲流性能相当。 相差的那几毫秒可以忽略不计。

继续把数组变大，现在采用一次读取1024*32个字节数据试试。

低级流按照字节数组复制(数组长度8192): 1.128s
缓冲流按照字节数组复制(数组长度8192): 1.133s

由此又得到了新的结论：数组越大性能越高，低级流和缓冲流性能相当。 相差的那几秒可以忽略不计。

继续把数组变大，现在采用一次读取1024*6个字节数据试试

低级流按照字节数组复制(数组长度8192): 1.039s
缓冲流按照字节数组复制(数组长度8192): 1.151s

此时可以发现，当数组大到一定程度，性能已经提高不了多少了，甚至缓冲流的性能还没低级流高。

最终总结一下

缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。 只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。

---

六、转换流

导图

FileReader默认只能读取UTF-8编码格式的文件。如果使用fileReader读取GBK格式的文件，就可能出现乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节的，这样就会导致乱码。

但是Java提供了另外两种流：InputStreamReader，OutputStreamWriter，这两流被称为转换流。它们可以将字节流转换为字符流，并且可以指定编码方案。

---

6.1 InputStreamReader类

InputStreamReader类：前面半截的名字，InputStream表示字节输入流，后面半截的Reader表示字符输入流，合在一起就表示：可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是字符输入流。

InputStreamReader同样，也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

现在准备一个GBK格式的文件，然后使用下面的代码进行读取，看是否有乱码。

代码实现

 public static void main(String[] args) {
        try (
                //1.得到文件的原始字节流(GBK的字节流形式)
                InputStream is = new FileInputStream("day09/console.txt");
                //2.把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader ra = new InputStreamReader(is,"GBK");
                //3.把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(ra);
            ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }

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

执行完后，并没有发现乱码。

---

6.2 OutputStreamWriter类

OutputStreamWriter：OutputStream表示字节输出流，Writer表示字符输出流，合在一起就表示：把OutputStream转换为Writer，但最终，OutputStreamWriter也是Writer的子类，所以也算是字符输出流。

同样的。OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。

OutputStreamWriter也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

需求：现在准备一个GBK格式的文件，使用下面代码往文件中写字符数据。

public class Test {
    public static void main(String[] args)  {
        //指定写出去的字符编码。

        try {
            //1.创建一个文件字节输出流
            OutputStream fileWriter = new FileOutputStream("day11/console.txt");
            //2.把原始的字节输出流,按照指定的字符集编码转换成字符输出转换流。
            Writer writer = new OutputStreamWriter(fileWriter,"GBK");
            //3.把字符输出流包装成缓冲字符输出流
            BufferedWriter bufferedWriter = new BufferedWriter(writer);

            bufferedWriter.write("123456");
            bufferedWriter.write("好人");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

---

七、打印流

导图

打印流：打印数据，与write方法写数据不同的是，它是打印啥就输出啥。

其实从第一次接触Java代码的时候，我们就一直在使用打印流，比如打印流特有的方法：print（数据）或者println（数据），打印啥就输出啥。

打印流有两个：字节打印流：PrintStream，一个是字符打印流：PrinlWriter。

打印流演示（PrintStream和PrintWriter的用法一样）

public class Test {
    public static void main(String[] args) {
        try (
                //1.创建一个打印流通道
                //PrintStream printStream = new PrintStream("console.txt",Charset.forName("GBK"));
                PrintWriter printWriter = new PrintWriter(new FileOutputStream("console", true));
            ) {
                printWriter.print(97);//文件中显示的就是:97
                printWriter.print('a');//文件中显示的就是:a
                printWriter.println(true);//文件中显示的就是:true
                printWriter.println(99.5);//文件中显示的就是99.5
            
                printWriter.write(97);//文件中显示的是a
            } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

---

● 重定向输出语句

System.out.println(); 这句话在Java中表示打印输出，但至于为什么能够输出，现在就可以揭晓谜底了。

System里有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台。

而且，System还提供了一个方法，可以修改底层的打印流，这样就可以人为重定向打印语句的输出目的地了。

public class PrintTest2 {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");

        try ( PrintStream ps = new PrintStream("io-app2/src/console.txt"); ){
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);

            System.out.println("烈士暮年");	
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

八、数据流

如果我们在开发中想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。

这就可以用到数据流：DataInputStream和DataOutputStream。

8.1 DataOutputStream

DataOutputStream：包装流。

创建DataOutputStream对象时，底层需要依赖于一种原始的OutputStream流对象，然后调用它的wireXxx方法，写的是特定类型的数据。

使用演示

public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("console.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("666！");

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

---

8.2 DataInputStream

DataInputStream：包装流。

创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。

使用演示

public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("console.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

九、序列化流

导图

IO中的最后一个流：序列化流。

字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。

序列化：把对象写到文件或者网络中去。（写对象）
反序列化：把对象从文件或者网络中读取出来。（读对象）

---

9.1 ObjectOutputStream（序列化）

ObjectOutputStream流：包装流，不能单独使用，需要结合原始的字节输出流使用。

ObjectOutputStream的使用步骤：

1. 先准备一个类，必须让其实现Serializable接口。
2. 再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。

使用演示

第一步：先准备一个User类，必须让其实现Serializable接口。

import java.io.Serializable;

public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    //transient这个成员变量将不参与序列化
    private transient String passWord;

    public User(String loginName, String userName, int age, String password) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。

import java.io.*;

public class Test {
    public static void main(String[] args) {

        try(
                //2.创建一个对象字节输出流包装原始的字节输出流。
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("console.txt"));
        ) {
            //1.创建一个Java对象
            User user = new User("admin","李四",33,"6678");
            
            //3.序列化对象到文件中
            objectOutputStream.writeObject(user);
            System.out.println("序列化对象成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：

写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码。

这里必须用反序列化，自己写代码才能读取数据。

---

9.2 ObjectInputStream（反序列化）

ObjectInputStream：与ObjectOutputStream一样，是包装流，不能单独使用，需要结合原始的字节输入流使用。

接上个案例的代码，文件中已经有一个Student对象，现在要使用ObjectInputStream读取出来，称之为反序列化。

public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
            // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("console.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

十、IO框架（节选）

导图

为简化对IO操作，由Apache开源基金组织提供了一组有关IO流的小框架，可以提高IO流的开发效率。

这个框架的名字叫commons-io：本质是别人写好的一些字节码文件（class文件），打包成了一个jar包。我们只需要引入到项目中，就可以直接使用了。

主要了解：FileUtils类，它的部分功能如下：

在写代码之前，需引入jar包，具体步骤如下：

1.在模块的目录下，新建一个lib文件夹
2.把jar包复制粘贴到lib文件夹下
3.选择lib下的jar包，右键点击Add As Library，然后就可以用了。

代码演示

public class CommonsIOTest1 {
    public static void main(String[] args) throws Exception {
        //1.复制文件
        FileUtils.copyFile(new File("console.txt"), new File("newConsole.txt"));
        
        //2.复制文件夹
        FileUtils.copyDirectory(new File("D:\\work\\作业1"), new File("D:\\work\\新作业1"));
        
        //3.删除文件夹
        FileUtils.deleteDirectory(new File("D:\\work\\新作业1"));

        // Java提供的原生的一行代码搞定很多事情
         Files.copy(Path.of("console.txt"), Path.of("newConsole2.txt"));
        System.out.println(Files.readString(Path.of("console.txt")));
    }
}