《java基础》——IO流(输入输出)

柔情只为你懂 2022-10-01 05:39 225阅读 0赞

##### 输入输出的重要性： #####

输入和输出功能是Java对程序处理数据能力的提高，Java以流的形式处理数据。流是一组有序的数据序列，根据操作的类型，分为输入流和输出流。
     程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“读入”与“写入”操作的流类。
    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。

#### 一.文件处理类File ####

File类是java.io包下代表与平台无关的文件和目录，在程序中操作文件和目录，都可以通过File类来完成。不管是文件还是目录都是使用File来操作的，File类能新建，删除，重命名和目录，File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入 / 输出流.

###### 1.以下为File类提供的方法来操作文件和目录： ######

![在这里插入图片描述][20190611132011103.png]  
![在这里插入图片描述][20190611132030843.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70]

###### 2.File对象的创建方式： ######

<table> 
 <thead> 
  <tr> 
   <th>方法1：</th> 
   <th>方法2：</th> 
   <th>方法3：</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>new File(String pathName)</td> 
   <td>File file = new File(“E://1.txt”)</td> 
   <td>new File(String parent , String child)</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>parent :父抽象路径名；child：子路径名字符串</td> 
  </tr> 
 </tbody> 
</table>

###### 3.代码示例： ######

public class JavaFile {
        public static void main(String[] args) {
    
            String filePath = "src/com/java/io/JavaFile.java";
            // 根据指定路径创建文件对象
            File file = new File(filePath);
            System.out.println("文件名称:" + file.getName());
            System.out.println("文件是否存在：" + file.exists());
            System.out.println("文件的相对路径：" + file.getPath());
            System.out.println("文件的绝对路径：" + file.getAbsolutePath());
            System.out.println("是否为可执行文件：" + file.canExecute());
            System.out.println("文件可以读取：" + file.canRead());
            System.out.println("文件可以写入：" + file.canWrite());
            System.out.println("文件上级路径：" + file.getParent());
            System.out.println("文件大小：" + file.length() + "B");
            System.out.println("文件最后修改时间：" + new Date(file.lastModified()));
            System.out.println("是否文件类型：" + file.isFile());
            System.out.println("是否为文件夹：" + file.isDirectory());
    
        }
    }

###### 4.运行结果： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 1]

#### 二.Java IO 流： ####

###### 1. 流的概念： ######

java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源（source）到接收的（sink）的有序数据。

> 注：java把所有的传统的流类型都放到在java io包下，用于实现输入和输出功能。

###### 2.IO流的分类： ######

2.1 按照数据流的方向不同可以分为：输入流和输出流。

输出流：只能向其写入数据，而不能向其读取数据。  
输入流：只能从中读取数据，而不能向其写入数据。  
此处的输入,输出涉及一个方向的问题，对于如图15.1所示的数据流向，数据从内存到硬盘，通常称为输出流——也就是说，这里的输入，输出都是从程序运行所在的内存的角度来划分的。

> 注：如果从硬盘的角度来考虑，图15.1所示的数据流应该是输入流才对；但划分输入/输出流时是从程序运行所在的内存的角度来考虑的，因此如图15.1所在的流时输出流。而不是输入流。

对于如图15.2所示的数据流向，数据从服务器通过网络流向客户端，在这种情况下,Server端的内存负责将数据输出到网络里，因此Server端的程序使用输出流；Client端的内存负责从网络中读取数据，因此Client端的程序应该使用输入流。  
![在这里插入图片描述][20190611134915786.png]

> 注：java的输入流主要是InputStream和Reader作为基类，而输出流则是主要由outputStream和Writer作为基类。它们都是一些抽象基类，无法直接创建实例。

2.2 按照处理数据单位不同可以分为：字节流和字符流。

字节流：一次读入或读出是8位二进制。  
字符流：一次读入或读出是16位二进制。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

2.3 按照实现功能不同可以分为：节点流和处理流。  
可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，称为节点流。节点流也被称为低级流。图15.3显示了节点流的示意图。  
    从图15.3中可以看出，当使用节点流进行输入和输出时，程序直接连接到实际的数据源，和实际的输入/输出节点连接。  
处理流则用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能。处理流也被称为高级流。图15.4显示了处理流的示意图。  
![在这里插入图片描述][20190611135243570.png]

从图15.4可以看出，当使用处理流进行输入/输出时，程序并不会直接连接到实际的数据源，没有和实际的输入和输出节点连接。使用处理流的一个明显的好处是，只要使用相同的处理流，程序就可以采用完全相同的输入/输出代码来访问不同的数据源，随着处理流所包装的节点流的变化，程序实际所访问的数据源也相应的发生变化。

> 实际上，java使用处理流来包装节点是一种典型的装饰者设计模式，通过使用处理流来包装不同的节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入/输出功能，因此处理流也称为包装流。

###### 3.流的概念模型： ######

java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java Io流的40多个类都是从如下4个抽象类基类中派生出来的。

*  InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
 *  OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。  
       对于InputStream和Reader而言，它们把输入设备抽象成为一个”水管“，这个水管的每个“水滴”依次排列，如图15.5所示：  
        从图15.5可以看出，字节流和字符流的处理方式其实很相似，只是它们处理的输入/输出单位不同而已。输入流使用隐式的记录指针来表示当前正准备从哪个“水滴”开始读取，每当程序从InputStream或者Reader里面取出一个或者多个“水滴”后，记录指针自定向后移动；除此之外，InputStream和Reader里面都提供了一些方法来控制记录指针的移动。  
        ![在这里插入图片描述][2019061113582736.png]  
         对于OutputStream和Writer而言，它们同样把输出设备抽象成一个”水管“，只是这个水管里面没有任何水滴，如图15.6所示：

正如图15.6所示，当执行输出时，程序相当于依次把“水滴”放入到输出流的水管中，输出流同样采用隐示指针来标识当前水滴即将放入的位置，每当程序向OutputStream或者Writer里面输出一个或者多个水滴后，记录指针自动向后移动。  
   图15.5和图15.6显示了java Io的基本概念模型，除此之外，Java的处理流模型则体现了Java输入和输出流设计的灵活性。处理流的功能主要体现在以下两个方面。

*  性能的提高：主要以增加缓冲的方式来提供输入和输出的效率。
 *  操作的便捷：处理流可能提供了一系列便捷的方法来一次输入和输出大批量的内容，而不是输入/输出一个或者多个“水滴”。  
        处理流可以“嫁接”在任何已存在的流的基础之上，这就允许Java应用程序采用相同的代码，透明的方式来访问不同的输入和输出设备的数据流。图15.7显示了处理流的模型。  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 2]

