快速学习Java8新特性第二讲——Lambda表达式

淩亂°似流年 2023-06-19 09:57 1阅读 0赞

# Lambda表达式是什么？ #

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。这样就可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

# 为什么使用Lambda表达式？ #

先回顾一下之前我们学过的匿名内部类，就以下面定义的一个比较器来说，该比较器是用于比较两个Integer的大小。

//定义一个比较器，用于比较两个Integer的大小
    Comparator<Integer> com = new Comparator<Integer>() { 
        @Override
        public int compare(Integer o1, Integer o2) { 
            return Integer.compare(o1, o2);
        }
    };
    
    //使用以上定义好的比较器，将比较器作为参数进行传递
    TreeSet<Integer> ts = new TreeSet<Integer>(com);

上面编写的这样一个匿名内部类属实难看，而且写了那么大一坨的东西，所以我们就要想着怎么让代码写得少一点，使用Lambda表达式就可简化上面编写的匿名内部类，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
再来看一个例子，假设有这样一个需求：假设某公司现在有好多雇员，每一个雇员都有其姓名、年龄以及工资等基本信息，现在想要获取当前公司中员工年龄不小于35的员工信息。为了解决这个需求，首先要创建一个雇员实体类，即Employee.java。

package com.meimeixia.java8;
    
    public class Employee { 
    
    	private int id;
    	private String name;
    	private int age;
    	private double salary;
    
    	public Employee() { 
    
    	}
    
    	public Employee(int id, String name, int age, double salary) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    	
    	public int getId() { 
    		return id;
    	}
    
    	public void setId(int id) { 
    		this.id = id;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public int getAge() { 
    		return age;
    	}
    
    	public void setAge(int age) { 
    		this.age = age;
    	}
    
    	public double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(double salary) { 
    		this.salary = salary;
    	}
    
    	@Override
    	public String toString() { 
    		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    	}
    
    }

然后，再编写一个方法用于获取当前公司中员工年龄不小于35的员工信息，接着做个测试，看是否真能获取到当前公司中员工年龄不小于35的员工信息。

package com.meimeixia.java8;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    
    public class LambdaDemo { 
    	
    	List<Employee> employees = Arrays.asList(
    			new Employee(100, "张三", 18, 9999.99),
    			new Employee(101, "李四", 38, 5555.99),
    			new Employee(102, "王五", 50, 6666.66),
    			new Employee(103, "赵六", 16, 3333.33),
    			new Employee(104, "田七", 8, 7777.77)
    	);
    	
    	//测试是否能获取当前公司中员工年龄不小于35的员工信息？
    	@Test
    	public void test() { 
    		List<Employee> list = filterEmployees(employees);
    		for (Employee employee : list) { 
    			System.out.println(employee);
    		}
    	}
    	
    	//用于获取当前公司中员工年龄不小于35的员工信息的方法
    	public List<Employee> filterEmployees(List<Employee> list) { 
    		List<Employee> emps = new ArrayList<Employee>();
    		for (Employee emp : list) { 
    			if (emp.getAge() >= 35) { 
    				emps.add(emp);
    			}
    		}
    		return emps;
    	}
    
    }

这个时候，万一需求变了呢？还要获取当前公司中员工工资大于5000的员工信息。于是，我们还要在LambdaDemo类中编写一个用于获取当前公司中员工工资大于5000的员工信息的方法。

public List<Employee> filterEmployees2(List<Employee> list) { 
        List<Employee> emps = new ArrayList<Employee>();
        for (Employee emp : list) { 
            if (emp.getSalary() >= 5000) { 
                emps.add(emp);
            }
        }
        return emps;
    }

不知你有没有发现上面根据需求变化编写的两个方法有大量的冗余代码，除了判断语句之外，其他的几乎都相同。一旦遇到这种代码，我们就要想办法来解决了，即需要进行优化处理。原来我们对这样的代码最好的优化方式无非就是使用设计模式了，但要用哪一种设计模式呢？这里可以使用策略设计模式，那什么叫策略设计模式呢？就是你给它什么策略，它就按什么策略进行过滤。  
怎样使用策略设计模式来重构代码呢？既然我们发现只有判断条件不一致，那么我们便可以定义一个接口来进行条件判断。

package com.meimeixia.java8;
    
    public interface MyPredicate<T> { 
    	
    	public boolean test(T t);
    	
    }

如果我们要定义新的判断规则，那么只需要定义一个类实现MyPredicate接口即可。例如，我们要进行员工年龄不小于35的判断。

package com.meimeixia.java8;
    
    public class FilterEmployeeByAge implements MyPredicate<Employee> { 
    
    	@Override
    	public boolean test(Employee t) { 
    		return t.getAge() >= 35;
    	}
    
    }

或者，进行员工工资不小于5000的判断。

package com.meimeixia.java8;
    
    public class FilterEmployeeBySalary implements MyPredicate<Employee> { 
    
    	@Override
    	public boolean test(Employee t) { 
    		return t.getSalary() >= 5000;
    	}
    
    }

现在，我们就只需要编写如下一个filterEmployee方法，不用再费心费力为每一种条件变化编写一个相应的方法了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]  
虽说使用了策略设计模式来重构了代码，但是依然是还有一点不好的地方，即为每个判断规则都定义一个实现类的话有点多余。于是，我们可以直接使用匿名内部类实现接口的方式来继续优化代码。例如，获取当前公司中员工工资不大于5000的员工信息。

