JAVA提高篇之字符串

小咪咪 2022-12-21 03:18 142阅读 0赞

最近学习JAVA String类，写点博客记录学习笔记，主要从五个部分介绍Java 字符串，（1）字符串String简介  （2）字符串String 常用方法  （3）字符串String常规操作如截断，查找分区等，（4）字符串的存储特性和不可变性，（5）String ,StringBuilder,Stringbuffer之间的比较。

（一）String简介

在JAVA中，我们用String来表示字符串，如"abd"，"132asdjkdv"，等内容， Java程序中的所有字符串文字（例如`"abc"` ）都被实现为此类的实例。

String是一个fianl类，代表不可变的字符序列。字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享。 例如：

>     String str = "abc";

相当于：

>     char data[] = {'a', 'b', 'c'};
>          String str = new String(data);

字符串的特点：

1.  字符串的内容在创建后永不可变。（重点）
2.  因为字符串在创建后是不可变的，所以字符串是可以共享的。
3.  字符串的处理结果相当于char\[ \]字符数组，但底层原理是byte\[ \]字节数组。
4.  通过new创建的字符串对象,每一次new都会申请一块内存空间,虽然内容是相同的,但是地址值是不同的，
5.  以""方式给出的字符串,只要字符序列相同(顺序和大小写完全相同),无论在程序代码中出现几次,JVM都只会创建一个String对象放置于堆内存的字符串常量池中

String应用中的注意点

>  *  String s1 = "a"; 说明：在字符串常量池中创建了一个字面量为"a"的字符串。
>  *   s1 = s1 + "b"; 说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符 串s1+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本 字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响 程序的性能。
>  *   String s2 = "ab"; 说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。
>  *   String s3 = "a" + "b"; 说明：s3指向字符串常量池中已经创建的"ab"的字符串。 String s4 = s1.intern(); 说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串 赋值给s4。

（二）String常用方法

Java中String类常用的方法如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2][]

程序实例：