###### 4.java输入/输出流体系中常用的流的分类表： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 3]

> 注：表中粗体字所标出的类代表节点流，必须直接与指定的物理节点关联：斜体字标出的类代表抽象基类，无法直接创建实例

###### 5.常用的Io流用法： ######

下面是整理的常用的Io流的特性及使用方法，只有清楚每个Io流的特性和方法。才能在不同的需求面前正确的选择对应的IO流进行开发。

5.1 Io体系的基类（InputStream/Reader，OutputStream/Writer）。

> 字节流和字符流的操作方式基本一致，只是操作的数据单元不同——字节流的操作单元是字节，字符流的操作单元是字符。所以字节流和字符流就整理在一起了。  
> InputStream和Reader是所有输入流的抽象基类，本身并不能创建实例来执行输入，但它们将成为所有输入流的模板，所以它们的方法是所有输入流都可使用的方法。  
> 在InputStream里面包含如下3个方法。

*  int read(); 从输入流中读取单个字节（相当于从图15.5所示的水管中取出一滴水），返回所读取的字节数据（字节数据可直接转换为int类型）。
 *  int read(byte\[\] b)从输入流中最多读取b.length个字节的数据，并将其存储在字节数组b中，返回实际读取的字节数。
 *  int read(byte\[\] b,int off,int len); 从输入流中最多读取len个字节的数据，并将其存储在数组b中，放入数组b中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字节数。

