Java学习☕ | Java300集课程笔记整理2.0（IO流）

末蓝、 2022-09-14 08:43 110阅读 0赞

### 文章目录 ###

*  一、File类和File对象
 *  二、测试编码和解码（Encode&Decode）
 *   *  2.1 编码（Encode）
     *  2.2 解码（Decode）
 *  三、文件字节输入流
 *   *  3.1 单个字节读取
     *  3.2 分段读取
 *  四、文件字节输出流
 *  五、文件字符输入输出流
 *   *  5.1 实现输入流
     *  5.2 实现输出流
 *  六、文件拷贝（利用文件字节输入输出流）
 *  七、字节数组输入输出流
 *   *  7.1 实现输入流
     *  7.2 实现输出流
 *  八、对接流

--------------------

> 学习视频（Java300集）：[https://www.bilibili.com/video/BV1ct411n7oG][https_www.bilibili.com_video_BV1ct411n7oG]

# 一、File类和File对象 #

*  测试代码

package com.ljh.io;
    import java.io.File;
    
    /*
    测试io和File类:File只是一个路径表示形式，可以构建一个文件、不存在的路径以及文件夹
    1,构建File对象
    2,相对路径和绝对路径
        1）有盘符：绝对路径
        2）没有盘符：相对路径
     */
    public class Test_io_File {
        
        public static void main(String[] args) {
        
    
            //构建一个路径，最好用/来分隔
            String path = "D:/workplace_java/Pro01/io.PNG";
    
            /*利用File的构造器构建File对象，三种方法*/
    
            //1、直接用路径名称
            File src1 = new File(path);
    
            //2、父子结合（2种方法）
            File src2 = new File("D:/workplace_java/Pro01","io.PNG");
            src2 = new File("D:/workplace_java","Pro01/io.PNG");
    
            //3、用父构建的对象和子的名称结合
            File src3 = new File(new File("D:/workplace_java/Pro01"),"io.PNG");
    
            //打印路径的长度
            System.out.println(src1.length());
            System.out.println(src2.length());
            System.out.println(src3.length());
    
            /*测试相对路径和绝对路径*/
    
            //绝对路径
            File src = new File(path);
            System.out.println(src.getAbsoluteFile());//打印绝对路径
    
            //相对路径
            src = new File("io.PNG");
            System.out.println(src.getAbsoluteFile());
    
            //一个不存在的文件也能构建出绝对路径
            src = new File("abc.png");
            System.out.println(src.getAbsoluteFile());
        }
    }

*  测试结果  
    ![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAI3tLZXl9_size_20_color_FFFFFF_t_70_g_se_x_16][]

--------------------

# 二、测试编码和解码（Encode&Decode） #

## 2.1 编码（Encode） ##

*  测试代码：

package com.ljh.io;
    
    import java.io.UnsupportedEncodingException;
    import java.nio.charset.StandardCharsets;
    
    /*
    编码：字符(字符串)->字节
     */
    public class ContentEncode {
        
        public static void main(String[] args) throws UnsupportedEncodingException {
        
    
            String m = "java永远的神";
    
            /*转化成字节数组*/
    
            //使用默认的工程字符集(UTF-16LE，小端，每个字符都是2个字节)
            byte[] datas = m.getBytes();
            System.out.println(datas.length);
    
            //使用GBK编码，中文字符2个字节，英文字符1个字节
            datas = m.getBytes("GBK");
            System.out.println(datas.length);
        }
    }

*  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70][]

## 2.2 解码（Decode） ##

*  测试代码：

package com.ljh.io;
    
    import java.io.UnsupportedEncodingException;
    
    /*
    解码：字节->字符串
     */
    public class ContentDecode {
        
        public static void main(String[] args) throws UnsupportedEncodingException {
        
    
            String m = "java永远滴神";
    
            //先转成字节数组
            byte[] datas = m.getBytes();
    
            /*再转回字符串*/
    
            String m2 = new String(datas,0, datas.length,"UTF-8");
            System.out.println(m2);
    
            /*出现乱码的情况*/
    
            //1)字符数不够(一个中文2个字节，最后的“神”少了一个，所以出现乱码)
            String m3 = new String(datas,0,datas.length-1,"UTF-8");
            System.out.println(m3);
    
            //2)字符集不一致
            String m4 = new String(datas,0, datas.length,"GBK");
            System.out.println(m4);
        }
    }

