Java面试知识点：File、IO流

逃离我推掉我的手 2022-09-09 14:57 210阅读 0赞

# 问题：Java面试知识点：File、IO流 #

答案：

1.File

listFiles方法注意事项:  
• 当调用者不存在时，返回null  
• 当调用者是一个文件时，返回null  
• 当调用者是一个空文件夹时，返回一体度为0的数组  
• 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回  
• 当调用者是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏内容  
• 当调用者是一个需要权限才能进入的文件夹时，返回null

代码如下：

package com.xy;
    
    import java.io.File;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test01
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/23 0023 16:02
     * @Version: 1.0
     */
    public class test01 {
        public static void main(String[] args) {
            String path="D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0\\01_File";
            File file=new File(path);
            System.out.println(file);
    
            String path1="D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0";
            String path2="01_File";
            File file1=new File(path1,path2);
            System.out.println(file1);
            File file2=new File("D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0");
            File file3=new File(file2,path2);
            System.out.println(file3);
        }
    }
    
    
    
    
    
    public class test02 {
        public static void main(String[] args) throws IOException {
            File file=new File("day07\\a.txt");
            boolean newFile = file.createNewFile();
            System.out.println(newFile);
    
            File file1=new File("day07\\aaa");
            boolean mkdir = file1.mkdir();      //创建一个单级文件夹，
            // 不管调用者有没有后缀名，只能创建单击文件夹
            System.out.println(mkdir);
            boolean mkdirs = file1.mkdirs();    //创建一个多级文件夹
            System.out.println(mkdirs);
        }
    }
    
    
    
    
    
    
    public class test03 {
        public static void main(String[] args) {
            File file=new File("D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0" +
                    "\\01_File\\a.txt");
            boolean delete = file.delete();
            System.out.println(delete);     //如果删除的是文件，那么直接删除，如果删除的是文件夹，
            // 那么能删除空文件夹，如果要删除一个有内容的文件夹，只能先进入到这个文件夹，
            // 把里面的内容全部删除完毕，才能再次删除这个文件夹
            //简单来说：只能删除文件和空文件夹
        }
    }
    
    
    
    
    
    public class test04 {
        public static void main(String[] args) {
            File file=new File("D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0" +
                    "\\01_File\\06-File的获取和判断方法.flv");
            boolean b = file.isDirectory();     //判断是否为文件夹
            System.out.println(b);
            boolean b1 = file.isFile();         //判断是否为文件
            System.out.println(b1);
            boolean b2 = file.exists();         //判断文件是否存在
            System.out.println(b2);
            String name = file.getName();       //获取文件或目录的名称
            System.out.println(name);
    
            File file1=new File("D:\\");
            File[] files = file1.listFiles();
            for (File file2 : files) {
                System.out.println(file2);
            }
            //进入文件夹，获取这个文件夹里面所有的文件和文件夹的File对象，并把这些File对象都放在一个数组
            // 中返回，包括隐藏文件和隐藏文件夹都可以获取
            //注意事项：
            //1.当调用者是一个文件时
            //2.当调用者是一个空文件夹时
            //3.当调用者是一个有内容的文件夹时
            //4.当调用者是一个有权限才能进入的文件夹时
        }
    }
    
    
    
    
    
    public class test05 {
        public static void main(String[] args) throws IOException {
            File file=new File("day07\\aaa");
            file.mkdirs();
            File file1=new File(file,"a.txt");
            boolean newFile = file1.createNewFile();
            System.out.println(newFile);
        }
    }
    
    
    
    
    public class test06 {
        public static void main(String[] args) {
            File file=new File("D:\\Java\\2021Java传智播客\\09_第九章 IO流-V10.0\\" +
                    "01_File\\a");
    //        deleteFile(file);
            HashMap<String,Integer> hashMap=new HashMap<>();
            count(new File("D:\\LeetCode"),hashMap);
            String s="a.txt";
            String[] split = s.split("\\.");
            for (String s1 : split) {
                System.out.println(s1);
            }
            System.out.println(hashMap);
        }
        public static void deleteFile(File file){
            if (file==null){
                return;
            }
            File[] files = file.listFiles();
            for (File file1 : files) {
                if (file1.isFile()){
                    file1.delete();
                    continue;
                }
                else {
                    deleteFile(file1);
                }
            }
            file.delete();
        }
    
        public static void count(File file,HashMap<String,Integer> hashMap){
            File[] files = file.listFiles();
            if (files==null){
                return;
            }
            for (File file1 : files) {
                if (file1.isFile()){
                    System.out.println(file1.getName());
                    if (file1.getName().split("\\.").length<2){
                        continue;
                    }
                    String s = file1.getName().split("\\.")[1];
                    System.out.println(s);
                    hashMap.put(s,hashMap.getOrDefault(s,0)+1);
                }
                else {
                    count(file1,hashMap);
                }
            }
        }
    }

