Java基础加强第五讲泛型(上)——初识泛型

迈不过友情╰ 2022-03-25 09:19 199阅读 0赞

大家可以看看JDK帮助文档中的Class的定义，其中好多地方涉及到了`<>`的语法形式，这就是我们今天要讲解的泛型。  
泛型是JDK1.5的所有新特性中最难深入掌握的部分，不过，我们在实际应用中不能掌握得那么深入，掌握泛型中一些最基本的内容就差不多了。

# 体验泛型 #

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。  
JDK1.5以前的集合类中存在什么问题呢？JDK1.5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。试看以下代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]  
JDK1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据，试看如下代码：

package cn.liayun.generic;
    
    import java.util.ArrayList;
    
    public class GenericTest { 
    
    	public static void main(String[] args) throws Exception { 
    		ArrayList<String> collection2 = new ArrayList<String>();
    		collection2.add("abc");
    	}
    
    }

那么，这两行代码编译时就报告了语法错误：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]  
而且，以下代码不再需要进行类型转换：  
![在这里插入图片描述][20190119220923751.png]  
在JDK1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。  
引入泛型以后，我之前讲解反射的代码例子，即用反射的方式通过`String(StringBuffer buffer);`构造方法创建String类的实例，就可以改写成如下形式了，这种情况下创建实例对象时不需要类型转换。

package cn.liayun.generic;
    
    import java.lang.reflect.Constructor;
    
    public class GenericTest { 
    
    	public static void main(String[] args) throws Exception { 
    		Class<String> clazzString1 = String.class;
    		Constructor<String> constructor1 = clazzString1.getConstructor(StringBuffer.class);
    		String str2 = constructor1.newInstance(new StringBuffer("abc"));//不用进行类型转换了。
    		System.out.println(str2.charAt(2));//c
    	}
    
    }

我是怎么知道什么情况下可以用泛型的呢？这要看类的定义，只有类被定义成了泛型，才可以对其进行参数化应用。  
泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。通过下面的代码验证getClass()方法返回的结果已经去掉了“类型”信息。

由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

package cn.liayun.generic;
    
    import java.util.ArrayList;
    
    public class GenericTest { 
    
    	public static void main(String[] args) throws Exception { 
    		ArrayList<Integer> collection3 = new ArrayList<Integer>();
    // collection3.add("abc");//泛型是给编译器看的
    		collection3.getClass().getMethod("add", Object.class).invoke(collection3, "abc");
    		System.out.println(collection3.get(0));
    	}
    
    }

# 了解泛型 #

`ArrayList<E>`类定义和`ArrayList<Integer>`类引用中涉及如下术语：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]

## 参数化类型与原始类型的兼容性 ##

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]  
可不可以，不就是编译器一句话的事吗？  
原始类型可以引用一个参数化类型的对象，编译报告警告，例如，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]  
原来的方法接受一个集合参数，新的类型也要能传进去。要是不明白，我可以举例说明。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]  
上面的例子说明了以下代码成立：  
![在这里插入图片描述][20190119231255846.png]  
再看下面的例子，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]  
说明了以下代码成立：  
![在这里插入图片描述][2019011923131819.png]  
小结：使用泛型时，如果两边都使用到了泛型，两边必须要一样；只用一边也是可以的。  
这里，大家一定要注意一点，参数化类型是不考虑类型参数的继承关系的。泛型中的类型参数严格说明集合中装载的数据类型是什么和可以加入什么类型的数据，记住：`Collection<String>`和`Collection<Object>`是两个没有转换关系的参数化的类型。那么，以下代码是错误的！不写`<Object>`没错，写了就是明知故犯。  
![在这里插入图片描述][20190119231328123.png]  
我们假设以上代码可以编译通过，那么以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象。以下代码同样也是错误的：  
![在这里插入图片描述][20190119231336945.png]  
我们假设以上代码可以编译通过，那么以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象。  
现在，大家可以思考下，下面的代码会报错误吗？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]  
显然不会。因为原始类型可以引用一个参数化类型的对象，所以第一句没有错误；参数化类型可以引用一个原始类型的对象，所以第二句也没有错误。但不能将两句结合起来看，如`Vector<Object> v = new Vector<String>();`，那么就是错误的。  
最后，我再介绍一个知识点，**编译器不允许创建泛型变量的数组，即在创建数组实例时，数组的元素不能使用参数化的类型**。例如，下面语句有错误：  
![在这里插入图片描述][20190119231356131.png]

# 泛型中的?通配符 #

有这样一个需求，定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据。该方法如何定义呢？我先定义一个错误的方法，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]  
`Collection<Object>`中的Object只是说明`Collection<Object>`实例对象中的方法接受的参数是Object；`Collection<Object>`是一种具体类型，`HashSet<Date>`也是一种具体类型，两者没有兼容性问题。  
然后，我再给出正确的方法定义，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]  
`Collection<?> a`可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以，`a = new ArrayList<Integer>`和`a = new ArrayList<String>`都可以， 但`a.add(new Date())`或`a.add("abc")`都不行。  
最后，我给出一个结论，使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