package strings;
    
    /**
     * Created with IntelliJ IDEA.
     * User:  yongping Li
     * Date: 2020/11/14
     * Time: 10:47
     * Description: No Description
     */
    /*
     String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。
    
     常用的方法如下：
    
     1、获取：
     	1.1 字符串中包含的字符数，也就是字符串的长度。
     		int length():获取长度。
     	1.2 根据位置获取该位置上的某个字符。
     		char charAt(int index):返回指定索引处的char值。
     	1.3 根据字符获取该字符在字符串的位置。
     		int indexOf(String str):返回的是str在字符串中第一次出现的位置。
     		int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
     		int lastIndexOf(int ch):反向索引一个字符出现的位置
    
     2、判断：
     	2.1  字符串中是否包含某一个子串。
     		boolean contains(str);
     		特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。
     				  所以，也可以用于对指定判断是否包含。
     				 if(str.indexOf("aa")!=-1)
     				  而且该方法既可以判断，又可以获取出现的位置
     	2.2 字符中是否有内容。
     		boolean isEmpty():原理就是判断长度是否为0.
     	2.3 字符串是否是以指定内容开头。
     		boolean startsWith(str);
     	2.4 字符串是否是以指定内容结尾。
     		boolean endsWith(str);
     	2.5判断字符串内容是否相同。复写Object类中的equals方法。
     		boolean equals(str);
     	2.6 判断内容是否相同，并忽略大小写
     		boolean equalsIgnoreCase();
    
     3、转换
     	3.1 将字符数组转换成字符串。
     		构造函数： String(char[])
     				  String(char[],offset,count):将字符数组中的一部分转换成字符串。
     		静态方法：
     				 static String copyValueOf(char[]);
     				 static String copyvalueOf(char[] data, int offset, int count);
     	3.2 将字符串转换成字符数组（重点）。
     				char[] toCharArray();
     	3.3 将字节数组转换成字符串。
     				 String(byte[])
     				 String(byte[],offset,count):将字节数组中的一部分转换成字符串。
     	3.4 将字符串转换成字节数组
     	3.5 将基本数据类型转换成字符串。
     		String valueOf(int);
     		String valueOf(double);
    
     		特殊：字符串和字节数组在转换过程中是可以指定编码表的。
    
     4、替换
     		String replace(oldchar,newchar);
     5、切割
     		String[] split(regex);
     6、子串            获取字符串中的一部分
     		String substring(begin);
     		String substring(begin,end);
     7、转换，去除空格，比较
     	7.1 将字符串转成大写或者小写。
     		String toUpperCase();
     		String toLowerCase();
     	7.2 将字符串两端的多个空格去除。
     		String trim();
     	7.3 将两个字符串进行自然顺序的比较。
     */
    
    public class StringDemo {
        //转换，去除空格，比较
        public static void method_7(){
            String s="Hello Java";
            sop("原字符串为："+s);
            //转换大小写
            sop(s.toUpperCase());
            sop(s.toLowerCase());
            //去除空格
            sop(s.trim());
    
            //字符串比较
            String s1="acc";
            String s2="aaa";
            sop(s1.compareTo(s2));
        }
        //子串         获取字符串中的一部分
        public static void method_sub(){
            String s="abcdefghijklmnopqrstuvwxyz";
            sop("原字符串为");
            sop(s);
            String s1=s.substring(9); //从指定位置到结尾。如果角标不存在，则会出现字符串角标越界异常。
            sop("获取的子串s1为：");
            sop(s1);
            String s2=s.substring(7,20); //包含头，不包含尾。 获取整个字符串：s.substring(0,s.length());
            sop("获取的子串s2为：");
            sop(s2);
        }
        //切割
        public static void method_split(){
            String s="zhangsan,lisi,wangwu";
            String[] arr=s.split("a");
            sop("原字符串为：");
            sop(s);
            sop("切割后的字符串为：");
            for(int x=0;x<arr.length;x++)
            {
                System.out.print(arr[x]+" ");
            }
            System.out.println();
        }
        //判断
        public static void method_is(){
            String str="ArrayDemo.java";
            String str1="arraydemo.java";
            //判断文件名称是否以Array开头
            sop(str.startsWith("Array"));
            //判断文件名称是否是以.java结尾
            sop(str.endsWith(".java"));
            //判断文件名称中是否包含Demo
            sop(str.contains("Demo"));
            //判断两个文件名是否相同（区分大小写）
            sop(str.equals(str1));
            //判断两个文件名是否相同（不区分大小写）
            sop(str.equalsIgnoreCase(str1));
        }
        //获取
        public static void method_get(){
            String str="abcdeakpf";
            sop("字符串为："+str);
            //长度
            sop("字符串的长度为："+str.length());
            //根据索引获取字符
            sop("角标为四的位置上的字符为："+str.charAt(4));//当访问到字符串中不存在的角标时，会发生 StringIndexOutOfBoundsException异常
            //根据字符获取索引
            sop("从角标为3的位置开始往后索引 a 出现的位置为："+str.indexOf('a',3));//如果没有找到返回-1
            //反向索引一个字符出现的位置
            sop("从字符串右面开始索引第一个a出现的位置为："+str.lastIndexOf("a"));
        }
        //转换
        public static void method_trans(){
            char[] arr={'a','b','c','d','e','f','g','h'};
            String str="jkasdhavsgjv";
            char[] a=str.toCharArray();
            //字符串操作
            System.out.print("将字符串转换为字符数组为：[");
            for(int x=0;x<a.length;x++)
            {
                if(x<a.length-1)
                    System.out.print(a[x]+",");
                else
                    System.out.print("]");
            }
            System.out.println();
            //字符数组操作
            System.out.print("字符数组为：[");
            for(int x=0;x<arr.length;x++)
            {
                if(x<arr.length-1)
                    System.out.print(arr[x]+",");
                else
                    System.out.print("]");
            }
            System.out.println();
            String s=new String(arr);
            sop("转换成字符串为："+s);
            //获取从角标为1的位置的字符开始三个字符
            String s1=new String(arr,1,3);
            sop("从角标为1的位置的字符开始三个字符组成的字符串为："+s1);
        }
        //替换
        public static void method_replace(){
    
            String s="      hello java     ";
    
            String s1=s.replace('a', 'n'); //如果要替换的字符不存在，则返回的还是原字符串
    
            sop("原来的字符串为："+s);
    
            sop("替换字符后的字符串为："+s1);
    
        }
        //主函数
        public static void main(String[] args) {
            method_get();
            method_is();
            method_trans();
            method_replace();
            method_split();
            method_sub();
            method_7();
        }
        //输出结果
        public static void sop(Object obj){
            System.out.println(obj);
        }
    }

运行结果：