2.IO流

（1）字节流

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

代码如下：

package com.xy;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test08字节流
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/24 0024 10:51
     * @Version: 1.0
     */
    public class test08字节流 {
        public static void main(String[] args) throws IOException {
            //第二个参数就是续写开关，如果没有传递，默认就是false，
            // 表示不打开续写功能，那么创建对象的这行代码会清空文件
    //        FileOutputStream fos=new FileOutputStream("day07\\b.txt",true);
            //如果第二个参数为true，表示打开续写功能
            //那么创建对象的这行代码不会清空文件
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream("day07\\b.txt");
                byte[] bytes = {6, 66, 66};
                String s = "\r\n";
                fos.write(bytes);
    //        fos.write(bytes,1,2);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    
    public class test09字节流 {
        public static void main(String[] args) throws IOException {
            //如果文件存在，那么就不会报错。
            //如果文件不存在，那么就直接报错。
            FileInputStream fis=new FileInputStream("day07\\b.txt");
            int read =0;
            //一次读取一个字节，返回值就是本次读到的那个字节数据
            //也就是字符在码表中对应的那个数字，
            //如果我们想要看到的是字符数据，那么一定要强转成char
            System.out.println(read);
            System.out.println((char)read);
            while ((read=fis.read())!=-1){
                System.out.println((char)read);
                //一次读取一个字节，返回值就是本次读到的那个字节数据
                //也就是字符在码表中对应的那个数字，
                //如果我们想要看到的是字符数据，那么一定要强转成char
            }
            fis.close();
        }
    }

public class test10字节流 {
        public static void main(String[] args) throws IOException {
            FileInputStream fis=null;
            FileOutputStream fos=null;
            try {
                fis=new FileInputStream("C:\\Users\\Administrator\\Pictures" +
                        "\\Saved Pictures\\1.jpg");
                fos=new FileOutputStream("day07\\1.jpg");
                int read=0;
                while ((read=fis.read())!=-1){
                    fos.write(read);
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis!=null){
                    try {
                        fis.close();
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

package com.xy;
    
    import java.io.*;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test12字节缓冲流
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/24 0024 15:12
     * @Version: 1.0
     */
    public class test12字节缓冲流 {
        public static void main(String[] args) throws IOException {
            BufferedInputStream bis=null;       //在底层创建了一个默认长度为8192的字节数组。
            BufferedOutputStream bos=null;      //在底层也创建了一个默认长度为8192的字节数组。
            long l = System.currentTimeMillis();
            try {
                bis=new BufferedInputStream(new FileInputStream("D:" +
                        "\\360安全浏览器下载\\" +
                        "CentOS-7-x86_64-DVD-1804.iso"));
                bos=new BufferedOutputStream(new FileOutputStream("" +
                        "day07\\1.iso"));
                System.out.println("开始拷贝数据");
                int length=0;
                while ((length=bis.read())!=-1){
                    bos.write(length);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (bis!=null){
                    try {
                        //方法的底层会把字节流给关闭。
                        bis.close();
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            long l1 = System.currentTimeMillis();
            System.out.println("结束，时间"+(l1-l));
        }
    }
    
    
    
    package com.xy;
    
    import java.io.*;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test12字节缓冲流
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/24 0024 15:12
     * @Version: 1.0
     */
    public class test13字节缓冲流 {
        public static void main(String[] args) throws IOException {
            BufferedInputStream bis=null;       //在底层创建了一个默认长度为8192的字节数组。
            BufferedOutputStream bos=null;      //在底层也创建了一个默认长度为8192的字节数组。
            long l = System.currentTimeMillis();
            try {
                bis=new BufferedInputStream(new FileInputStream("D:" +
                        "\\360安全浏览器下载\\" +
                        "CentOS-7-x86_64-DVD-1804.iso"));
                bos=new BufferedOutputStream(new FileOutputStream("" +
                        "day07\\1.iso"));
                System.out.println("开始拷贝数据");
                int length=0;
                byte[] bytes=new byte[1024];
                while ((length=bis.read(bytes))!=-1){
                    bos.write(bytes,0,length);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (bis!=null){
                    try {
                        //方法的底层会把字节流给关闭。
                        bis.close();
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            long l1 = System.currentTimeMillis();
            System.out.println("结束，时间"+(l1-l));
        }
    }

2.字符流

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

代码如下：

package com.xy;
    
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test14字符流
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/24 0024 15:41
     * @Version: 1.0
     */
    public class test14字符流 {
        public static void main(String[] args) throws UnsupportedEncodingException {
            String s="手可摘星辰";
            byte[] bytes = s.getBytes();
            System.out.println(Arrays.toString(bytes));
            for (byte aByte : bytes) {
                System.out.println(aByte);
            }
            System.out.println("************");
            byte[] bytes1 = s.getBytes("GBK");
            System.out.println(Arrays.toString(bytes1));
            for (byte b : bytes1) {
                System.out.println(b);
            }
    
            byte[] b1={-26, -119, -117, -27, -113, -81, -26, -111, -104,
                    -26, -104, -97, -24, -66, -80};
            byte[] b2={-54, -42, -65, -55, -43, -86, -48, -57, -77, -67};
            String s1=new String(b1);       //利用默认的UTF-8进行解码
            System.out.println(s1);
            String s2=new String(b2,"gbk");       //利用GBK进行解码
            System.out.println(s2);
        }
    }
    
    
    
    
    
    public class test15字符流 {
        public static void main(String[] args) throws IOException {
            //创建字符输出流的对象
    //        FileWriter fw=new FileWriter(new File("day07\\c.txt"));
            FileWriter fw=new FileWriter("day07\\c.txt");
            fw.write(6);
            char[] bytes={6,66,66};
            fw.write(bytes,0,2);
            fw.write("手可摘星辰");
    //        fw.flush();       //刷新流。刷新完毕之后，还可以继续写数据
            fw.close();         //关闭流。释放资源。一旦关闭，就不能写数据
        }
    }
    
    
    
    
    public class test16字符流 {
        public static void main(String[] args) throws IOException {
            //创建字符输入流对象
    //        FileReader fr=new FileReader(new File("day07\\c.txt"));
            FileReader fr= null;
            try {
                fr = new FileReader("day07\\c.txt");
                int length=0;
                char[] bytes=new char[1024];
                while ((length=fr.read(bytes))!=-1){
                    System.out.println(length);
                    System.out.println(new String(bytes,0,length));
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fr!=null){
                    fr.close();
                }
            }
        }
    }

package com.xy;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test18字符缓冲输入流
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/24 0024 19:23
     * @Version: 1.0
     */
    public class test18字符缓冲输入流 {
        public static void main(String[] args) throws IOException {
            BufferedReader br= null;
            try {
                br = new BufferedReader(new FileReader("day07\\d.txt"));
                int length=0;
                char[] chars=new char[1024];
                System.out.println(br.readLine());      //一读读一整行，在之前，如果读不到数据，返回-1
                //但是readLine读不到数据返回null
                while ((length=br.read(chars))!=-1){
                    System.out.println(new String(chars,0,length));
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                br.close();
            }
        }
    }
    
    
    
    
    public class test19字符缓冲输出流 {
        public static void main(String[] args) throws IOException {
            BufferedWriter bw= null;
            try {
                bw = new BufferedWriter(new FileWriter("day07\\1.txt"));
                bw.write(6);
                char[] chars={6,66};
                bw.newLine();       //跨平台的回车换行
                bw.write(chars);
                bw.write("手可摘星辰");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                bw.close();
            }
        }
    }

3.对象操作流

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 8][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 9][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_13_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 10][]

代码如下:

public class test21转换流 {
        public static void main(String[] args) throws IOException {
            InputStreamReader isr=new InputStreamReader(new FileInputStream("" +
                    "day07\\d.txt"));
            int length=0;
            while ((length=isr.read())!=-1){
                System.out.println((char) length);
            }
            isr.close();
    
            OutputStreamWriter osw=new OutputStreamWriter(
                    new FileOutputStream("day07\\2.txt"));
            osw.write("手可摘星辰");
            osw.close();
        }
    }
    
    
    
    
    public class test22对象操作流 {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            User user=new User("杨大大","666");
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(
                    "day07\\3.txt"));
            //Exception in thread "main" java.io.NotSerializableException: com.xy.User
            //对象操作流对象要序列化
            oos.writeObject(user);
            oos.close();
    
            //Exception in thread "main" java.io.InvalidClassException:
            // com.xy.User; local class incompatible:
            //如果我们修改了类中的信息，那么虚拟机会再次计算出一个序列号，把文件中的对象读到内存，本地中
            //的序列号和类中的序列号不一致了。
    
            //解决
            //我们手动给出，而且这个值不要变
    
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("day07\\3.txt"));
            User o = (User)ois.readObject();
            while (true){
                try {
                    User o1 = (User)ois.readObject();
                } catch (IOException e) {
                    break;
                }
            }
            System.out.println(o);
            ois.close();
            System.out.println(o.getName());
        }
    }
    package com.xy;
    
    import java.io.Serializable;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: User
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/25 0025 11:05
     * @Version: 1.0
     */
    //如果想要这个类的对象能被序列化，那么这个类必须要实现一个接口.Serializable
    //Serializable接口的意义
    //称之为是一个标记性接口，里面没有任何的抽象方法
    //只要一个类实现了这个Serializable接口，那么表示这个类的对象可以被序列化。
    public class User implements Serializable {
        private String name;
        private transient String password;
    
        private static final long serialVersionUID=1L;
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public User(String name, String password) {
            this.name = name;
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    
        public User() {
        }
    }
    
    
    
    
    
    
    public class test23Properties {
        public static void main(String[] args) {
            Properties properties=new Properties();
            properties.put("杨大大","恒大大");
            System.out.println(properties);
            properties.remove("杨大大");
            System.out.println(properties);
            properties.put("杨大大","恒大大");
            String s = properties.getProperty("杨大大");
            System.out.println(s);
            Set<Object> objects = properties.keySet();
            for (Object object : objects) {
                System.out.println(object);
            }
        }
    }
    
    
    public class test24Properties {
        public static void main(String[] args) throws IOException {
            Properties prop=new Properties();
            FileReader fr=new FileReader("day07\\prop.properties");
            prop.load(fr);  //调用完load方法之后，文件中的键值对数据已经在集合中了
            fr.close();
            System.out.println(prop);
    
            prop.setProperty("杨大大","666");
            FileWriter fw=new FileWriter("day07\\prop1.properties");
            prop.store(fw,"");
            fw.close();
        }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/7a6d44a945b54d478d2df8dc93a7cc3c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/c1a2d44062a34e3990e902e5099dc7f5.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/dd776139abda49e4af89ac75ca1a797e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/4693a7f15c524564a219fb22f25e3698.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/abcb43a46b3f420c83b34e46441e8b3b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/5df70963b75d4f0cbc06704fab9dc8db.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/7c4bef84c1cd43e698d6885a24e21e07.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/31ed4d9cc9b74fe49222fb42a5ba9cd1.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/9d3a1566da6d4c349a42f8360c0c66b6.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20220829/2a7b350809f046b5aad9b0c7c87bea10.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_13_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/277767c2d2d8470aaa30ffb558bafabd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeWFuZzEzNTYzNzU4MTI4_size_20_color_FFFFFF_t_70_g_se_x_16 10]: /images/20220829/79f124edf4fe4edba7a422faef2c9b78.png