【Java】IO流（超详细！！）

╰+攻爆jí腚メ 2023-01-13 01:55 134阅读 0赞

### Java IO流 ###

*  Java IO流
 *   *  IO 流的分类
     *   *   *  按照流的方向
             *   *  输入流
                 *  输出流
             *  按照数据单位的不同
             *   *  字节流
                 *  字符流
             *  根据功能不同
             *   *  节点流
                 *  处理流
     *  IO 流的架构
     *   *  四个基本抽象类
         *   *  InputStream 字节输入流
             *  OutputStream 字节输入流
             *  Reader 字符输入流
             *  Writer 字符输出流
             *  总结
         *  IO 流特性
         *  IO 流常用对象
         *   *  File
             *  InputStream
             *   *  FileInputStream
                 *  ByteArrayInputStream
                 *  PipedInputStream
                 *  FilterInputStream
                 *  BufferedInputStream
                 *  DataInputStream
                 *  ObjectInputStream
             *  OutputStream
             *  Reader
             *   *  InputStreamReader
                 *  BufferedReader
                 *  FileReader
                 *  PipedReader
                 *  FilterReader
                 *  CharArrayReader
                 *  StringReader
             *  Writer
         *  字符流和字节流的应用场景
         *  字符流和字节流的区别（重点）
         *  IO 流方法
         *   *  字节流常用方法
             *  字符流常用方法
         *  IO 流使用实例
         *   *  FileInputStream、FileOutputStream（字节流）
             *  BufferedInputStream、BufferedOutputStream（缓冲字节流）
             *  字符流便捷类
             *  BufferedReader、BufferedWriter（字符缓冲流）
         *  序列化与反序列化
         *   *  什么是序列化?
             *  为什么要进行序列化？
             *  什么是反序列化？
             *  序列化的实现 Serializable
             *   *  如何将一个对象序列化？
                 *  反序列化
                 *  transient关键字
                 *  实际实现例子

# Java IO流 #

## IO 流的分类 ##

#### 按照流的方向 ####

> 输入和输出都是相对于我们程序来说

##### 输入流 #####

从别的地方（本地文件、网络上的资源等）获取资源 **输入** 到我们程序中

##### 输出流 #####

从我们程序中 **输出** 到别的地方（本地文件），例如：将一个字符串输出到文件中保存，就是需要用到输出流

#### 按照数据单位的不同 ####

> 首先对单位有个认识： 1 字符 = 2 字节； 1 字节 = 8 位(bit)，1 中文汉字 对应 1 字符、或者 2 字节

##### 字节流 #####

每次读取 / 写出一个字节，当出现中文，使用字节流就会出现乱码的情况

##### 字符流 #####

每次读取 / 写出两个字节，当出现中文，使用字符流不会出现乱码的情况

#### 根据功能不同 ####

##### 节点流 #####

直接操作数据读写的流类

从 / 向一个特定的地方（节点）读写数据。 例如 FileInputStream、FileOutputStream

##### 处理流 #####

是对一个已经存在的流的连接和封装，**通过所封装的流的功能调用实现数据读写。如BufferedReader**。**处理流的构造方法总是要带一个其他的流对象做参**数。一个流对象**经过其他流的多次包装**，功能更加丰富

## IO 流的架构 ##

### 四个基本抽象类 ###

**Java 所有的流都是继承这四个抽象类**

为什么是抽象类不是接口？ 因为Java IO流的设计模式采用的是**装饰者模式**，后面深挖！

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>输入流</th> 
   <th><strong>输出流</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>字节流</strong></td> 
   <td><strong>InputStream</strong></td> 
   <td><strong>OutputStream</strong></td> 
  </tr> 
  <tr> 
   <td><strong>字符流</strong></td> 
   <td><strong>Reader</strong></td> 
   <td><strong>Writer</strong></td> 
  </tr> 
 </tbody> 
</table>

#### InputStream 字节输入流 ####

*  ByteArrayInputStream 节点流
 *  PipedInputStream 节点流
 *  **FilterInputStream**
    
     *  BufferedInputStream 处理流
     *  DataInputStream 处理流
 *  **FileInputStream** 节点流
 *  ObjectInputStream 节点流

#### OutputStream 字节输入流 ####

*  ByteArrayOutputStream 节点流
 *  PipedOutputStream 节点流
 *  FilterOutStream
    
     *  BufferedOutputStream 处理流
     *  DateOutputStream 处理流
     *  PrintStream
 *  **FileOutputStream** 节点流
 *  ObjectOutputStream 节点流