## 泛型中的?通配符的扩展 ##

通配符的限定分为上限和下限，下面就给大家简单介绍一下。

*  限定通配符的上边界
    
     *  以下代码是正确的：  
        ![在这里插入图片描述][20190120000700619.png]
     *  以下代码是错误的：  
        ![在这里插入图片描述][20190120000711937.png]
 *  限定通配符的下边界
    
     *  以下代码是正确的：  
        ![在这里插入图片描述][20190120000725509.png]
     *  以下代码是错误的：  
        ![在这里插入图片描述][20190120000734688.png]

关于通配符的限定，大家需要注意以下几点。

1.  限定通配符总是包括自己；
2.  ?只能用作引用，不能用它去给其他变量赋值。例如，  
    ![在这里插入图片描述][20190120000746886.png]  
    编译报错，因为方法forName具体的定义为：
    
        public static Class<?> forName(String className) throws ClassNotFoundException {  }
    
    可知此方法的返回结果是`Class<?>`，所以不能用它去给其他变量赋值。上面代码相当于，  
    ![在这里插入图片描述][20190120000801311.png]  
    再看一个例子，  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]  
    上面的代码错误，原理与`Vector<Object> x11 = new Vector<String>();`相似，只能通过强制类型转换方式来赋值。

# 泛型集合类的综合案例 #

这里，我会举一个例子，即如何变量Map集合。要是你能写出下面的代码即代表掌握了Java的泛型集合类。

package cn.liayun.generic;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class GenericTest { 
    
    	public static void main(String[] args) throws Exception { 
    		HashMap<String, Integer> maps = new HashMap<String, Integer>();
    		maps.put("zxx", 28);
    		maps.put("lhm", 35);
    		maps.put("flx", 33);
    		
    		Set<Map.Entry<String, Integer>> entrySet = maps.entrySet();
    		for (Map.Entry<String, Integer> entry : entrySet) { 
    			System.out.println(entry.getKey() + ":" + entry.getValue());
    		}
    	}
    	
    }

对了，在jsp页面中也经常要对Set或Map集合进行迭代，迭代代码如下：

<c:forEach items=“${map}” var=“entry”>
    	${entry.key}:${entry.value}
    </c:forEach>

# 定义泛型方法 #

Java中的泛型类型（或者泛型）类似于C++中的模板，但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为Java厂商升级其JVM造成难以逾越的障碍。所以，Java的泛型采用了可以完全在编译器中实现的擦除方法。  
例如，下面这两个方法，编译器会报告错误，它不认为是两个不同的参数类型，而认为是同一种参数类型。

public static void applyVector(Vector<Date> v1) { 
    
    }
    /* 不是重载，因为去类型化了 public static void applyVector(Vector<Integer> v1) { } */

Java的泛型方法没有C++模板函数功能强大，Java中的如下代码无法通过编译：  
![在这里插入图片描述][20190120013205665.png]  
注意：Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法为`<T>`。用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。  
试着，做一个练习，交换数组中的两个元素的位置，用泛型方法语法定义。

package cn.liayun.generic;
    
    import java.util.Arrays;
    
    public class GenericTest { 
    
    	public static void main(String[] args) throws Exception { 
    		String[] strs = new String[]{ "a","b","c"};
    		swap(strs, 1, 2);
    		System.out.println(Arrays.asList(strs));
    	}
    	
    	/* * 交换数组中的两个元素的位置的泛型方法 */
    	private static <T> void swap(T[] a, int i, int j) { 
    		T temp = a[i];
    		a[i] = a[j];
    		a[j] = temp;
    	}
    	
    }

注意：只有引用类型才能作为泛型方法的实际参数，`swap(new int[]{1,3,5,4,5},3,4);`语句会报告编译错误。这是因为编译器不会对`new int[]{1,3,5,4,5}`中的int自动拆箱和装箱了，因为`new int[]{1,3,5,4,5}`本身已经是对象了，你想要的有可能就是int数组呢？它装箱岂不弄巧成拙了。  
除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义，  
![在这里插入图片描述][20190120013216464.png]  
并且可以用&来指定多个边界，如`<V extends Serializable & cloneable> void method(){}`。  
在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分隔，例如：

public static <K,V> V getValue(K key) {  return map.get(key);}

最后，我再介绍一个知识点，因为比较少见，大家只要了解一下就行了。可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。我用下面的代码说明对异常如何采用泛型：  
![在这里插入图片描述][2019012001322628.png]

## 泛型方法的练习题 ##

下面有6道有关泛型方法的练习题，希望大家能认真做一下，巩固泛型方法的认识。我也会把每道题的答案给到大家。

### 练习一 ###

编写一个泛型方法，自动将Object类型的对象转换成其他类型。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 11]  
泛型方法的另外一个常见应用就是调用者无需对返回值进行类型转换。

### 练习二 ###

定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。  
![在这里插入图片描述][20190120013247661.png]

### 练习三 ###

采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容。

> 分析：在这种情况下，前面的通配符方案要比泛型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用泛型方法。