字符串为：abcdeakpf
    字符串的长度为：9
    角标为四的位置上的字符为：e
    从角标为3的位置开始往后索引 a 出现的位置为：5
    从字符串右面开始索引第一个a出现的位置为：5
    true
    true
    true
    false
    true
    将字符串转换为字符数组为：[j,k,a,s,d,h,a,v,s,g,j,]
    字符数组为：[a,b,c,d,e,f,g,]
    转换成字符串为：abcdefgh
    从角标为1的位置的字符开始三个字符组成的字符串为：bcd
    原来的字符串为：      hello java     
    替换字符后的字符串为：      hello jnvn     
    原字符串为：
    zhangsan,lisi,wangwu
    切割后的字符串为：
    zh ngs n,lisi,w ngwu 
    原字符串为
    abcdefghijklmnopqrstuvwxyz
    获取的子串s1为：
    jklmnopqrstuvwxyz
    获取的子串s2为：
    hijklmnopqrst
    原字符串为：Hello Java
    HELLO JAVA
    hello java
    Hello Java
    2
    
    Process finished with exit code 0

（三）字符串的常规操作

字符串的常规操作有查找，截取，和分割等，这些在String类中相应的方法，可以直接调用，亦或是几个方法的综合调用。

package strings;
    
    /**
     * Created with IntelliJ IDEA.
     * User:  yongping Li
     * Date: 2020/11/14
     * Time: 10:53
     * Description: No Description
     */
    public class  newStringDemo {
    
        public static void main(String[] args) {
            /*
             * 查找子串
             */
            String str1="dwqae12232aebdalf";
            //查找指定字符第一次出现的位置
            int first1=str1.indexOf(97);//参数为字符的ascii码
            //查找指定字符串第一次出现的位置
            int first2=str1.indexOf("12");
            //查找指定字符第一次出现的位置，从索引处开始（包括索引处）
            int first3=str1.indexOf(97, 0);
            //查找指定字符串第一次出现的位置，从索引处开始（包括索引处
            int first4=str1.indexOf("12232",0);
            System.out.println("first1="+first1);
            System.out.println("first1="+first2);
            System.out.println("first1="+first3);
            System.out.println("first1="+first4);
            System.out.println("-------------");
            /*
             * 截取字符串
             */
            //从索引处到末尾（不包括索引处）
            String substr1=str1.substring(5);
            //指定区间（包括结束索引处）
            String substr2=str1.substring(5, 10);
            System.out.println("substr1="+substr1);
            System.out.println("substr2="+substr2);
            System.out.println("-------------");
            /*
             * 分割字符串
             */
            //以a为分割字符
            String[] splitstr=str1.split("a");
            for(String res : splitstr){
                System.out.println(res);
            }
            //注：如果分割字符为正则表达式里的字符，则需要"\"做转义
        }
    
    }

运行结果如下·：

first1=3
    first1=5
    first1=3
    first1=5
    -------------
    substr1=12232aebdalf
    substr2=12232
    -------------
    dwq
    e12232
    ebd
    lf
    
    Process finished with exit code 0

（四）字符串的存储特性和不可变性

在Java的内存分配中，总共3种常量池，分别是**Class常量池**、**运行时常量池**、字符串常量池，  JVM的内存结构为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3][]

String定义时的内存分析：

String类的定义

> String s1="abc";
> 
> String s2="abc";
> 
> s1="hello";

String 内存分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4][]

String 的两种定义方式比较

String S="abc";
    String s=new String("abc");

内存分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5][]

String 与char数组的比较：

//String的两种定义方式
    String a="abc";
    String s=new String("abc");
    
    
    char[] arr={'a','b'};
    
    char [] ass={'a','b','c','d','e'};
    
    String s=new String(arr,13,43);

内存分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 6][]

综上，即String s="adb"，abd存储于常量池中，String s=new String("abd"),s指向堆之中的value，value指向常量池中的abd；

String的不可变性指的是：String中每一个看上去修改String的值的方法，实际上都是创建了一个全新的String对象，以包含修改之后的String对象，而最初的String对象没有发生变化。

程序示例：

package strings;//: strings/Immutable.java
    
    
    public class Immutable {
      public static String upcase(String s) {
        return s.toUpperCase();
      }
      public static void main(String[] args) {
        String q = "howdy";
        System.out.println(q); // howdy
        String qq = upcase(q);
        System.out.println(qq); // HOWDY
        System.out.println(q); // howdy
      }
    } /* Output:
    howdy
    HOWDY
    howdy
    *///:~