#### Reader 字符输入流 ####

*  CharArrayReader
 *  PipedReader
 *  FilterReader
 *  BufferedReader
 *  InputStreamReader
    
     *  FileReader

#### Writer 字符输出流 ####

*  CharArryWriter
 *  PipedWriter
 *  FilterWriter
 *  BufferedWriter
 *  OutputStreamWriter
    
     *  FilteWriter
 *  PrintWriter

#### 总结 ####

一、对于以上四个抽象类的各种继承子类，如何选择？

1.  首先确定是要输入流还是输出流，如果要读取文件到程序中使用，那么就选择输入流，反之，要将程序的数据输出到文件，那么就选择输出流
2.  其次选择是字节流还是字符流，如果需要操作的数据中包含有中文，那么肯定是使用字符流更加好，反之则选择字节流
3.  根据 1、2 点就可以选出合适的节点流了，比如 FileInputStream 文件输入流，如果想要在这个基础上增加功能，那么**可以从处理流中找到一个合适的**，例如 BufferedInputStream

二、**字符流的由来**

Java 中字符采用的是 Unicode 标准，一个字符是16位的，也就是一个字符对应两个字节。为此，Java引入了处理字符的流。因为数据编码的不同，而又了对字符进行高效操作的流对象。**字符流的本质**就是基于字节流读取时，去查了指定的码表。

### IO 流特性 ###

1.  先进先出， 最先写入输出流的数据最先被输入流读取到
2.  顺序存取，可以一个接着一个地往流中写入一串字节，读出的时候也是按照写入顺序来读取一串字节，不能随机访问中间的数据
3.  只读或者只写，每个流都只能是输入流或者输出流的一种，不能同时具备这两个功能，输入流只能进行读操作，输出流只能进行写操作。如果既要写入数据又要读取数据，那么就分别提供两个流（输入流和输出流）

### IO 流常用对象 ###

常用的对象是五个类一个接口

**五个类：** InputStream，OutputStream、Reader、Writer、File

**接口：** Serializable（序列化接口

#### File ####

1.  File 类是用来**操作文件的类**，但是不能操作文件内的数据。可以通过对象的思想来操作文件和文件夹。
2.  **File类保存文件或目录的各种元数据信息**，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。
3.  构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>File(File parent, String child)</td> 
       <td>根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。</td> 
      </tr> 
      <tr> 
       <td>File(String pathname)</td> 
       <td>通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。</td> 
      </tr> 
      <tr> 
       <td>File(String parent, String child)</td> 
       <td>根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。</td> 
      </tr> 
      <tr> 
       <td>File(URI uri)</td> 
       <td>通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。</td> 
      </tr> 
     </tbody> 
    </table>
4.  常用的成员方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>createNewFile()</td> 
       <td>当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件</td> 
      </tr> 
      <tr> 
       <td>delete()</td> 
       <td>删除此抽象路径名表示的文件或者目录</td> 
      </tr> 
      <tr> 
       <td>exists()</td> 
       <td>判断此抽象路径名表示的文件或者目录是否存在</td> 
      </tr> 
      <tr> 
       <td>getAbsoluteFile()</td> 
       <td>返回此抽象路径名的绝对路径名形式。</td> 
      </tr> 
      <tr> 
       <td>getAbsolutePath()</td> 
       <td>返回此抽象路径名的绝对路径名字符串。</td> 
      </tr> 
      <tr> 
       <td>length()</td> 
       <td>返回由此抽象路径名表示的文件的长度。</td> 
      </tr> 
      <tr> 
       <td>mkdir()</td> 
       <td>创建此抽象路径名指定的目录。</td> 
      </tr> 
     </tbody> 
    </table>
5.  File类使用实例
    
        public class FileTest { 
        	public static void main(String[] args) throws IOException { 
        		File file = new File("C:/Mu/fileTest.txt");
                // 判断文件是否存在
                if (!file.exists()) { 
                    // 不存在则创建
                    file.createNewFile();
                }
                System.out.println("文件的绝对路径：" + file.getAbsolutePath());
                System.out.println("文件的大小：" + file.length());
        
                // 刪除文件
                file.delete();
        	}
        }

#### InputStream ####

InputStream 和 OutputStream 都是抽象类，是字节流的基类，所有具体的字节流实现类都是分别继承了这两个类。

