java之IO流总结

数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。
• 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流。
• 字符流 ：以字符为单位，读写数据的流。

1 字节流

1.1 字节输出流（OutputStream）

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
• public abstract void write(int b) ：将指定的字节输出流。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

1.1.1 FileOutputStream

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件,是OutputStream的子类。

构造方法

• public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造方法的作用:
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
3.会把FileOutputStream对象指向创建好的文件

写入数据的原理(内存-->硬盘)
    java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

字节输出流的使用步骤(重点):
    1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
    2.调用FileOutputStream对象中的方法write,把数据写入到文件中
    3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

写出字节：write(int b) 方法，每次可以写出一个字节数据。
写出字节数组：write(byte[] b)，每次可以写出数组中的数据。
写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节。

数据追加续写：

• public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了。

代码运行如下：

public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //创建FileOutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos = new FileOutputStream(new File("E:\\java\\JavaseBase02\\day15\\b.txt"));
        //调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write(49);
        fos.write(48);
        fos.write(49);
        /*
            public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
            一次写多个字节:
                如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
                如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
         */
        byte[] bytes = {65,66,67,68,69};
        fos.write(bytes);
        fos.write(bytes,1,2);
         /*
            写入字符的方法:可以使用String类中的方法把字符串,转换为字节数组
                byte[] getBytes()  把字符串转换为字节数组
         */
         byte[] bytes2 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes2));
        fos.write(bytes2);

        //释放资源
        fos.close();
    }
}

运行结果如图：

1.2 字节输入流（InputStream）

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
• public abstract int read()： 从输入流读取数据的下一个字节。
• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

1.1.2 FileInputStream

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1。
使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 。

代码运行如下：

/*    文件复制的步骤:
        1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        3.使用字节输入流对象中的方法read读取文件
        4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
        5.释放资源
 */
public class Demo01CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Pictures\\Saved Pictures\\source code.png");
        //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("E:\\Source code.png");
        //一次读取一个字节写入一个字节的方式
        //3.使用字节输入流对象中的方法read读取文件
      /*  int len = 0;
        while((len = fis.read()) != -1){
            //4.使用字节输出流中的方法write，把读取到的字节写入到目的地的文件中
            fos.write(len);
        }*/
        //使用数组缓冲读取多个字节，写入多个字节
     byte[] bytes = new byte[1024];
        //3.使用字节输入流对象中的方法read读取文件
        int len = 0;  //
        while((len = fis.read(bytes)) != -1){
            fos.write(bytes, 0 ,len);
        }

        //5.释放资源（先关写的，后关读的；如果写完了，肯定读取完毕了）
        fis.close();
        fos.close();
        long e = System.currentTimeMillis();
        System.out.println("复制文件共耗时："+(e-s)+"毫秒");
    }
}

运行结果如图：

2 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2.1 字符输入流（Reader）

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。
• public int read()： 从输入流读取一个字符。
• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

2.1.1 FileReader

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

2. idea中默认UTF-8编码表

3. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
• FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream .

构造方法:
    FileReader(String fileName)
    FileReader(File file)
    参数:读取文件的数据源
        String fileName:文件的路径
        File file:一个文件
    FileReader构造方法的作用:
        1.创建一个FileReader对象
        2.会把FileReader对象指向要读取的文件
字符输入流的使用步骤:
    1.创建FileReader对象,构造方法中绑定要读取的数据源
    2.使用FileReader对象中的方法read读取文件
    3.释放资源

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取。
使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 。

代码运行如下：

public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        //1.创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("E:\\java\\JavaseBase02\\day15\\b.txt");
        //2.使用FileReader对象中的方法read读取文件
        /*int len = 0;
        while((len = fr.read()) != -1){
            System.out.print((char)len);
        }*/
        char[] bytes = new char[1024];
        int len = 0;
        while((len = fr.read(bytes)) != -1){
            System.out.print(new String(bytes,0,len));
        }
        //3.释放资源
        fr.close();
    }
}

运行结果如图：

2.2 字符输出流（Writer）

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• void write(int c) 写入单个字符。
• void write(char[] cbuf)写入字符数组。
• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
• void write(String str)写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
• void flush()刷新该流的缓冲。
• void close() 关闭此流，但要先刷新它。

2.2.1 FileWriter

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

写出字符：write(int b) 方法，每次可以写出一个字符数据。

关闭和刷新：

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

• flush ：刷新缓冲区，流对象可以继续使用。
• close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream。

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便。

代码运行如下：

public class Demo03Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("E:\\java\\JavaseBase02\\day15\\a.txt");
        char[] chars = {'a','b','c','d','e'};
        fw.write(chars);
        fw.flush();
        fw.write(chars,0,3);
        fw.flush();
        fw.write("\r\n");
        fw.write("你好java");
        fw.write("你好java",0,5);
        fw.close();
    }
}

运行结果如图：

2.3 IO异常的处理

2.3.1 JDK7前处理

代码运行如下：

/*
    在jdk1.7之前使用try catch finally 处理流中的异常
    格式:
        try{
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }finally{
            一定会指定的代码
            资源释放
        }
 */
