IO流的概述和使用

一、IO流（字节流）

1.1 IO流概述

IO流的作用：可以对文件或者网络中的数据进行读、写的操作。

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

IO流分为两大派系：

1.字节流：字节流又分为字节输入流、字节输出流

2.字符流：字符流由分为字符输入流、字符输出流

1.2、IO流（（字节流））--- FileInputStream读取一个字节

字节流中的字节输入流，用InputStream来表示。但是InputStream是抽象类，我们用的是它的子类，叫FileInputStream。

需要用到的方法如下图所示：有构造方法、成员方法

使用FileInputStream读取文件中的字节数据，步骤如下：

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

public class Test1 {
   public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream((""BoWen\\src\\w1.txt""));
​
        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

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

1.3、IO流（字节流）--- FileInputStream读取多个字节

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

使用FileInputStream一次读取多个字节的步骤如下：

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

public class Test2 {
// 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("BoWen\\src\\w1.txt");
​
        // 2、开始读取文件中的字节数据：每次读取多个字节。
        //  public int read(byte b[]) throws IOException
        //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
​
        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。  abc 66
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，倒出多少。
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
        // 性能得到了明显的提升！！
        // 这种方案也不能避免读取汉字输出乱码的问题！！
​
        is.close(); // 关闭流
    }
}

需要我们注意的是：read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。

假设有一个w1.txt文件内容如下：abcde。

每次读取过程如下：

也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte[] bytes = new byte[3]; 第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3； 第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2； 第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1；

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

1.4、IO流（字节流）--- FileInputStream读取全部字节

前面的读取方式，不管是一次读取一个字节，还是一次读取多个字节，都有可能有乱码。那么接下来我们介绍一种，不出现乱码的读取方式。我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。

public static void main(String[] args) throws Exception {
        // 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("BoWen\\src\\itheima03.txt");
​
// 2、准备一个字节数组，大小与文件的大小正好一样大。
        File f = new File("BoWen\\src\\itheima03.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();
    }

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("BoWen\\src\\itheima03.txt");
​
//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));
​
//3、关闭流
is.close(); 

最后，还是要注意一个问题： 一次读取所有字节虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出。

1.5、IO流（字节流）--- FileOutputStream写字节

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

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

 public static void main(String[] args) throws Exception {  
// 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道：覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("BoWen/src/itheima04out.txt");
​
        // 追加数据的管道
        OutputStream os =
                new FileOutputStream("BoWen/src/itheima04out.txt", true);
​
        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节，代表a
        os.write('b'); // 'b'也是一个字节
​
        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);
​
        os.write(bytes, 0, 15);
​
        // 换行符
        os.write("\r\n".getBytes());
​
        os.close(); // 关闭流
    }