**InputStream常见的实现子类**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70]

##### FileInputStream #####

文件输入流，**非常常用到的一个类**，他通常用来对文件进行读写操作

##### ByteArrayInputStream #####

字节数组输入流，**从字节数组(byte\[\])中进行以字节为单位的读取**，也就是将资源文件都以字节的形式存入到该类中的字节数组中去。

##### PipedInputStream #####

管道字节输入流，能够实现多线程间的管道通信

##### FilterInputStream #####

装饰者类，具体的装饰者继承该类，这些类都是处理类，作用是对节点类进行功能增强，实现特殊功能

##### BufferedInputStream #####

缓冲字节输入流，是继承了FilterInputStream的处理类，内部有一个**缓冲区**，**缓冲区用来存放字节，每次都是将缓存区存满之后在进行发送，而不是一个字节一个字节进行发送，这样的效率更高**

##### DataInputStream #####

数据输入流，是处理类，同样是继承了FilterInputStream，作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。

##### ObjectInputStream #####

对象输入流，用来提供对基本数据或对象的持久存储，**也就是说，能够直接传输对象，通过用在反序列化中，他是一种处理流。构造器的参数是一个InputStream的实例对象**

#### OutputStream ####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70 1][]

OutputStream的常用继承子类和InputStream的常用继承子类相似。

作用相反，我们需要注意这个**PrintSteam**类

#### Reader ####

字符流的两个抽象基类：Reader和Writer

Reader的主要实现子类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70 2]

**截图中划掉的部分是因为，这部分有错**

##### InputStreamReader #####

从字节流到字符流的桥梁。（`InputStreamReader`构造器入参是`FileInputStream`的实例对象），它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定，也可以显式给定，或者可以接受平台的默认字符集。

##### BufferedReader #####

从字符输入流中读取文本，设置一个缓冲区来提高效率。`BufferedReader`是对`InputStreamReader`的封装，前者构造器的入参就是后者的一个实例对象。

##### FileReader #####

用于读取字符文件的便利类，`new FileReader(File file)`等同于`new InputStreamReader(new FileInputStream(file, true),"UTF-8")`，但FileReader不能指定字符编码和默认字节缓冲区大小。

##### PipedReader #####

管道字符输入流。实现多线程间的管道通信

##### FilterReader #####

FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。

##### CharArrayReader #####

从`Char`数组中读取数据的介质流。

##### StringReader #####

从`String`中读取数据的介质流。

#### Writer ####

与Reader的相似，但是同样`Writer`有子类`PrintWriter`

### 字符流和字节流的应用场景 ###

1.  字节流一般用来处理图像，视频，以及PPT，Word类型的文件
2.  字符流一般用来处理纯文本类型的文件，例如txt文件
3.  **字节流也可以处理纯文本文件，但是字符流不能处理图像视频等非文本类型的文件**

### 字符流和字节流的区别（重点） ###

1.  读写单位不同
    
    字节流以字节为单位进行读、写
    
    字符流以字符为单位进行读、写，因为是根据码表映射字节，所以有可能一个字符对应多个字节
2.  处理对象不同
    
    字节流处理的对象可以是视频、图片、ppt、文本文件等等
    
    字符流只能处理纯文本类型的文件
3.  有无缓冲区（详情可以到 http://blog.csdn.net/qq\_25184739/article/details/51203733 查看）
    
     *  字节流是没有缓冲区的，字节流是直接对文件进行处理，如果在输出字符串到文件的时候，如果最后没有调用close方法进行关闭流，那么对应的文件也是有输出的
     *  字符流是自带缓冲区的，如果输出字符串到文件的时候，最后没有调用close方法，那么输出的数据可能有一部分是在缓冲区中，我们可以调用flush方法强制将缓冲流的数据输出到文件

### IO 流方法 ###

#### 字节流常用方法 ####

**字节输入流InputStream主要方法：**

*  read() ：从此输入流中读取一个数据字节。
 *  read(byte\[\] b) ：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
 *  read(byte\[\] b, int off, int len) ：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
 *  close()：关闭此输入流并释放与该流关联的所有系统资源。

**字节输出流OutputStream主要方法：**