//优化方式二，直接使用匿名内部类来实现接口。例如，获取当前公司中员工工资不大于5000的员工信息
    @Test
    public void test3() { 
        List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() { 
            @Override
            public boolean test(Employee t) { 
                return t.getSalary() <= 5000;
            }
        });
        
        for (Employee employee : list) { 
            System.out.println(employee);
        }
    }

从以上匿名内部类的内容中，发现匿名内部类里面有用的代码就是`return t.getSalary() <= 5000;`这一句，但是我为了这一句多写了5~6行代码，可读性一下子就降低了，结构也乱了，代码根本就不简洁了。你不仅就要问了，那可以继续优化代码吗？当然了，匿名内部类可以使用Lambda表达式来代替，以此简化代码。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
其实，我们还可以使用Stream API来继续优化代码。如果使用了Stream API，那么除了在LambdaDemo类中定义好的employees集合，还有Employee实体类之外，剩下的什么都可以没有。

//还有，有了优化方式四（即使用Stream API），使用了Stream API，除了上面定义好的employees集合，还有Employee实体类之外，剩下的什么都可以没有。
    @Test
    public void test5() { 
        //获取当前公司中员工工资不小于5000的员工信息
        employees.stream()
                 .filter((e) -> e.getSalary() >= 5000)
                 .forEach(System.out::println);
    }

运行以上测试方法，你便可以在Eclipse控制台看到当前公司中员工工资不小于5000的员工信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
在查询出当前公司中员工工资不小于5000的员工信息的基础上，只想取出排名最前的两个员工信息，那该怎么办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
再次运行以上测试方法，你便可以在Eclipse控制台看到如下打印信息。  
![在这里插入图片描述][20191205211432245.png]  
如果我们想把公司中所有员工的名字给提取出来，那么可以像下面这样做。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
此时，运行以上测试方法，你便可以在Eclipse控制台看到如下打印信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]

## 小结 ##

在某种特殊的情况下，我们可能要建立一个类来实现某一个接口，覆写其中的一个方法，来完成一些自定义的功能，而往往这种操作只需要使用一次或者很少使用，在这种情况下可以使用匿名内部类来解决一次性使用的情况。然而匿名内部类中真正有用到的只有其中一小部分代码，但是由于Java旧版本的语法要求，需要编写多余的代码格式。所以，这时我们就可以使用Lambda表达式来代替匿名内部类，使得代码更简洁。这就是我们为什么使用Lambda表达式的原因。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]

# Lambda表达式的基础语法 #

在Java8中引入了一个新的操作符，即"->"，该操作符被称为箭头操作符或者Lambda操作符，箭头操作符将整个Lambda表达式拆分成了个两部分：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]  
Lambda表达式一共有好几种变化的形式，我总结出来有如下六种形式，下面我会一一介绍它们。

## 语法格式一：无参数，且无返回值 ##

第一种语法格式说的就是接口中的那个抽象方法无参，并且无返回值。你能找到这样一个接口吗？即接口中的那一个抽象方法无参，并且无返回值。难道你还没找到这样类似的接口吗？例如Runnable接口，Runnable接口的定义如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]  
这里，我就以Runnable接口为例来讲述这种语法格式。原来我们是使用匿名内部类的方式来实现该接口的，就像下面这样。