*  使用通配符：
    
        public static void printCollection(Collection<?> collection) { 
            System.out.println(collection.size());
            for(Object obj : collection) { 
                System.out.println(obj);
            }
        }
 *  使用泛型方法：
    
        public static <T> void printCollection2(Collection<T> collection/*, T obj2*/) { 
        	System.out.println(collection.size());
        	for (Object obj : collection) { 
        		System.out.println(obj);
        	}
        	
        // collection.add(obj2);
        }

### 练习四 ###

定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。

> 分析：如果使用如下形式：`static void copy(Collection a, Object[] b);`有可能出现A类型的数据复制进B类型的数组中的情况。所以需要使用泛型方法进行定义。

![在这里插入图片描述][20190120162242535.png]

### 练习五 ###

定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。  
![在这里插入图片描述][20190120162251912.png]  
此时，copy1方法与copy2方法有什么区别呢？要知道两者之间的区别，就必须了解类型参数的类型推断，马上我就会介绍。

### 练习六 ###

编写一个泛形方法，接收一个任意数组，并颠倒数组中的所有元素。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 12]

# 类型参数的类型推断 #

编译器判断泛型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断(？，应为直觉推断吧！)的，其实现方法是一种非常复杂的过程。根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

*  当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：  
    ![在这里插入图片描述][20190120162350542.png]
 *  当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型，这很容易凭着感觉推断出来，例如：  
    ![在这里插入图片描述][20190120162359514.png]
 *  当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型。例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 13]
 *  当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候优先考虑返回值的类型。例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比Eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 14]
 *  参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为Date类型，编译将出现问题。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 15]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]: /images/20220325/54fd8139a3584cf8a691b41c9c68604e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]: /images/20220325/ed002c6b56184e82bb90e0e146deafd2.png
[20190119220923751.png]: /images/20220325/44df2caa80674f218fe58b9a6cadaa0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]: /images/20220325/93f450a039d84af8b42adf6869c875b2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]: /images/20220325/35c85bf8c53f4b5b9f40e1e84a8ed401.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]: /images/20220325/a7de7240a8ef4f938251310804b80efa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]: /images/20220325/eefa043bada94eca8dbf58f9538d3326.png
[20190119231255846.png]: /images/20220325/5ea909eff806446b8a3ce8fd8c3dd8b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]: /images/20220325/29d57e9c49454c46b84bfab2c68a3350.png
[2019011923131819.png]: /images/20220325/a3a4e71ec77c4da9ab58c7808408cb47.png
[20190119231328123.png]: /images/20220325/45f7d86eafd64ff4865a10a6d8eff73d.png
[20190119231336945.png]: /images/20220325/f1d28b4871264bc8a7cc1c0fc3d9c434.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]: /images/20220325/725daee1db9d49a2bb839c650692b5d8.png
[20190119231356131.png]: /images/20220325/dae944b25ade449087a3bc63fef3847e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]: /images/20220325/8ccee3de1cf94b45af0ef487d793dd0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]: /images/20220325/795daf041e3048f29171b86e21f780d5.png
[20190120000700619.png]: /images/20220325/c604f74a999f44bfa6bb1f0c828074f1.png
[20190120000711937.png]: /images/20220325/8f31216fb26940e69918cc9d95e13d5a.png
[20190120000725509.png]: /images/20220325/1222c9548ba3448ca19cf0b885fb6232.png
[20190120000734688.png]: /images/20220325/0aa4879bf8d745ed88508b67d18448da.png
[20190120000746886.png]: /images/20220325/0eb96e58af3a41f0bb7d06212ab9813b.png
[20190120000801311.png]: /images/20220325/0e23d0ad232b4fbf8cb40a46d56d42cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]: /images/20220325/df5a2382e4b04bdeb62b3b631101ef11.png
[20190120013205665.png]: /images/20220325/1cb97c07ee7a45c287557311c4b091e5.png
[20190120013216464.png]: /images/20220325/836137ee252b4c1ea0df5e96d2946ecb.png
[2019012001322628.png]: /images/20220325/76193d243e4b438baf0ad79c746331a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 11]: /images/20220325/bf3b183407d749f4b376e677532556c4.png
[20190120013247661.png]: /images/20220325/7c9bd62237a84662872b6d511ce47673.png
[20190120162242535.png]: /images/20220325/97d29c0be9974bc8bb9c9cabd8d640d7.png
[20190120162251912.png]: /images/20220325/7f1fa0c25eea4f6d8dc2b32f63bf0e80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 12]: /images/20220325/3d4c2879a01e41239f7d18631b71f777.png
[20190120162350542.png]: /images/20220325/f5508de9459a486c93aa429689514439.png
[20190120162359514.png]: /images/20220325/ce1c6bec88ba43eeb0212bb7efbfe2ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 13]: /images/20220325/5903fd1ce770497093993389c294b020.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 14]: /images/20220325/65fe4e1fef6944399c399e39f3fef947.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 15]: /images/20220325/f349352760ca405390d28f8eb92f360e.png