在Reader中包含如下3个方法。

*  int read(); 从输入流中读取单个字符（相当于从图15.5所示的水管中取出一滴水），返回所读取的字符数据（字节数据可直接转换为int类型）。
 *  int read(char\[\] b)从输入流中最多读取b.length个字符的数据，并将其存储在字节数组b中，返回实际读取的字符数。
 *  int read(char\[\] b,int off,int len); 从输入流中最多读取len个字符的数据，并将其存储在数组b中，放入数组b中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字符数。

对比InputStream和Reader所提供的方法，就不难发现这两个基类的功能基本是一样的。InputStream和Reader都是将输入数据抽象成如图15.5所示的水管，所以程序即可以通过read()方法每次读取一个”水滴“，也可以通过read（char\[\] chuf）或者read（byte\[\] b）方法来读取多个“水滴”。当使用数组作为read（）方法中的参数, 我们可以理解为使用一个“竹筒”到如图15.5所示的水管中取水，如图15.8所示read(char\[\] cbuf)方法的参数可以理解成一个”竹筒“，程序每次调用输入流read(char\[\] cbuf)或read（byte\[\] b）方法，就相当于用“竹筒”从输入流中取出一筒“水滴”，程序得到“竹筒”里面的”水滴“后，转换成相应的数据即可；程序多次重复这个“取水”过程，直到最后。程序如何判断取水取到了最后呢？直到read（char\[\] chuf）或者read（byte\[\] b）方法返回-1，即表明到了输入流的结束点。

![在这里插入图片描述][20190611140956177.png]  
InputStream和Reader提供的一些移动指针的方法：

*  void mark(int readAheadLimit); 在记录指针当前位置记录一个标记（mark）。
 *  boolean markSupported(); 判断此输入流是否支持mark()操作，即是否支持记录标记。
 *  void reset(); 将此流的记录指针重新定位到上一次记录标记（mark）的位置。
 *  long skip(long n); 记录指针向前移动n个字节/字符。

OutputStream和Writer：  
OutputStream和Writer的用法也非常相似，它们采用如图15.6所示的模型来执行输入，两个流都提供了如下三个方法：

*  void write(int c); 将指定的字节/字符输出到输出流中，其中c即可以代表字节，也可以代表字符。
 *  void write(byte\[\]/char\[\] buf); 将字节数组/字符数组中的数据输出到指定输出流中。
 *  void write(byte\[\]/char\[\] buf, int off,int len ); 将字节数组/字符数组中从off位置开始，长度为len的字节/字符输出到输出流中。

因为字符流直接以字符作为操作单位，所以Writer可以用字符串来代替字符数组，即以String对象作为参数。Writer里面还包含如下两个方法。

*  void write(String str); 将str字符串里包含的字符输出到指定输出流中。
 *  void write (String str, int off, int len); 将str字符串里面从off位置开始，长度为len的字符输出到指定输出流中。  
    5.2 Io体系的基类文件流的使用(FileInputStream/FileReader ，FileOutputStream/FileWriter)

前面说过InputStream和Reader都是抽象类，本身不能创建实例，但它们分别有一个用于读取文件的输入流：FileInputStream和FileReader，它们都是节点流——会直接和指定文件关联。下面程序示范使用FileInputStream和FileReader。

InputStream和Reader都是抽象类，本身不能创建实例，但它们分别有一个用于读取文件的输入流：FileInputStream和FileReader,它们都是节点流——会直接和指定文件关联。

###### 代码示例： ######

使用FileInputStream读取文件：