*  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 1][]

--------------------

# 三、文件字节输入流 #

> 操作流程：
> 
> 1.  创建源
> 2.  选择流
> 3.  操作（读取）
> 4.  释放资源

## 3.1 单个字节读取 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件字节输入流（单个字节读取）：
    1，创建源
    2，选择流
    3，操作
    4，释放资源
     */
    public class IOtest01 {
        
        public static void main(String[] args) {
        
    
            //1，创建源
            File src = new File("abc.txt");
    
            //2，选择流（输入流）
            InputStream is = null;
    
            try {
        
                is = new FileInputStream(src);
    
                try {
        
                    //如果遇到不存在的数据(文件末尾)，就返回-1，故当遇到-1时就结束循环
                    int temp;
                    while((temp = is.read())!= -1)//需要将is.read()赋值给一个变量才能继续访问下一个数据。直接用is.read()会出错
                        System.out.println((char)temp);
    
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    
                //4，释放资源
                if(null != is) {
        
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  abc.txt（源文件）:  
    ![20210203164432373.png][]
 *  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 2][]

## 3.2 分段读取 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件字节输入流（分段读取）
     */
    public class IOtest01_1 {
        
        public static void main(String[] args) {
        
    
            //1，创建源
            File src = new File("abc.txt");
    
            //2，选择流（输入流）
            InputStream is = null;
    
            try {
        
                is = new FileInputStream(src);
    
                //3，操作（分段读取）
                byte[] flush = new byte[3];//作为缓冲容器，每3个读取一次（每三个为一段）
                int len = -1;//记住读取的长度
                while(true){
        
                    try {
        
                        if (!((len = is.read(flush))!= -1)) break;
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                    //字节数组->字符串（解码）
                    String msg = new String(flush,0,len);
                    System.out.println(msg);
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    
                //4，释放资源
                if(null != is) {
        
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  源文件与上图一致
 *  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 3][]

--------------------

# 四、文件字节输出流 #

> 操作流程：
> 
> 1.  创建源
> 2.  选择流
> 3.  操作（写入）
> 4.  释放资源

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件字节输出流
    1、创建源
    2、选择流
    3、操作（写入）
    4、释放资源
     */
    public class IOtest02 {
        
        public static void main(String[] args) {
        
    
            //1,创建源（创建不存在的文件）
            File dest = new File("dest.txt");
    
            //2、选择流（输出流）
            OutputStream os = null;
    
            try {
        
                os = new FileOutputStream(dest);
    
                //3,操作（写入数据）
                String msg = "java is nb";//写入数据内容
                byte[] datas = msg.getBytes();//字符串->字节数组（编码）
    
                try {
        
                    os.write(datas,0, datas.length);//按字节大小写入
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
                try {
        
                    os.flush();//最好要写上，刷新
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
            	//4，释放资源
                if (null != os) {
        
                    try {
        
                        os.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
    
    
        }
    }

*  测试结果（得到的文件）：  
    ![20210203164930587.png][]

--------------------

# 五、文件字符输入输出流 #

> 操作流程：
> 
> 1.  创建源
> 2.  选择流
> 3.  操作（读取）
> 4.  释放资源

## 5.1 实现输入流 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件字符输入流
    1，创建源
    2，选择流
    3，操作（读取）
    4，释放资源
     */
    public class IOtest03 {
        
        public static void main(String[] args) {
        
    
            //1，创建源
            File src = new File("abc.txt");
    
            //2，选择流（输入流）
            Reader reader = null;
    
            try {
        
                reader = new FileReader(src);
    
                //3，操作（分段读取）
                char[] flush = new char[1024];//作为缓冲容器，每k（1024个字节）读取一次，可读取中文
                int len = -1;//记住读取的长度
                while(true){
        
                    try {
        
                        if (!((len = reader.read(flush))!= -1)) break;
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                    //字符数组->字符串
                    String msg = new String(flush,0,len);
                    System.out.println(msg);
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    			//4，释放资源
                if(null != reader) {
        
                    try {
        
                        reader.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  源文件内容：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 4][]
 *  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 5][]

## 5.2 实现输出流 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件字符输出流
    1、创建源
    2、选择流
    3、操作（写入）
    4、释放资源
     */
    public class IOtest04 {
        
        public static void main(String[] args) {
        
    
            //1,创建源（创建不存在的文件）
            File dest = new File("dest1.txt");
    
            //2、选择流（输出流）
            Writer writer = null;
    
            try {
        
                writer = new FileWriter(dest);
    
                //3,操作（写入数据）
                String msg = "java is 牛逼\r\n失败乃成功之母";//写入数据内容（可含中文）
                char[] datas = msg.toCharArray();//字符串->字符数组
    
                writer.write(datas);//可不指定大小
                writer.flush();//记得刷新
            } catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
            	//4，释放资源
                if (null != writer) {
        
                    try {
        
                        writer.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  测试结果（得到文件内容）：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 6][]

--------------------

# 六、文件拷贝（利用文件字节输入输出流） #

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    文件拷贝：文件字节输入、输出流
    利用文件字节输入输出流的代码进行合并即可得到文件拷贝的程序
     */
    public class IOtest_copy {
        
        public static void main(String[] args) {
        
    
            //1，创建源（两个源）
            File src = new File("p.png");//源头
            File dest = new File("p_copy.png");//目的源
    
            //2，选择流（输入、输出流）
            InputStream is = null;
            OutputStream os = null;
    
            try {
        
                is = new FileInputStream(src);
                os = new FileOutputStream(dest);
    
                try {
        
                    //3，操作（分段读取，再写入）
                    byte[] flush = new byte[1024];//1k为单位
                    int len = -1;
                    while((len = is.read(flush))!= -1)//需要将is.read()赋值给一个变量才能继续访问下一个数据。直接用is.read()会出错
                        os.write(flush,0,len);
    
                    os.flush();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    
                //4，释放资源,先打开的后释放（输入的先打开）
                if(null != os) {
        //先释放os
                    try {
        
                        os.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
    
                if (null != is) {
        //再释放is
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  测试结果：

1.  源文件（原图片）：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 7][]
2.  目的文件：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 8][]

--------------------

# 七、字节数组输入输出流 #

## 7.1 实现输入流 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    字节数组输入流：
    1，创建源：源是字节数组，不要太大
    2，选择流
    3，操作
    4，释放资源：可以不用处理
     */
    public class IOtest05 {
        
        public static void main(String[] args) {
        
    
            //1，创建源
            byte[] src = "show me the code".getBytes();//字节数组作为源
    
            //2，选择流（输入流）
            ByteArrayInputStream is = null;//直接用子类创建对象，因为要用到特殊方法
    
            try {
        
                is = new ByteArrayInputStream(src);
    
                try {
        
                    //3,操作，用分段读取
                    byte[] flush = new byte[5];
                    int len = -1;
                    while((len = is.read(flush))!= -1) {
        
                        String msg = new String(flush, 0, len);
                        System.out.println(msg);
                    }
    
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }finally {
        
    
                //4，释放资源(可以不写)
                if(null != is) {
        
                    try {
        
                        is.close();//此时close是空方法
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 9][]

## 7.2 实现输出流 ##

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    字节数组输出流
    1、创建源：内部维护，不用自己创建
    2、选择流：不关联源
    3、操作（写入）
    4、释放资源：可以不用处理
    5、要获取资源
     */
    public class IOtest06 {
        
        public static void main(String[] args) {
        
    
            //1,创建源（可不写）
            byte[] dest = null;//可以不写，只为了风格统一
    
            //2、选择流（输出流）
            ByteArrayOutputStream os = null;//直接用子类创建对象，因为要用到特殊方法
    
            try {
        
                os = new ByteArrayOutputStream();
    
                //3,操作（写入数据）
                String msg = "show me the code";//写入数据内容
                byte[] datas = msg.getBytes();//字符串->字节数组（编码）
    
                os.write(datas,0, datas.length);//按字节大小写入
                try {
        
                    os.flush();//最好要刷新一下
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
    
                //获取资源
                dest = os.toByteArray();
                String str = new String(dest,0,dest.length);
                System.out.println(str+"的长度为"+dest.length);
            } finally {
        
                //4，释放资源(可不写)
                if (null != os) {
        
                    try {
        
                        os.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  测试结果：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 10][]

--------------------

# 八、对接流 #

> 对接流的实现：
> 
>  *  图片读取到字节数组（程序为中转站）
> 
> 1.  图片到程序：`FileInputStream`
> 2.  程序到字节数组：`ByteArrayOutputStream`
> 
>  *  字节数组写入到文件（程序为中转站）
> 
> 1.  字节数组到程序：`ByteArrayInputStream`
> 2.  程序到文件：`FileOutputStream`

*  测试代码：

package com.ljh.io;
    
    import java.io.*;
    
    /*
    对接流
    1、图片读取到字节数组中
    2、字节数组写入到文件中
     */
    public class IOtest07 {
        
        public static void main(String[] args) {
        
    
            //调用方法
            byte[] datas = fileToByteArray("p.png");
            System.out.println("图片大小为"+datas.length);
            byteArrayToFile(datas,"p_data.png");
        }
    
        /*1，图片读取到字节数组中
            1)图片到程序：FileInputStrean
            2)程序到字节数组：ByteArrayOutputStream*/
        public static byte[] fileToByteArray(String filePath) {
        
    
            //1，创建源
            File src = new File(filePath);
            byte[] dest = null;
    
            //2，选择流
            InputStream is = null;
            ByteArrayOutputStream os = null;
    
            try {
        
                is = new FileInputStream(src);
                os = new ByteArrayOutputStream();
    
                try {
        
                    //3，操作
                    byte[] flush = new byte[1024*10];//每10k读取一次
                    int len = -1;
                    while((len = is.read(flush))!= -1)//需要将is.read()赋值给一个变量才能继续访问下一个数据。直接用is.read()会出错
                        os.write(flush,0,len);//写到os（字节数组）里面
    
                    os.flush();
    
                    return os.toByteArray();//返回获取到的资源
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    
                //4，释放资源(可不写os的释放)
                if(null != is) {
        
                    try {
        
                        is.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }
    
         /*2，字节数组写入到文件中
            1)字节数组到程序：ByteArrayInputStream
            2)程序到文件：FileOutputStream*/
        public static void byteArrayToFile(byte[] dest, String filePath) {
        
    
            //1，创建源
            File src = new File(filePath);
    
            //2，选择流
            ByteArrayInputStream is = null;
            OutputStream os = null;
    
            try {
        
                is = new ByteArrayInputStream(dest);
                os = new FileOutputStream(src);
    
                try {
        
                    //3，操作
                    byte[] flush = new byte[1024*10];//每10k读取一次
                    int len = -1;
                    while((len = is.read(flush))!= -1)//需要将is.read()赋值给一个变量才能继续访问下一个数据。直接用is.read()会出错
                        os.write(flush,0,len);//写到os（字节数组）里面
    
                    os.flush();
    
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            }finally {
        
    
                //4，释放资源(可不写is的释放)
                if(null != os) {
        
                    try {
        
                        os.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

*  源文件（原图片）：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 7][]
 *  测试结果及得到的文件：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 11][]  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 12][]

[https_www.bilibili.com_video_BV1ct411n7oG]: https://www.bilibili.com/video/BV1ct411n7oG
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAI3tLZXl9_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/2638e530e9cc4cb09aa8a1d95e4e779e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70]: /images/20220828/b223770554ea48568f1591cf08c23b14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 1]: /images/20220828/21aafd1880954a5885ee4628f4ca60f5.png
[20210203164432373.png]: /images/20220828/9041235288ff4a51897e45fd9e78b00f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 2]: /images/20220828/3446a408004c401aa480ca7db94781ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 3]: /images/20220828/544676315ef84448a5392a945214be2b.png
[20210203164930587.png]: /images/20220828/e2211d77ec184b0d9b6baf096c94f129.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 4]: /images/20220828/777b64ccfb204f1c9160309d372d10f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 5]: /images/20220828/9c4bb59094c545399b620a8dfd320a6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 6]: /images/20220828/b15b0376d1214a7497682c920da8f958.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 7]: /images/20220828/2de253c7c0e34d4d8121982f1b03e744.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 8]: /images/20220828/c7be0611ab86476c849f7a180aa6521d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 9]: /images/20220828/665f8eeeb2774954b91ddd3ea6754533.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 10]: /images/20220828/f994fd41b8c34de4894af86efede64e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 11]: /images/20220828/7c5263bc9aaf43ba96110add638a883c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODkyODUzOQ_size_16_color_FFFFFF_t_70 12]: /images/20220828/3fc3ffd60ca843b8a9d5ab119cae12c6.png