public class Demo01TryCatch {
    public static void main(String[] args) throws IOException {
        //提高变量fw的作用域,让finally可以使用
        //变量在定义的时候,可以没有值,但是使用的时候必须有值
        //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
       try {
           fw = new FileWriter("E:\\java\\JavaseBase02\\day15\\a.txt");
           for (int i = 0; i < 10; i++) {
               //可能会产出异常的代码
               fw.write("HwlloWorld" + i + "\r\n");
           }
       }catch (IOException e) {
                //异常的处理逻辑
                e.printStackTrace();
       }finally {
                //一定会指定的代码
                //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
                if(fw != null){
                    try {
                        fw.close();
                        //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
       }
    }
}

2.3.2 JDK后前处理

代码运行如下：

/*
    JDK7的新特性
    在try的后边可以增加一个(),在括号中可以定义流对象
    那么这个流对象的作用域就在try中有效
    try中的代码执行完毕,会自动把流对象释放,不用写finally
    格式:
        try(定义流对象;定义流对象....){
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }
 */
public class Demo02JDK7 {
    public static void main(String[] args) {
        try{//1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("E:\\java\\JavaseBase02\\day15\\a.txt");
            //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
            FileOutputStream fos = new FileOutputStream("E:\\b.txt");
            //可能会产出异常代码
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read()) != -1){
                fos.write(len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

3 缓冲流

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

• 字节缓冲流：BufferedInputStream，BufferedOutputStream
• 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

3.1 字节缓冲流

构造方法

• public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
• public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。

效率测试代码运行如下：

package Demo01;

import java.io.*;

/*
读写文件效率测试
*/
public class Demo05Tes01 {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
    }

    private static void show03() {
        //记录开始时间
        long start = System.currentTimeMillis();
        //创建流对象
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\Source code.png"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\SourceCode3.png"));){
            //读写数据
            byte[] bytes = new byte[1024];
            int len = 0;
            while((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间："+(end - start)+"毫秒");
    }

    private static void show02() {//缓冲流
        //记录开始时间
        long start = System.currentTimeMillis();
        //创建流对象
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\Source code.png"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\SourceCode2.png"));){
            //读写数据
            int len = 0;
            while((len = bis.read()) != -1){
                bos.write(len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间："+(end - start)+"毫秒");
        System.out.println("=====================================");
    }

    private static void show01() {//基本流
        //记录开始时间
        long start = System.currentTimeMillis();
        //创建流对象
        try(FileInputStream fis = new FileInputStream("E:\\Source code.png");
            FileOutputStream fos = new FileOutputStream("C:\\SourceCode1.png");){
            int len = 0;
            while((len = fis.read()) != -1){
                fos.write(len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间："+(end - start)+"毫秒");
        System.out.println("=====================================");
    }
}

运行结果如图：

3.2 字符缓冲流

• public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
• public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

• BufferedReader：public String readLine(): 读一行文字。
• BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

代码运行如下：

package Demo01;

import java.io.*;
import java.util.HashMap;

/*
    练习:
        对文本的内容进行排序
        按照(1,2,3....)顺序排序
    分析:
        1.创建一个HashMap集合对象,可以:存储每行文本的序号(1,2,3,..);value:存储每行的文本
        2.创建字符缓冲输入流对象,构造方法中绑定字符输入流
        3.创建字符缓冲输出流对象,构造方法中绑定字符输出流
        4.使用字符缓冲输入流中的方法readline,逐行读取文本
        5.对读取到的文本进行切割,获取行中的序号和文本内容
        6.把切割好的序号和文本的内容存储到HashMap集合中(key序号是有序的,会自动排序1,2,3,4..)
        7.遍历HashMap集合,获取每一个键值对
        8.把每一个键值对,拼接为一个文本行
        9.把拼接好的文本,使用字符缓冲输出流中的方法write,写入到文件中
        10.释放资源
 */
public class Demo06Test02 {
    public static void main(String[] args) throws IOException {
        //1.创建一个HashMap集合对象，key:存储每行文本的序号（1,2,3...）；value:存储每行的文本
        HashMap<String ,String> map = new HashMap<>();
        //2.创建字符缓冲输入流对象，构造方法中绑定字符流入流
        BufferedReader br = new BufferedReader(new FileReader("day16\\in.txt"));
        //3.创建字符缓冲输出流对象，构造方法中绑定字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("day16\\out.txt"));
        //4.使用字符缓冲输入流中的方法readLine，逐行读取文本
        String line;
        while((line = br.readLine()) != null){
            //5.对读取到的文本进行切割，获取行中的序号和文本内容
            String[] arr = line.split("\\.");
            //6.把切割好的序号和文本的内容存储到HashMap集合中（key序号是有序的，会自动排序1,2,3,4...）
            map.put(arr[0], arr[1]);
        }

        //7.遍历HashMap集合，获取每个键值对
        for (String key :
                map.keySet()) {
            String value = map.get(key);
            //8.把每个键值对，拼接为一个文本行
            line = key + "." + value;
            //9.把拼接好的文本，使用字符缓冲输出流中的方法wirte，写入到文件中
            bw.write(line);
            bw.newLine();
        }
        //10.释放资源
        bw.close();
        br.close();
    }
}

运行结果如图：

4 转换流

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)–字节(看不懂的)

解码:字节(看不懂的)–>字符(能看懂的)

• 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

  编码表:生活中文字和计算机中二进制的对应规则

字符集

• 字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WfNbwJ6a-1593607966410)(img/1_charset.jpg)]

可见，当指定了编码，它所对应的字符集自然就指定了。

4.1 InputStreamReader

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

使用步骤:

    1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    2.使用InputStreamReader对象中的方法read读取文件
    3.释放资源
    注意事项:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

指定编码读取代码运行如下：

public class Demo03InputStreamReader {
    public static void main(String[] args) throws IOException {
        read_utf_8();
        read_gbk();
    }

    private static void read_gbk() throws IOException {
        //1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是GBK格式的文本.txt"),"GBK");
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read()) != -1){
            System.out.print((char)len);
        }
        //3.释放资源
        isr.close();
    }

    /*
            使用InputStreamReader读取UTF-8格式的文件
         */
    private static void read_utf_8() throws IOException {
        //1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是utf_8格式的文件.txt"));
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read()) != -1){
            System.out.print((char)len);
        }
        //3.释放资源
        isr.close();
        System.out.println("\n===========================");
    }
}