*  write(byte\[\] b) ：将 b.length 个字节从指定 byte 数组写入此文件输出流中。
 *  write(byte\[\] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
 *  write(int b) ：将指定字节写入此文件输出流。
 *  close() ：关闭此输入流并释放与该流关联的所有系统资源。

#### 字符流常用方法 ####

**字符输入流Reader主要方法：**

*  read()：读取单个字符。
 *  read(char\[\] cbuf) ：将字符读入数组。
 *  read(char\[\] cbuf, int off, int len) ： 将字符读入数组的某一部分。
 *  read(CharBuffer target) ：试图将字符读入指定的字符缓冲区。
 *  flush() ：刷新该流的缓冲。
 *  close() ：关闭此流，但要先刷新它。

**字符输出流Writer主要方法：**

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

另外，字符缓冲流还有两个独特的方法：

*  `BufferedWriter`类`newLine()` ：**写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。**
 *  `BufferedReader`类`readLine()` ：读取一个文本行。

### IO 流使用实例 ###

#### FileInputStream、FileOutputStream（字节流） ####

**字节流的方式效率较低，不建议使用**

public class IOTest { 
        public static void main(String[] args) throws IOException { 
                File file = new File("D:/test.txt");	write(file);
            System.out.println(read(file));
        }
    
        public static void write(File file) throws IOException { 
            // 第二个参数是追加的意思，不会覆盖之前的数据，默认是false
            OutputStream os = new FileOutputStream(file, true);
    
            // 要写入的字符串
            String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
            // 写入文件
            os.write(string.getBytes());
            // 关闭流
            os.close();
        }
    
        public static String read(File file) throws IOException { 
            InputStream in = new FileInputStream(file);
    
            // 一次性取多少个字节
            byte[] bytes = new byte[1024];
            // 用来接收读取的字节数组
            StringBuilder sb = new StringBuilder();
            // 读取到的字节数组长度，为-1时表示没有数据
            int length = 0;
            // 循环取数据
            while ((length = in.read(bytes)) != -1) { 
                // 将读取的内容转换成字符串
                sb.append(new String(bytes, 0, length));
            }
            // 关闭流
            in.close();
    
            return sb.toString();
        }
    }

#### BufferedInputStream、BufferedOutputStream（缓冲字节流） ####

> 缓冲字节流是为高效率而设计的，真正的读写操作还是靠`FileOutputStream`和`FileInputStream`，所以其构造方法入参是这两个类的对象也就不奇怪了。

public class IOTest { 
    
    	public static void write(File file) throws IOException { 
    		// 缓冲字节流，提高了效率
    		BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
    		// 写入文件
    		bis.write(string.getBytes());
    		// 关闭流
    		bis.close();
    	}
    
    	public static String read(File file) throws IOException { 
    		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度，为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = fis.read(bytes)) != -1) { 
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		fis.close();
    
    		return sb.toString();
    	}
    }

**InputStreamReader、OutputStreamWriter（字符流）**

> **字符流适用于文本文件的读写**，`OutputStreamWriter`类其实也是借助`FileOutputStream`类实现的，故其构造方法是`FileOutputStream`的对象

public class IOTest { 
    	
    	public static void write(File file) throws IOException { 
    		// OutputStreamWriter可以显示指定字符集，否则使用默认字符集
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");
    
    		// 要写入的字符串
    		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
    		osw.write(string);
    		osw.close();
    	}
    
    	public static String read(File file) throws IOException { 
    		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");
    		// 字符数组：一次读取多少个字符
    		char[] chars = new char[1024];
    		// 每次读取的字符数组先append到StringBuilder中
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字符数组长度，为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = isr.read(chars)) != -1) { 
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		isr.close();
    
    		return sb.toString()
    	}
    }

#### 字符流便捷类 ####

> Java提供了`FileWriter`和`FileReader`简化字符流的读写，`new FileWriter`等同于`new OutputStreamWriter(new FileOutputStream(file, true))`

public class IOTest { 
    	
    	public static void write(File file) throws IOException { 
    		FileWriter fw = new FileWriter(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
    		fw.write(string);
    		fw.close();
    	}
    
    	public static String read(File file) throws IOException { 
    		FileReader fr = new FileReader(file);
    		// 一次性取多少个字节
    		char[] chars = new char[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度，为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = fr.read(chars)) != -1) { 
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		fr.close();
    
    		return sb.toString();
    	}
    }

#### BufferedReader、BufferedWriter（字符缓冲流） ####

public class IOTest { 
    	
    	public static void write(File file) throws IOException { 
    		// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
    		// FileOutputStream(file, true), "UTF-8"));
    		// FileWriter可以大幅度简化代码
    		BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
    		bw.write(string);
    		bw.close();
    	}
    