1.6、IO流（字节流）--- 字节流复制文件

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

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

 public static void main(String[] args) throws Exception {
        // 需求：复制照片。
        // 1、创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("D:/resource/meinv.png");
        // 2、创建一个字节输出流管道与目标文件接通。
        OutputStream os = new FileOutputStream("C:/data/meinv.png");
        // 3、创建一个字节数组，负责转移字节数据。
        byte[] buffer = new byte[1024]; // 1KB.
        // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
        int len; // 记住每次读取了多少个字节。
        while ((len = is.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }
​
        os.close();
        is.close();
        System.out.println("复制完成！！");
    }

二、IO流资源释放

我们现在知道这个问题了，那这个问题怎么解决呢？ 在JDK7以前，和JDK7以后分别给出了不同的处理方案。

2.1 JDK7以前的资源释放

在JDK7版本以前，我们可以使用try...catch...finally语句来处理。格式如下：

try{
    //有可能产生异常的代码
}catch(异常类 e){
    //处理异常的代码
}finally{
    //释放资源的代码
    //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。
}
 public static void main(String[] args)  {
        InputStream is = null;
        OutputStream os = null;
        try {
            System.out.println(10 / 0);
            // 1、创建一个字节输入流管道与源文件接通
            is = new FileInputStream("BoWen\\src\\itheima03.txt");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("BoWen\\src\\itheima03copy.txt");
​
            System.out.println(10 / 0);
​
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源的操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.2、JDK7以后的资源释放

try(资源对象1; 资源对象2;){
    使用资源的代码
}catch(异常类 e){
    处理异常的代码
}
​
//注意：注意到没有，这里没有释放资源的代码。它会自动是否资源
  public static void main(String[] args)  {
        try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

三、IO流（字符流）

3.1、FileReader类

先学习字符流中的FileReader类，这是字符输入流，用来将文件中的字符数据读取到程序中来。

FileReader读取文件的步骤如下：

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

public static void main(String[] args)  {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("BoWen\\src\\itheima03.txt");
        ){
            // 2、一个字符一个字符的读（性能较差）
//            int c; // 记住每次读取的字符编号。
//            while ((c = fr.read()) != -1){
//                System.out.print((char) c);
//            }
            // 每次读取一个字符的形式，性能肯定是比较差的。
​
            // 3、每次读取多个字符。（性能是比较不错的！）
            char[] buffer = new char[3];
            int len; // 记住每次读取了多少个字符。
            while ((len = fr.read(buffer)) != -1){
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

3.2、FileWriter类

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

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

 public static void main(String[] args) {
        try (
                // 创建一个文件字符输出流管道与目标文件接通。
                // 覆盖管道
                // Writer fw = new FileWriter("BoWen/src/itheima02out.txt");
                // 追加数据的管道
                Writer fw = new FileWriter("BoWen/src/itheima02out.txt", true);
                ){
            // 1、public void write(int c):写一个字符出去
            fw.write('a');
            fw.write(97);
            //fw.write('张'); // 写一个字符出去
            fw.write("\r\n"); // 换行
​
            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");
​
            // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
            fw.write("我爱你中国abc", 0, 5);
            fw.write("\r\n");
​
            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'我', '爱', 'a', 'b', 'c'};
            fw.write(buffer);
            fw.write("\r\n");
​
            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer, 0, 2);
            fw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

3.3、FileWriter写的注意事项

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

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

//1.创建FileWriter对象
Writer fw = new FileWriter("BoWen/src/itheima03out.txt");
​
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

而下面的代码，加上了flush()方法之后，数据就会立即到目标文件中去。

//1.创建FileWriter对象
Writer fw = new FileWriter("BoWen/src/itheima03out.txt");
​
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');
​
//3.刷新
fw.flush(); 

下面的代码，调用了close()方法，数据也会立即到文件中去。因为close()方法在关闭流之前，会将内存中缓存的数据先刷新到文件，再关流。

//1.创建FileWriter对象
Writer fw = new FileWriter("BoWen/src/itheima03out.txt");
​
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');
​
//3.关闭流
fw.close(); //会先刷新，再关流

但是需要注意的是，关闭流之后，就不能在对流进行操作了。否则会出异常

四、缓冲流

4.1 缓冲字节流

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

读数据时：它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。

在创建缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下

4.2 字符缓冲流

使用BufferedReader读取数据的代码如下：

public static void main(String[] args)  {
        try (
                Reader fr = new FileReader("BoWen\\src\\itheima04.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = br.read(buffer)) != -1){
//                System.out.print(new String(buffer, 0, len));
//            }
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
​
            String line; // 记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示

接下来，用代码演示一下，使用BufferedWriter往文件中写入字符数据。

public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("BoWen/src/itheima05out.txt", true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
        ){
​
            bw.write('a');
            bw.write(97);
            bw.write('张');
            bw.newLine();
​
            bw.write("我爱你中国abc");
            bw.newLine();
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.3 缓冲流性能分析

我们说缓冲流内部多了一个数组，可以提高原始流的读写性能。讲到这有这么一个疑问，它和我们使用原始流，自己加一个8BK数组不是一样的吗？ 缓冲流就一定能提高性能吗？

答：缓冲流不一定能提高性能。

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

① 使用低级流一个字节一个字节的复制

② 使用低级流按照字节数组的形式复制

③ 使用缓冲流一个字节一个字节的复制

④ 使用缓冲流按照字节数组的形式复制

低级流一个字节复制: 慢得简直让人无法忍受
低级流按照字节数组复制(数组长度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

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

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

五、转换流

5.1、InputStreamReader类

学习InputStreamReader类，你看这个类名就比较有意思，前面是InputStream表示字节输入流，后面是Reader表示字符输入流，合在一起意思就是表示可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是字符输入流。

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

需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是是否有乱码。

执行完之后，你会发现没有乱码。

5.2、OutputStreamWriter类

学习OutputStreamWriter类，你看这个类名也比较有意思，前面是OutputStream表示字节输出流，后面是Writer表示字符输出流，合在一起意思就是表示可以把OutputStream转换为Writer，最终OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。

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

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

public static void main(String[] args) {
        // 指定写出去的字符编码。
        try (
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("BoWen/src/itheima07out.txt");
                // 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
                Writer osw = new OutputStreamWriter(os, "GBK");
                // 3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

六、打印流

6.1、打印流基本使用

打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫print(数据)或者println(数据)，它打印啥就输出啥。

打印流有两个，一个是字节打印流PrintStream，一个是字符打印流PrintWriter，如下图所示

PrintStream和PrintWriter的用法是一样的，所以这里就一块演示了。

public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("BoWen/src/itheima08.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("BoWen/src/itheima08.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("BoWen/src/itheima08.txt", true));
                ){
                ps.print(97);   //文件中显示的就是:97
                ps.print('a'); //文件中显示的就是:a
                ps.println("我爱你中国abc"); //文件中显示的就是:我爱你中国abc
                ps.println(true);//文件中显示的就是:true
                ps.println(99.5);//文件中显示的就是99.5
​
                ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

6.2、 重定向输出语句

System.out.println()这句话表示打印输出，但是至于为什么能够输出呢，因为System里面有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。

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

public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");
​
        try ( PrintStream ps = new PrintStream("BoWen/src/itheima09.txt"); ){
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);
​
            System.out.println("烈士暮年"); 
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

此时打印语句，将往文件中打印数据，而不在控制台。

七、数据流

接下我们再学习一种流，这种流在开发中偶尔也会用到。比如，我们想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个DataInputStream和DataOutputStream.

7.1、DataOutputStream类

我们先学习DataOutputStream类，它也是一种包装流，创建DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。

代码如下：往文件中写整数、小数、布尔类型数据、字符串数据

public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("BoWen/src/itheima10out.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("程序员666！");
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

7.2、DataInputStream类

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

代码如下：读取文件中特定类型的数据（整数、小数、字符串等）

public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("BoWen/src/itheima10out.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();
        }
    }

八、序列化流

序列化流是干什么用的呢？ 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。

序列化：意思就是把对象写到文件或者网络中去。（简单记：写对象）
反序列化：意思就是把对象从文件或者网络中读取出来。（简单记：读对象）

8.1、 ObjectOutputStraem类

ObjectOutputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输出流使用。

代码如下：将一个User对象写到文件中去

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

// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;
​
    public User() {
    }
​
    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方法对象到文件。

public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("BoWen/src/itheima11out.txt"));
                ){
            // 1、创建一个Java对象。
            User u = new User("admin", "张三", 32, "666888xyz");
​
            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

怎样才能读懂文件中的对象是什么呢？这里必须用反序列化，自己写代码读。

8.2、ObjectInputStream类

ObjectInputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输入流使用。

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

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

本文由徐磊老师指导完成；