运行结果如图：

4.2 OutputStreamReader

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
• OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

代码运行如下：

/*
    练习：转换文件编码
        将GBK编码的文本文件，转换为UTF-8编码的文本文件。

    分析:
        1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
        2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
        3.使用InputStreamReader对象中的方法read读取文件
        4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
        5.释放资源
 */
public class Demo04Test {
    public static void main(String[] args) throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是GBK格式的文本.txt"),"GBK");
        //2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day16\\我是UTF-8格式的文本.txt"),"UTF-8");
        //3.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read()) != -1){
            //4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中
            osw.write(len);
        }
        // 5.释放资源
        osw.close();
        isr.close();
    }
}

运行结果如图：

转换流是字节与字符间的桥梁！

5 对象流

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

5.1 ObjectOutputStream

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

• public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("java.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

1. 一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

2.写出对象方法

• public final void writeObject (Object obj) : 将指定的对象写出。

5.2 ObjectInputStream

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

• public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

• public final Object readObject () : 读取一个对象。

注意：
对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。**发生这个异常的原因如下：

• 该类的序列版本号与从流中读取的类描述符的版本号不匹配
• 该类包含未知数据类型
• 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

序列化集合代码如下：

/*
    练习：序列化集合
        当我们想在文件中保存多个对象的时候
        可以把多个对象存储到一个集合中
        对集合进序列化和反序列化
    分析:
        1.定义一个存储Person对象的ArrayList集合
        2.往ArrayList集合中存储Person对象
        3.创建一个序列化流ObjectOutputStream对象
        4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
        5.创建一个反序列化ObjectInputStream对象
        6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        7.把Object类型的集合转换为ArrayList类型
        8.遍历ArrayList集合
        9.释放资源
 */
public class Demo03Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.定义一个存储Person对象的ArrayList集合
        ArrayList<Person> list = new ArrayList<>();
        //2.往ArrayList集合中存储Person对象
        list.add(new Person("张三",18));
        list.add(new Person("李四",19));
        list.add(new Person("王五",20));
        //3.创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day16\\list.txt"));
        //4. 使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        oos.writeObject(list);
        //5.创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day16\\list.txt"));
        //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        Object o = ois.readObject();
        //7.把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>)o;
        //8.遍历ArrayList集合
        for (Person p :
                list2) {
            System.out.println(p);
        }
        //9.释放资源
        ois.close();
        oos.close();
    }
}

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name ;
    private int age;

    public Person() {
    }

     Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

运行结果如图：

6 打印流

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

6.1 PrintStream类

构造方法

• public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

使用System.setOut方法改变输出语句的目的地改为参数中传递的打印流的目的地， 输出语句,默认在控制台输出
static void setOut(PrintStream out)
重新分配“标准”输出流。

代码运行如下：

public class Demo01PrintStream {
    public static void main(String[] args) throws FileNotFoundException {
       show01();
       show02();
    }

    private static void show02() throws FileNotFoundException {
        System.out.println("我是在控制台输出的~");

        PrintStream ps = new PrintStream("day16\\print.txt");
        System.setOut(ps);//把输出语句的目的地改变为打印流的目的地
        System.out.println("我在打印流的目的地中输出");

        ps.close();
    }

    public static void show01() throws FileNotFoundException {
        //创建打印流PrintStream对象,构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("day16\\print.txt");
        //如果使用继承父类write方法写数据，那么查看数据的时候会查询编码表
        ps.write(97);

        //如果使用自己特有的方法print/println写数据，写的数据会原样输出
        ps.println(97);
        ps.println("Hello Java");
    }
}

运行结果如图：