运行结果为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 7][]

代码示例：

package strings;
    
    /**
     * Created with IntelliJ IDEA.
     * User:  yongping Li
     * Date: 2020/11/14
     * Time: 15:10
     * Description: No Description
     */
    public class StringTest {
        public static void main(String[] args) {
            String str1 = "abc";
            String str2 = "bcd";
    
            System.out.println(str1);
            System.out.println(str2);
    
            str1 = str2;
            System.out.println(str1);
            System.out.println(str2);
            System.out.println(str1 == str2);
    
            //.......
            str1 = new String("bcd");
            System.out.println(str1);
            System.out.println(str1 == str2);
        }
    
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 8][]

运行流程分析：

开始运行程序：

> String str1 = "abc";  
> String str2 = "bcd";

（从内存层面来看）在使用字面值来创建String时，编译器会在静态方法区（字符串常量池）里寻找是否已经存在字面值（这里是abc 和bcd）如果没有就会在静态方法区（字符串常量池）里创建，并为我们的str1 str2 赋值（将abc的地址赋给str1，同理str2） ；

![å¨è¿éæå¥å¾çæè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center]

而后

> str1 = str2;

![å¨è¿éæå¥å¾çæè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 1]

其后创建对象时

> str1 = new String("bcd");

![å¨è¿éæå¥å¾çæè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 2]

当二者比较时：

> str2 = new String("bcd");  
> System.out.println(str1 == str2);

![å¨è¿éæå¥å¾çæè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 3]

（五）String StringBuilder,StringBuffer之间的比较

StringBuilder 和StringBuffer是对于String的改进，我们知道，String具有不可变性和长度确定性，即为不可变的字符序列，那么，如何定义可变的字符序列，java.lang.StringBuffer代表可变的字符序列，可以对字符 串内容进行增删，此时不会产生新的对象。 很多方法与String相同， 作为参数传递时，方法内部可以改变值。

StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

> StringBuffer()：初始容量为16的字符串缓冲区
> 
> StringBuffer(int size)：构造指定容量的字符串缓冲区
> 
> StringBuffer(String str)：将内容初始化为指定字符串内容

常用方法

> StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
> 
> StringBuffer delete(int start,int end)：删除指定位置的内容
> 
> StringBuffer replace(int start, int end, String str)：把\[start,end)位置替换为str
> 
> StringBuffer insert(int offset, xxx)：在指定位置插入xxx StringBuffer reverse() ：把当前字符序列逆转
> 
>

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且 提供相关功能的方法也一样 

面试题：对比String、StringBuffer、StringBuilder

> String(JDK1.0)：不可变字符序列
> 
> StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全
> 
> StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全 注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder 会改变其值。

继承结构：

![è¿éåå¾çæè¿°][70]

三者比较

> 1）String是不可变字符序列，StringBuilder和StringBuffer是可变字符序列。  
> 2）执行速度StringBuilder > StringBuffer > String。  
> 3）StringBuilder是非线程安全的，StringBuffer是线程安全的

（六）String与基本数据类型之间的转换

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 11][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20221120/01133542f17b47b9a2ef5ee59fe53e68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]: /images/20221120/5efdcf78cca9419e9b9915b57c2a40bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]: /images/20221120/008d20dba1064ef58a624f25cb6fc24d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]: /images/20221120/42ff245d2632423b978f56335eea11ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4]: /images/20221120/d4b0055b32ad4e4fb1dad8d63c1fe576.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5]: /images/20221120/e88d821fe0504d71adf8d7534b36713b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 6]: /images/20221120/df5b9f3dc92749cdb259e0e495fc4d50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 7]: /images/20221120/ffa6616576b8465c86bf69532a1cf67a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 8]: /images/20221120/3dcc479643ea46ebabaf7fd12b22f065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/a9adbbfc6ffb4f45b1eb6fe84481dcf4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/f9e256d1d3c44a5d81fe72b443029b80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/5d218218a3d64df18b755b542aab0244.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMjE1NjEy_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/f7fc7b76904b4476966929d13bf2f1a9.png
[70]: /images/20221120/f9e5b7d9bc8a4009b8be76e839c47725.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 9]: /images/20221120/1d40f8901ebe442e8934f4233c9da12f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 10]: /images/20221120/813c15ecd09b45dba1212b917e3d673c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 11]: /images/20221120/8d7c3dbd4dbc47fdbebd3fb8bca75c1b.png