    	public static String read(File file) throws IOException { 
    		BufferedReader br = new BufferedReader(new FileReader(file));
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    
    		// 按行读数据
    		String line;
    		// 循环取数据
    		while ((line = br.readLine()) != null) { 
    			// 将读取的内容转换成字符串
    			sb.append(line);
    		}
    		// 关闭流
    		br.close();
    
    		return sb.toString();
    	}
    }

### 序列化与反序列化 ###

#### 什么是序列化? ####

序列化就是将一个 Java 对象编程二进制内容，二进制内容本质上就是一个byte\[\]数组。

#### 为什么要进行序列化？ ####

因为序列化之后可以把 byte\[\] 数组保存到文件中，或者把 byte\[\] 通过网络传输到远程，就相当于把 Java 对象存储到文件或者通过网络传输出去了。

#### 什么是反序列化？ ####

就是将一个二进制内容（即byte\[\] 数组）变成Java对象，通过反序列化，就可以将保存在文件中的byte\[\] 数组变回 Java对象，或者从网络中读取byte\[\] 数组并且把他变回Java对象

#### 序列化的实现 Serializable ####

需要被序列化的类实现 **Serializable** 接口，这个接口没有任何的抽象方法。**因为他的作用仅仅是为了标注该对象是可以被序列化的**，

##### 如何将一个对象序列化？ #####

通过一个输出流 **ObjectOutputStream** 对象的 **writeObject(Object obj)** 方法就可以将obj对象的状态（内容）写出。

##### 反序列化 #####

如果要将obj对象的内容保存输入到程序中，我们可以通过输入流 **ObjectInputStream** 对象的readObject() 方法，该方法将返回反序列化得到的内容

##### transient关键字 #####

transient 关键字的作用就是，如果类中某个属性不想被序列化，那么就使用该关键字，对象的该属性就不会被序列化，反之也无法反序列化恢复

##### 实际实现例子 #####

1.  定义一个Person类，实现Serializable接口，表示该类的对象可以实例化
    
        package Test;
        
        import java.io.Serializable;
        
        public class Person implements Serializable { 
            private int age;
            private transient String name;
        
            public Person(int age, String name) { 
                this.age = age;
                this.name = name;
            }
        
            public Person() { 
            }
        
            public int getAge() { 
                return age;
            }
        
            public void setAge(int age) { 
                this.age = age;
            }
        
            public String getName() { 
                return name;
            }
        
            public void setName(String name) { 
                this.name = name;
            }
        
            @Override
            public String toString() { 
                return "Person{" +
                        "age=" + age +
                        ", name='" + name + '\'' +
                        '}';
            }
        }
2.  定义ObjectInputStream 对象和 ObjectOutputStream 对象
    
        public static void main(String[] args) throws IOException, ClassNotFoundException { 
            String path = "D:\\java\\LeetCode\\src\\Test\\test.txt";
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File(path)));
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File(path)));
        
            Person p = new Person(18,"小明");
            // 序列化p
            oos.writeObject(p);
            System.out.println("序列化成功");
        
            // 反序列化
            Object o = ois.readObject();
            System.out.println(o);
            System.out.println("反序列化成功");
        
            // 关闭资源
            oos.close();
            ois.close();
        }
3.  程序结果
    
    可以看到结果中，name并没有被复原，这是因为我们对于name属性使用了transient关键字
    
        序列化成功
        Person{ age=18, name='null'}
        反序列化成功
        
        Process finished with exit code 0
4.  查看test.txt文件  
    ![在这里插入图片描述][2021041514471973.png]  
    生成了一些东西，不过这里乱码了  
    ![在这里插入图片描述][20210415144733455.png]  
    本文大部分内容来自：
    
     *  https://blog.csdn.net/mu\_wind/article/details/108674284
     *  https://blog.csdn.net/sinat\_37064286/article/details/86537354

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70]: /images/20221022/01c057892bf648c197b95248a4b873cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70 1]: /images/20221022/ad41e92cc53e422392e940a4d463c248.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9jYXN0bGU_size_16_color_FFFFFF_t_70 2]: /images/20221022/d3174f30b0494981a349cb4e5cb3f615.png
[2021041514471973.png]: /images/20221022/09f1a23736ca4275a37a75f92f128b06.png
[20210415144733455.png]: /images/20221022/011ac43c32b54747b84036eef89f653a.png