Runnable r = new Runnable() { 
    	@Override
    	public void run() { 
    		System.out.println("Hello World!" + num);
    	}
    };
    r.run();

现在，匿名内部类可以使用Lambda表达式来充当了，即使用Lambda表达式实现Runnable接口。

Runnable r1 = () -> System.out.println("Hello Lambda!" + num);
    r1.run();

实际上，Lambda表达式我们也可称之为是语法糖或者糖语法，它底层就是一个函数（方法），只不过，我们写起来比较简单而已。当你在写Lambda表达式时，有一个小的注意事项：如果在局部内部类中应用了一个同级别的局部变量时，那么在Java 7及之前该变量必须是final的，但在Java 8之后，可以不用加了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]  
虽然在Java 8之后，同级别的局部变量前面的final关键字可以不用加了，但是它实际上还是一个final的，所以它就不可以做一些操作了（例如自增或者自减），只不过我们可以省略，默认不写了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]

## 语法格式二：有一个参数，并且无返回值 ##

第二种语法格式说的就是接口中的那个抽象方法有一个参数，并且无返回值。你能找到这样一个接口吗？即接口中的那一个抽象方法有一个参数，并且无返回值。Java 8中就有这样一个接口，即Consumer接口，其定义如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]  
这里，我就以Consumer接口为例来讲述这种语法格式。我们可以使用Lambda表达式对Consumer接口中有一个参数的accept方法进行实现。

@Test
    public void test2() { 
    	Consumer<String> con = (x) -> System.out.println(x);
    	con.accept("我是美美侠！");
    }

## 语法格式三：若只有一个参数，参数的小括号可以省略不写 ##

第三种语法格式说的就是接口中的那个抽象方法如果只有一个参数，那么参数的小括号可以省略不写了，但习惯上还是要写上。还是以上面的Consumer接口为例来讲述这种语法格式。

@Test
    public void test2() { 
    // Consumer<String> con = (x) -> System.out.println(x);
    	Consumer<String> con = x -> System.out.println(x);
    	con.accept("我是美美侠！");
    }

## 语法格式四：有两个以上的参数，有返回值，并且Lambda体中有多条语句 ##

第四种语法格式说的就是接口中的那个抽象方法有两个以上的参数，有返回值，并且Lambda体中有多条语句，那么此时Lambda体必须使用大括号括起来。这里，我就以Comparator接口为例来讲述这种语法格式。

@Test
    public void test3() { 
    	Comparator<Integer> com = (x, y) -> { 
    		System.out.println("函数式接口");
    		return Integer.compare(x, y);
    	};
    }

## 语法格式五：当Lambda体中只有一条语句时，return和大括号都可以省略不写 ##

第五种语法格式说的就是接口中的那个抽象方法有两个以上的参数，有返回值，并且Lambda体中只有一条语句，那么此时return和大括号都可以省略不写。这里，我同样以Comparator接口为例来讲述这种语法格式。

@Test
    public void test4() { 
    	Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    }

## 语法格式六：Lambda表达式中的参数列表的数据类型可以省略不写，因为JVM的编译器可以通过上下文来推断出数据类型 ##

最后这种语法格式说的就是Lambda表达式中的参数列表的数据类型可以省略不写，因为JVM的编译器可以通过上下文来推断出数据类型，这个过程我们称之为"类型推断"，其实，“类型推断"也是一个语法糖。  
![在这里插入图片描述][20191206090826129.png]  
上述Lambda表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的，这就是所谓的"类型推断”。  
实际上，我们之前就已经用过类型推断，只不过你没意识到而已。  
![在这里插入图片描述][20191206092848268.png]  
还有在Java 7之后，集合是可以像下面这样写的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]  
在Java 8中，对类型推断是怎么升级的呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]

## 小结 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191205200125114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191205203221633.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191205211405922.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191205211414439.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191205211423452.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191205211432245.png]: https://img-blog.csdnimg.cn/20191205211432245.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191205211439593.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191205211446545.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191205211454677.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191206083651536.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191206083655484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20191206083706125.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20191206083718843.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20191206090813292.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191206090826129.png]: https://img-blog.csdnimg.cn/20191206090826129.png
[20191206092848268.png]: https://img-blog.csdnimg.cn/20191206092848268.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20191206092851435.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2019120609290079.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20191206092910549.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70