package com.java.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.Date;
    
    /**   
     * @ClassName:  JavaFile   
     * @Description:TODO   
     * @author: lsh
     * @date:   2019年6月11日    
     */
    public class JavaFile {
        public static void main(String[] args) {
    
            String filePath = "src/com/java/io/JavaFile.java";
            // 根据指定路径创建文件对象
            try {
                // 创建字节输入流 
                FileInputStream fis = new FileInputStream(filePath);
                // 创建一个长度为1024的“竹筒”
                byte[]  bbuf = new byte[1024];
                // 用于保存实际读取的字节数
                int hasRead = 0;
                // 使用循环来重复“取水”过程
                while ((hasRead = fis.read(bbuf)) > 0) {
                    // 取出“竹筒” 中的水滴（字节），将字节数组转换成字符串输入
                    System.out.println(new String(bbuf, 0 , hasRead));
                }
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    }

###### 运行结果 ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 5]  
上面程序中的while循环就是使用FileInputStream循环“取水”的过程。

> 注：上面程序最后使用了fis.close()来关闭该文件的输入流，与JDBC编程一样，程序里面打开的文件IO资源不属于内存的资源，垃圾回收机制无法回收该资源，所以应该显示的关闭打开的IO资源。Java 7改写了所有的IO资源类，它们都实现了AntoCloseable接口，因此都可以通过自动关闭资源的try语句来关闭这些Io流。

使用FileReader读取文件：

package com.java.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.util.Date;
    
    /**   
     * @ClassName:  JavaFile   
     * @Description:TODO   
     * @author: lsh
     * @date:   2019年6月11日    
     */
    public class JavaFile {
        public static void main(String[] args) {
    
            String filePath = "src/com/java/io/JavaFile.java";
            // 根据指定路径创建文件对象
            try {
                // 创建字节输入流 
                FileReader fis = new FileReader(filePath);
                // 创建一个长度为1024的“竹筒”
               char[] c = new char[1024];
                // 用于保存实际读取的字节数
                int hasRead = 0;
                // 使用循环来重复“取水”过程
                while ((hasRead = fis.read(c)) > 0) {
                    // 取出“竹筒” 中的水滴（字节），将字节数组转换成字符串输入
                    System.out.println(new String(c, 0 , hasRead));
                }
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 7]

可以看出使用FileInputStream和FileReader进行文件的读写并没有什么区别，只是操作单元不同而且。

FileOutputStream/FileWriter是Io中的文件输出流，下面介绍这两个类的用法。

FileOutputStream的用法：

package com.java.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.Date;
    
    /**   
     * @ClassName:  JavaFile   
     * @Description:TODO   
     * @author: lsh
     * @date:   2019年6月11日    
     */
    public class JavaFile {
        public static void main(String[] args) throws IOException {
    
           
            FileInputStream fis=null;
            FileOutputStream fos=null;
            try {
                //创建字节输入流
                fis=new FileInputStream("src/com/java/io/JavaFile.java");
                //创建字节输出流
                fos=new FileOutputStream("src/com/java/io/JavaFile2.java");
     
                byte[] b=new byte[1024];
                int hasRead=0;
     
                //循环从输入流中取出数据
                while((hasRead=fis.read(b))>0){
                    //每读取一次，即写入文件输入流，读了多少，就写多少。
                    fos.write(b,0,hasRead);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                fis.close();
                fos.close();
            }
            
        }
    }

运行程序可以看到输出流指定的目录下多了一个文件：newTest.txt, 该文件的内容和Test.txt文件的内容完全相同。FileWriter的使用方式和FileOutputStream基本类似，这里就带过。

> 注： 使用java的io流执行输出时，不要忘记关闭输出流，关闭输出流除了可以保证流的物理资源被回收之外，可能还可以将输出流缓冲区中的数据flush到物理节点中里（因为在执行close（）方法之前，自动执行输出流的flush（）方法）。java很多输出流默认都提供了缓存功能，其实我们没有必要刻意去记忆哪些流有缓存功能，哪些流没有，只有正常关闭所有的输出流即可保证程序正常。

5.3 转换流的使用（InputStreamReader/OutputStreamWriter）:  
   下面以获取键盘输入为例来介绍转换流的用法。java使用System.in代表输入。即键盘输入，但这个标准输入流是InputStream类的实例，使用不太方便，而且键盘输入内容都是文本内容，所以可以使用InputStreamReader将其包装成BufferedReader,利用BufferedReader的readLine()方法可以一次读取一行内容，如下代码所示:：

public class InputStreamReaderTest {
        public  static void main(String[] args)throws IOException {
            try {
                // 将System.in对象转化为Reader对象
                InputStreamReader reader=new InputStreamReader(System.in);
                //将普通的Reader包装成BufferedReader
                BufferedReader bufferedReader=new BufferedReader(reader);
               String buffer=null;
               while ((buffer=bufferedReader.readLine())!=null){
                // 如果读取到的字符串为“exit”,则程序退出
                   if(buffer.equals("exit")){
                       System.exit(1);
                   }
                   //打印读取的内容
                   System.out.print("输入内容："+buffer);
               }
            }catch (IOException e){
                e.printStackTrace();
            }finally {
            }
        }
    }

上面程序将System.in包装成BufferedReader,BufferedReader流具有缓存功能，它可以一次读取一行文本——以换行符为标志，如果它没有读到换行符，则程序堵塞。等到读到换行符为止。运行上面程序可以发现这个特征，当我们在控制台执行输入时，只有按

#### 6.何为NIO,和传统Io有何区别？ ####

我们使用InputStream从输入流中读取数据时，如果没有读取到有效的数据，程序将在此处阻塞该线程的执行。其实传统的输入里和输出流都是阻塞式的进行输入和输出。 不仅如此，传统的输入流、输出流都是通过字节的移动来处理的（即使我们不直接处理字节流，但底层实现还是依赖于字节处理），也就是说，面向流的输入和输出一次只能处理一个字节，因此面向流的输入和输出系统效率通常不高。  
    从JDk1.4开始，java提供了一系列改进的输入和输出处理的新功能，这些功能被统称为新IO(NIO)。新增了许多用于处理输入和输出的类，这些类都被放在java.nio包及其子包下，并且对原io的很多类都以NIO为基础进行了改写。新增了满足NIO的功能。  
    NIO采用了内存映射对象的方式来处理输入和输出，NIO将文件或者文件的一块区域映射到内存中，这样就可以像访问内存一样来访问文件了。通过这种方式来进行输入/输出比传统的输入和输出要快的多。

JDk1.4使用NIO改写了传统Io后，传统Io的读写速度和NIO差不了太多。

#### 7.在开发中正确使用Io流 ####

了解了java io的整体类结构和每个类的一下特性后，我们可以在开发的过程中根据需要灵活的使用不同的Io流进行开发。下面是我整理2点原则:

如果是操作二进制文件那我们就使用字节流，如果操作的是文本文件那我们就使用字符流。  
尽可能的多使用处理流，这会使我们的代码更加灵活，复用性更好。

[20190611132011103.png]: /images/20220119/72abaadbefe34ccbaa30ed179195d42c.png
[20190611132030843.png]: /images/20220119/b65653acc6e44c08b9531bfb5ff09e71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70]: /images/20220119/de7d81a42ab54ca7ad0649e332d33f03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 1]: /images/20220119/7d0979ed6330464481d769e1520282f3.png
[20190611134915786.png]: /images/20220119/9f597993bb4f49f58ebffa6b11115f96.png
[20190611135243570.png]: /images/20220119/15000686400a44909a151e8f241409c4.png
[2019061113582736.png]: /images/20220119/89e386ed229046d0b8998714303606a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 2]: /images/20220119/264142fec5764b67bf74aff86e17ab13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 3]: /images/20220119/cef449d4e94149d5a112fc5c9e464488.png
[20190611140956177.png]: /images/20220119/5c0aa2694d694463b4dc4d6ca3ff7a07.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 4]: /images/20220119/c26cca1fae35408e8ac8d32e95231ab7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 5]: /images/20220119/928bc7f40daf4b30be8302201f2a7c4f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 6]: /images/20220119/7ff69be62a0c42a0b70fe563fa710d55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDYxNDIx_size_16_color_FFFFFF_t_70 7]: /images/20220119/088973ed6a82472a95b45a4de2b50a11.png