快速学习Java8新特性第五讲——强大的Stream API

分手后的思念是犯贱 2023-06-21 03:50 13阅读 0赞

# Stream是什么？ #

Java 8中有两大最为重要的改变。第一个是Lambda表达式；另外一个则是Stream API（位于包java.util.stream.\*下）。Stream是Java 8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。  
那Stream（流）到底是什么呢？Stream（流）是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。**“集合讲的是数据，流讲的是计算！”** 我们尤其注意以下几点：

1.  Stream自己不会存储元素；
2.  Stream不会改变源对象，相反，它们会返回一个持有结果的新Stream；
3.  Stream操作是延迟执行的，这意味着它们会等到需要结果的时候才执行。

如果要用一个图来形象地描述Stream（流），那么可能是下面这样的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]

# Stream使用的三个步骤 #

Stream的操作一般可以分为以下三个步骤：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]

# 如何创建Stream？ #

创建Stream（流）一共有四种方式，下面我会一一介绍到。

## 通过Collection接口创建 ##

通过Collection系列集合提供的stream()方法或者paralleStream()方法获取流对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
例如，以下代码就是通过这种方式来创建流的。

//创建流一共有以下四种方式：
    //1. 可以通过Collection系列集合提供的stream()方法（获取的是串行流）或者paralleStream()方法（获取的是并行流）获取流对象
    List<String> list = new ArrayList<String>();
    //流也可以带泛型
    Stream<String> stream1 = list.stream();

## 通过数组创建 ##

Java 8中的Arrays类的stream()静态方法可以获取数组流，而且它有许多重载的方法可以返回不同基本数据类型数组的Steam对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
例如，以下代码就是通过这种方式来获取数组流的。

//2. 通过Arrays类中的静态方法stream()获取数组流
    Employee[] emps = new Employee[10];
    Stream<Employee> stream2 = Arrays.stream(emps);

## 通过Stream类中的静态方法of()创建 ##

可以使用Stream类中的静态方法of()，通过显示值来创建一个流，该方法可以接收任意数量的参数。  
![在这里插入图片描述][2019121110263099.png]  
例如，以下代码就是通过这种方式来获取流的。

//3. 通过Stream类中的静态方法of()获取流
    Stream<String> stream3 = Stream.of("aa", "bb", "cc");

## 通过静态方法Stream.iterate()或者Stream.generate()创建无限流 ##

可以使用静态方法Stream.iterate()或者Stream.generate()来创建无限流。创建无限流也有两种方式，一种是通过迭代来创建，即使用Stream类中的静态方法iterate()来创建。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
创建出来的无限流如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
如果我们不想要这么多数，只想要前十个数，那么该咋怎呢？这时可以来个中间操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]  
此时，创建出来的无限流就是下面这样子的了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]  
创建无限流的第二种方式是通过生成来创建，即使用Stream类中的静态方法generate()来创建。  
![在这里插入图片描述][20191211102708491.png]  
创建出来的无限流如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]  
如果我们不想要这么多数，只想要前5个数，那么该咋怎呢？这时也可以来个中间操作。  
![在这里插入图片描述][20191211102724394.png]  
此时，创建出来的无限流就是下面这样子的了。  
![在这里插入图片描述][20191211102732168.png]

# 中间操作 #

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而是在终止操作时一次性全部处理，这称为"惰性求值"。

## 筛选与切片 ##

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

### filter(Predicate p) ###

下面我会举一个例子来演示filter(Predicate p)。例如，过滤公司中年龄大于35的雇员。

package com.meimeixia.java8;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    
    import org.junit.Test;
    
    public class TestStreamAPI { 
    	
    	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)
    	);
    	
    	//演示filter(Predicate p)
    	@Test
    	public void test1() { 
    		Stream<Employee> steam = employees.stream()
                                            .filter((e) -> { 
                                                System.out.println("Stream API的中间操作");
                                                return e.getAge() > 35;
                                            });
    		/* * 我为了让大家看结果，我就得来一个终止操作，不然的话，以上中间操作是没有任何结果的！ * 因为中间操作没有执行，所以是没有任何结果的（中间操作它是不会执行任何操作的）。 * 只有当你执行终止操作以后，所有的中间操作才一次性全部处理（一次性执行全部内容，这个过程我们就称为"惰性求值"，或者称为"延迟加载"） */
    		steam.forEach(System.out::println);
    	}
    	
    }

其中，Employee实体类的内容如下：

运行TestStreamAPI单元测试类中的test1()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]  
从上图可以看出，迭代操作是由人家Stream API帮我们完成的，再也不需要我们自己完成这个迭代操作了，这也叫做内部迭代。与内部迭代相对应的是外部迭代，也就是我们自己写的迭代。

//外部迭代：我们自己写的迭代
    @Test
    public void test2() { 
        Iterator<Employee> it = employees.iterator();
        while (it.hasNext()) { 
                System.out.println(it.next());
        } 
    }

### limit(long maxSize) ###

下面我会举一个例子来演示limit(long maxSize)。例如，过滤公司中年龄大于35的雇员之后，获取其中前3个雇员的信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]  
运行以上test3()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]  
从上图可以看出，迭代操作只执行了两次，也就是说它只要找到满足条件的数据以后，之后的迭代操作就不再继续执行了，这个过程就叫做**短路**！在某种情况下，它可以用于提高效率。实际上，它跟我们之前学的&&和||有点类似。

### skip(long n) ###

下面我会举一个例子来演示skip(long n)。例如，过滤公司中薪水大于5000元的雇员之后，跳过前2个，获取后面的雇员信息。

//演示skip(long n)
    @Test
    public void test4() { 
        employees.stream()
                 .filter((e) -> e.getSalary() > 5000)
                 .skip(2) //跳过前两个，获取后面的雇员信息
                 .forEach(System.out::println);
    }

运行以上test4()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191211115637747.png]

### distinct() ###

下面我会举一个例子来演示distinct()。例如，过滤公司中薪水大于5000元的雇员之后，跳过前2个，获取后面的雇员信息（而且还要去除重复的雇员信息）。为了更好地配合该案例的演示，首先得在TestStreamAPI类的employees集合中添加几个重复的元素。

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),
            
            new Employee(104, "田七", 8, 7777.77),
            new Employee(104, "田七", 8, 7777.77)
    );

然后，在TestStreamAPI类中编写一个如下的测试方法。

//演示distinct()
    @Test
    public void test5() { 
        employees.stream()
                 .filter((e) -> e.getSalary() > 5000)
                 .skip(2) //跳过前两个，获取后面的雇员信息
                 .distinct()
                 .forEach(System.out::println);
    }

接着，运行以上test5()方法，发现并没有去除重复元素，为什么没去掉呢？因为它是通过流所生成元素的hashCode()和equals()来去除重复元素。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]  
所以，要想去除重复元素，必须得重写Employee实体类中的hashCode()和equals()这两个方法。

package com.meimeixia.java8;
    
    public class Employee { 
    
    	private Integer id;
    	private String name;
    	private Integer age;
    	private Double salary;
    	
    	public Employee() { 
    		super();
    	}
    
    	public Employee(Integer id) { 
    		super();
    		this.id = id;
    	}
    
    	public Employee(Integer id, Integer age) { 
    		super();
    		this.id = id;
    		this.age = age;
    	}
    
    	public Employee(Integer id, String name, Integer age, Double salary) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    	
    	public Integer getId() { 
    		return id;
    	}
    
    	public void setId(Integer id) { 
    		this.id = id;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public Integer getAge() { 
    		return age;
    	}
    
    	public void setAge(Integer age) { 
    		this.age = age;
    	}
    
    	public Double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(Double salary) { 
    		this.salary = salary;
    	}
    	
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((age == null) ? 0 : age.hashCode());
    		result = prime * result + ((id == null) ? 0 : id.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		result = prime * result + ((salary == null) ? 0 : salary.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Employee other = (Employee) obj;
    		if (age == null) { 
    			if (other.age != null)
    				return false;
    		} else if (!age.equals(other.age))
    			return false;
    		if (id == null) { 
    			if (other.id != null)
    				return false;
    		} else if (!id.equals(other.id))
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (salary == null) { 
    			if (other.salary != null)
    				return false;
    		} else if (!salary.equals(other.salary))
    			return false;
    		return true;
    	}
    
    	@Override
    	public String toString() { 
    		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    	}
    	
    }

重写完Employee实体类中的hashCode()和equals()这两个方法后，再次运行以上test5()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191211115657447.png]

## 映射 ##

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

### map(Function f) ###

下面我会举一个例子来演示map(Function f)。例如，将一个集合中的所有元素（英文字母）都给转成大写。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]  
从中我们可以得出一个结论：依次从数据源中提取出来的每个元素都将应用到map方法中的`(str) -> str.toUpperCase()`这个函数上，然后就产生一个新流，得到一个结果。  
如果这时我们想提取出公司中所有员工的名字，那么该咋办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]  
运行以上test6()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]

### flatMap(Function f) ###

在讲解flatMap(Function f)之前，我们可以在TestStreamAPI类中先编写一个方法，用于解析字符串，并把字符串中的一个一个的字符给单独提取出来，放到集合中。

//在讲解flatMap(Function f)之前，我们可以在类中先编写一个方法，用于解析字符串，并把字符串中的一个一个的字符给单独提取出来，放到集合中
    public static Stream<Character> filterCharacter(String str) { 
    	List<Character> list = new ArrayList<Character>();
    	for (Character ch : str.toCharArray()) { 
    		list.add(ch);
    	}
    	return list.stream();
    }

如果使用map方法来遍历出list集合中每个字符串的每一个字符，那么我们就得像下面这样做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 16]  
不知你有没有发现，像上面这样子做会很麻烦，还得嵌套遍历。那有没有更加简单的方式来遍历出list集合中每个字符串的每一个字符呢？当然有了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 17]  
运行以上test6()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 18]

### 小结 ###

map(Function f)与flatMap(Function f)它俩有点类似于集合中的add(Object obj)和addAll(Collection coll)这俩方法。先来看一下add(Object obj)方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 19]  
再来看一下addAll(Collection coll)方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 20]  
据此，我们应该知道map(Function f)与flatMap(Function f)它俩之间的区别了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 21]

## 排序 ##

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

### sorted() ###

下面我会举一个例子来演示sorted()。例如，将一个集合中的所有元素（英文字母）按照自然顺序排序。

//演示sorted()，自然排序
    @Test
    public void test8() { 
    	List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
    	
    	list.stream()
    	    .sorted()
    	    .forEach(System.out::println);
    }

运行以上test8()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213101214857.png]

### sorted(Comparator comp) ###

下面我会举一个例子来演示sorted(Comparator comp)。例如，通过定制排序比较两个Employee（先按年龄比，年龄相同再按姓名比）。为了更好地配合该案例的演示，首先得确保TestStreamAPI类的employees集合是下面这样子的。

然后，在TestStreamAPI类中编写一个如下的测试方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 22]  
运行以上test8()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 23]  
如果此时我们想按照年龄倒序来排，那么该咋怎呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 24]  
再次运行以上test8()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 25]

# 终止操作 #

终止操作会从流的流水线生成结果，其结果可以是任何不是流的值，例如List、Integer，甚至是void。

## 查找与匹配 ##

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

### allMatch(Predicate p) ###

下面我会举一个例子来演示allMatch(Predicate p)。例如，检查公司中所有员工是否处于忙碌状态。

package com.meimeixia.java8;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    
    import com.meimeixia.java8.Employee.Status;
    
    /* * 终止操作 */
    public class TestStreamAPI_2 { 
    	
    	List<Employee> employees = Arrays.asList(
    			new Employee(100, "张三", 18, 9999.99, Status.FREE),
    			new Employee(101, "李四", 38, 5555.99, Status.BUSY),
    			new Employee(102, "王五", 50, 6666.66, Status.VOCATION),
    			new Employee(103, "赵六", 16, 3333.33, Status.FREE),
    			new Employee(104, "田七", 8, 7777.77, Status.BUSY)
    	);
    	
    	@Test
    	public void test1() { 
    		boolean b1 = employees.stream()
    			     .allMatch((e) -> e.getStatus().equals(Status.BUSY));
    		System.out.println(b1);
    	}
    	
    }

其中，Employee实体类的内容如下：

package com.meimeixia.java8;
    
    public class Employee { 
    
    	private Integer id;
    	private String name;
    	private Integer age;
    	private Double salary;
    	
    	private Status status;//加个状态
    
    	public Employee() { 
    		super();
    	}
    
    	public Employee(Integer id) { 
    		super();
    		this.id = id;
    	}
    
    	public Employee(Integer id, Integer age) { 
    		super();
    		this.id = id;
    		this.age = age;
    	}
    
    	public Employee(Integer id, String name, Integer age, Double salary) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    	
    	public Employee(Integer id, String name, Integer age, Double salary, Status status) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    		this.status = status;
    	}
    
    	public Integer getId() { 
    		return id;
    	}
    
    	public void setId(Integer id) { 
    		this.id = id;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public Integer getAge() { 
    		return age;
    	}
    
    	public void setAge(Integer age) { 
    		this.age = age;
    	}
    
    	public Double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(Double salary) { 
    		this.salary = salary;
    	}
    	
    	public Status getStatus() { 
    		return status;
    	}
    
    	public void setStatus(Status status) { 
    		this.status = status;
    	}
    
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((age == null) ? 0 : age.hashCode());
    		result = prime * result + ((id == null) ? 0 : id.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		result = prime * result + ((salary == null) ? 0 : salary.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Employee other = (Employee) obj;
    		if (age == null) { 
    			if (other.age != null)
    				return false;
    		} else if (!age.equals(other.age))
    			return false;
    		if (id == null) { 
    			if (other.id != null)
    				return false;
    		} else if (!id.equals(other.id))
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (salary == null) { 
    			if (other.salary != null)
    				return false;
    		} else if (!salary.equals(other.salary))
    			return false;
    		return true;
    	}
    	
    	@Override
    	public String toString() { 
    		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
    				+ "]";
    	}
    
    	public enum Status { 
    		FREE,
    		BUSY,
    		VOCATION;
    	}
    
    }

### anyMatch(Predicate p) ###

下面我会举一个例子来演示anyMatch(Predicate p)。例如，检查公司中是否有员工处于忙碌状态。

### noneMatch(Predicate p) ###

下面我会举一个例子来演示noneMatch(Predicate p)。例如，检查公司中是否所有员工都没有处于忙碌状态。

@Test
    public void test1() { 
    	boolean b1 = employees.stream()
    		     .allMatch((e) -> e.getStatus().equals(Status.BUSY));
    	System.out.println(b1);
    	
    	System.out.println("--------------------------------------");
    	
    	boolean b2 = employees.stream()
    		     .anyMatch((e) -> e.getStatus().equals(Status.BUSY));
    	System.out.println(b2);
    	
    	System.out.println("--------------------------------------");
    	
    	boolean b3 = employees.stream()
    		     .noneMatch((e) -> e.getStatus().equals(Status.BUSY));
    	System.out.println(b3);
    
    }

### findFirst() ###

下面我会举一个例子来演示findFirst()。例如，获取公司中薪资最低的员工信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 27]  
不知你有没有想过，为什么findFirst()方法返回的结果类型是`Optional<Employee>`，而之前返回的不是`Optional<Employee>`呢？它是这样认为的，如果使用了findFirst()方法的话，那么最终的结果有可能为空，而只要有可能为空的话，它就会把这样的值封装到Optional容器中去。比方说当你查找流中的第一个元素时，就有可能没有第一个元素，你一个一个地使劲找，压根就找不到，因为根本就没有数据啊！这样，当返回的结果有可能为空时，它就会把这种有可能为空的值封装到Optional容器中去。  
Optional又是个什么东东呢？之前我们说了，Java 8会尽可能地去避免空指针异常，那它是怎么避免的呢？Java 8搞出了这么一个Optional，它是一个容器类，Java 8会把我们的对象封装到这个容器中去，有了这个容器以后，它就可以有一些方法来使用了，比如说有一个orElse()方法，这样的方法就是指当容器类中封装的那个对象为空时，你就可以考虑一个替代的对象了，这样的话，就避免了为空。因此，Java 8使用这种方式解决了空指针异常。  
此时，运行以上test1()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 28]  
如果此时我们想要获取公司中薪资最高的员工信息，那么该咋办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 29]  
再次运行以上test1()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 30]

### findAny() ###

下面我会举一个例子来演示findAny()。例如，获取公司中处于空闲状态的任意一个员工的信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 31]  
这里，一定要注意stream()与parallelStream()这两方法之间的区别。下一讲我就会介绍到串行流与并行流，这里稍微了解一下即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 32]  
此时，运行以上test1()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 33]

### count() ###

下面我会举一个例子来演示count()。例如，获取公司员工的总数。

@Test
    public void test2() { 
    	long count = employees.stream()
    		     .count();
    	System.out.println(count);
    }

### max(Comparator c) ###

下面我会举一个例子来演示max(Comparator c)。例如，获取公司中薪资最高的员工信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 34]  
运行以上test2()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][2019121312154213.png]

### min(Comparator c) ###

下面我会举一个例子来演示min(Comparator c)。例如，获取公司中的最小的工资是多少。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 35]  
运行以上test2()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213121557585.png]

### forEach(Consumer c) ###

对于该方法而言，我已经讲过不知道多少遍了，这里就不再赘述了。

## 归约 ##

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

### reduce(T identity，Binaryoperator b) ###

下面我会举一个例子来演示reduce(T identity，Binaryoperator b)。例如，计算1到10之间的和。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 36]

### reduce(Binaryoperator b) ###

下面我会举一个例子来演示reduce(Binaryoperator b)。例如，累计当前公司中工资的总和是多少。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 37]  
不知你有没有想过一个问题，为什么上面的那个reduce()方法返回的是Integer，下面的这个reduce()方法返回的就是Optional呢？你觉得上面的那个reduce()方法返回的值有可能为空吗？不可能，因为它有一个起始值，有了这个起始值，返回的值就不可能为空了；下面的这个reduce()方法有起始值吗？没有，因为没有起始值，所以总和有可能为空，比方说没人的公司就有可能为空。  
此时，运行以上test3()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213134634987.png]  
**实际上，map和reduce在当今的互联网中应用的是非常广泛的，map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名。**

## 收集 ##

![在这里插入图片描述][20191213142747749.png]  
Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、Set以及Map中），但是Collectors实现类中提供了许多静态方法，可以方便的创建常见的收集器实例。Collectors实现类中常用的静态方法如下表所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 38]  
下面我会举例来说明上表中所列出的每一个静态方法。

### toList() ###

下面我会举一个例子来演示Collectors实现类中的toList()静态方法。例如，我们想把当前公司中所有员工的名字给提取出来，并把这些名字放到一个List集合中，在实际开发中，这样的操作非常常见。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 39]  
运行以上test4()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 40]

### toSet() ###

下面我会举一个例子来演示Collectors实现类中的toSet()静态方法。例如，我们想把当前公司中所有员工的名字给提取出来，并把这些名字放到一个Set集合中。为了更好地配合该案例的演示，首先得在TestStreamAPI\_2类的employees集合中添加一个重复的元素。

List<Employee> employees = Arrays.asList(
    		new Employee(100, "张三", 18, 9999.99, Status.FREE),
    		new Employee(101, "李四", 38, 5555.99, Status.BUSY),
    		new Employee(102, "王五", 50, 6666.66, Status.VOCATION),
    		new Employee(103, "赵六", 16, 3333.33, Status.FREE),
    		new Employee(104, "田七", 8, 7777.77, Status.BUSY),
    		new Employee(104, "田七", 8, 7777.77, Status.BUSY)
    );

然后，在TestStreamAPI\_2类中编写一个如下的测试方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 41]  
运行以上test4()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 42]

### toCollection(…) ###

下面我会举一个例子来演示Collectors实现类中的toCollection()静态方法。例如，我们想把当前公司中所有员工的名字给提取出来，并把这些名字放到一个创建好的集合中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 43]  
运行以上test4()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 44]

### counting() ###

下面我会举一个例子来演示Collectors实现类中的counting()静态方法。例如，收集公司中员工的总人数。首先，将TestStreamAPI\_2类中的employees集合恢复到原来的样子。

然后，在TestStreamAPI\_2类中编写一个如下的测试方法。  
![在这里插入图片描述][20191213152436878.png]

### averagingDouble(…) ###

下面我会举一个例子来演示Collectors实现类中的averagingDouble()静态方法。例如，收集公司中所有员工工资的平均值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 45]  
运行以上test5()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213152500136.png]

### summingDouble(…) ###

下面我会举一个例子来演示Collectors实现类中的summingDouble()静态方法。例如，收集公司中所有员工工资的总和。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 46]  
运行以上test5()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213152527775.png]

### maxBy(…) ###

下面我会举一个例子来演示Collectors实现类中的maxBy()静态方法。例如，收集公司中最高工资的那个员工的信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 47]  
运行以上test5()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 48]

### minBy(…) ###

下面我会举一个例子来演示Collectors实现类中的minBy()静态方法。例如，收集公司中的最低工资。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 49]  
运行以上test5()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 50]

### groupingBy(…) ###

下面我会举一个例子来演示Collectors实现类中的groupingBy()静态方法。例如，将公司中所有员工按照状态来分组。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 51]  
运行以上test6()方法，可以发现Eclipse控制台打印的内容看起来不适合人观看，所以可以将打印内容做一下调整，就像下面这样子似的，这样可以清楚地看出公司中所有员工按照状态来分组的情况了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 52]  
如果此时我们要想进行多级分组，即先按照状态分组，按照状态分组完之后，再按照年龄段来分组，比如说35岁以内的就叫青年，50岁以内的就叫中年，剩下的就叫老年，那么该咋办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 53]  
运行以上test7()方法，同样发现Eclipse控制台打印的内容看起来不适合人观看，所以可以将打印内容做一下调整，就像下面这样子似的，这样可以清楚地看出多级分组的情况了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 54]

### partitioningBy(…) ###

下面我会举一个例子来演示Collectors实现类中的partitioningBy()静态方法。例如，将公司中所有员工进行分区（分片），工资大于8000的一个区，剩下的一个区。  
![在这里插入图片描述][20191213163021816.png]  
运行以上test8()方法，可以发现Eclipse控制台打印的内容看起来不适合人观看，所以可以将打印内容做一下调整，就像下面这样子似的，这样可以清楚地看出公司中所有员工分区的情况了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 55]

### summarizingDouble(…) ###

下面我会举一个例子来演示Collectors实现类中的summarizingDouble()静态方法。例如，收集公司中所有员工工资的总和、平均值，还要收集公司中的最高与最低工资。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 56]  
运行以上test9()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213163043613.png]

### joining(…) ###

下面我会举一个例子来演示Collectors实现类中的joining()静态方法。例如，提取出公司中所有员工的名字，然后拼接成一串字符串。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 57]  
运行以上test10()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213163103333.png]  
如果想要以逗号分隔所有员工的名字，那么该咋办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 58]  
此时，运行以上test10()方法，你便可以在Eclipse控制台看到如下图所示的打印信息了。  
![在这里插入图片描述][20191213163122816.png]  
如果想要输出像`===张三,李四,王五,赵六,田七===`的字符串，那么又该咋办呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 59]

# Stream API的练习 #

## 练习一 ##

给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？即给定\[1, 2, 3, 4, 5\]，应该返回\[1, 4, 9, 16, 25\]。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 60]

## 练习二 ##

怎样用map和reduce这俩方法数一数流中有多少个Employee呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 61]

## 练习三 ##

有如下三个类：

*  交易员类：
    
        package com.meimeixia.exer;
        
        /** * 交易员类 * @author liayun * */
        public class Trader { 
        	
        	private String name;
        	private String city;
        	
        	public Trader() { 
        		super();
        		// TODO Auto-generated constructor stub
        	}
        
        	public Trader(String name, String city) { 
        		super();
        		this.name = name;
        		this.city = city;
        	}
        
        	public String getName() { 
        		return name;
        	}
        
        	public void setName(String name) { 
        		this.name = name;
        	}
        
        	public String getCity() { 
        		return city;
        	}
        
        	public void setCity(String city) { 
        		this.city = city;
        	}
        
        	@Override
        	public String toString() { 
        		return "Trader [name=" + name + ", city=" + city + "]";
        	}
        	
        }
 *  交易类：
    
        package com.meimeixia.exer;
        
        /** * 交易类 * @author liayun * */
        public class Transaction { 
        
        	private Trader trader;
        	private int year;
        	private int value;
        	
        	public Transaction() { 
        		super();
        		// TODO Auto-generated constructor stub
        	}
        
        	public Transaction(Trader trader, int year, int value) { 
        		super();
        		this.trader = trader;
        		this.year = year;
        		this.value = value;
        	}
        
        	public Trader getTrader() { 
        		return trader;
        	}
        
        	public void setTrader(Trader trader) { 
        		this.trader = trader;
        	}
        
        	public int getYear() { 
        		return year;
        	}
        
        	public void setYear(int year) { 
        		this.year = year;
        	}
        
        	public int getValue() { 
        		return value;
        	}
        
        	public void setValue(int value) { 
        		this.value = value;
        	}
        
        	@Override
        	public String toString() { 
        		return "Transaction [trader=" + trader + ", year=" + year + ", value=" + value + "]";
        	}
        	
        }
 *  单元测试类：
    
        package com.meimeixia.exer;
        
        import java.util.Arrays;
        import java.util.List;
        
        import org.junit.Before;
        
        public class TestTransaction { 
        
        	List<Transaction> transactions = null;
        	
        	@Before
        	public void before() { 
        		Trader raoul = new Trader("Raoul", "Cambridge");
        		Trader mario = new Trader("Mario", "Milan");
        		Trader alan = new Trader("Alan", "Cambridge");
        		Trader brian = new Trader("Brain", "Cambridge");
        		
        		transactions = Arrays.asList(
        				new Transaction(brian, 2011, 300),
        				new Transaction(raoul, 2012, 1000),
        				new Transaction(raoul, 2011, 400),
        				new Transaction(mario, 2012, 710),
        				new Transaction(mario, 2012, 700),
        				new Transaction(alan, 2012, 950)
        		);
        		
        	}
        	
        	//1. 找出2011年发生的所有交易，并按交易额排序（从低到高）。
        	
        	//2. 交易员都在哪些不同的城市工作过？
        
        	//3. 查找所有来自剑桥的交易员，并按姓名排序。
        
        	//4. 返回所有交易员的姓名字符串，按字母顺序排序。
        
        	//5. 有没有交易员是在米兰工作的？
        	
        	//6. 打印生活在剑桥的交易员的所有交易额。
        
        	//7. 所有交易中，最高的交易额是多少。
        	
        	//8. 找到交易额最小的交易。
        	
        }

请解决如下8个问题：

*  (1)找出2011年发生的所有交易，并按交易额排序（从低到高）。
 *  (2)交易员都在哪些不同的城市工作过？
 *  (3)查找所有来自剑桥的交易员，并按姓名排序。
 *  (4)返回所有交易员的姓名字符串，按字母顺序排序。
 *  (5)有没有交易员是在米兰工作的？
 *  (6)打印生活在剑桥的交易员的所有交易额。
 *  (7)所有交易中，最高的交易额是多少。
 *  (8)找到交易额最小的交易。

如果想要找出2011年发生的所有交易，并按交易额排序（从低到高），那么你就应该像下面这样子做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 62]  
如果想要找出交易员都在哪些不同的城市工作过，那么你就应该像下面这样子做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 63]  
如果想要查找出所有来自剑桥的交易员，并按姓名排序，那么你就应该像下面这样子做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 64]  
如果想要返回所有交易员的姓名字符串，并按字母顺序排序，那么该咋怎呢？不知你有没有想过，这个问题还是有很大的歧义的，就看你是从什么角度去理解这个问题的。我们不妨从各种角度出发，来解决该问题。

*  可能你第一时间想到，然后写出来的代码是下面这样的：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 65]  
    运行以上test4()方法，你会在Eclipse控制台中看到如下图所示的打印信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 66]
 *  但是，有时候你可能不是像上面那样理解的，你理解的是先把所有的姓名按照字母顺序进行排序，然后再连成一个字符串，即先排后拼。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 67]  
    此时，运行以上test4()方法，你会在Eclipse控制台中看到如下图所示的打印信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 68]
 *  也有可能你是这样理解的：先将姓名字符串里面的一个一个字符给提取出来，然后再拼成一个字符串，接着按照字母顺序来进行排序，即先拼后排。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 69]  
    其中，filterCharacter()方法的代码如下：
    
        public static Stream<String> filterCharacter(String str) { 
        	List<String> list = new ArrayList<String>();
        	for (Character ch : str.toCharArray()) { 
        		list.add(ch.toString());
        	}
        	return list.stream();
        }
    
    此时，运行以上test4()方法，你会在Eclipse控制台中看到如下图所示的打印信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 70]
 *  从上面可以看到，虽然是按照字母顺序来进行排序的，但是排的并不好，因为字母有大小写。字符在按照字母顺序进行排序时，底层是按照ASCII码来排的，即大写字母在前，小写字母在后。但我现在想忽略字母大小写来进行排序，这该怎么办呢？  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 71]  
    此时，再次运行以上test4()方法，你会在Eclipse控制台中看到如下图所示的打印信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 72]

如果想要知道有没有交易员是在米兰工作的，那么你就应该像下面这样子做了。  
![在这里插入图片描述][20191213181832653.png]  
如果想要打印生活在剑桥的交易员的所有交易额，那么你就应该像下面这样子做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 73]  
如果想要知道在所有交易中，最高的交易额是多少，那么你就应该像下面这样子做了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 74]  
如果想要找出交易额最小的交易，那么你就应该像下面这样子做了。  
![在这里插入图片描述][20191213181852550.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191211091209415.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/20191211084419705.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/20191211102614871.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/20191211102622449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[2019121110263099.png]: https://img-blog.csdnimg.cn/2019121110263099.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191211102639373.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 5]: https://img-blog.csdnimg.cn/20191211102647392.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/20191211102654154.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/20191211102701290.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191211102708491.png]: https://img-blog.csdnimg.cn/20191211102708491.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191211102715548.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191211102724394.png]: https://img-blog.csdnimg.cn/20191211102724394.png
[20191211102732168.png]: https://img-blog.csdnimg.cn/20191211102732168.png
[20191211111258994.png]: https://img-blog.csdnimg.cn/20191211111258994.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191211111312726.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/20191211115620689.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/20191211115628554.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191211115637747.png]: https://img-blog.csdnimg.cn/20191211115637747.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20191211115646765.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191211115657447.png]: https://img-blog.csdnimg.cn/20191211115657447.png
[20191213085021633.png]: https://img-blog.csdnimg.cn/20191213085021633.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20191213085030970.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/20191213085035712.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/20191213085046733.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 16]: https://img-blog.csdnimg.cn/20191213093756807.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 17]: https://img-blog.csdnimg.cn/2019121309380558.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 18]: https://img-blog.csdnimg.cn/20191213093811545.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 19]: https://img-blog.csdnimg.cn/20191213093818483.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 20]: https://img-blog.csdnimg.cn/20191213093825129.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 21]: https://img-blog.csdnimg.cn/20191213093832421.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213101207501.png]: https://img-blog.csdnimg.cn/20191213101207501.png
[20191213101214857.png]: https://img-blog.csdnimg.cn/20191213101214857.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20191213101219571.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 23]: https://img-blog.csdnimg.cn/20191213101230673.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 24]: https://img-blog.csdnimg.cn/20191213101237813.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 25]: https://img-blog.csdnimg.cn/2019121310124557.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 26]: https://img-blog.csdnimg.cn/20191213110853550.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 27]: https://img-blog.csdnimg.cn/20191213113846985.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 28]: https://img-blog.csdnimg.cn/2019121311593777.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 29]: https://img-blog.csdnimg.cn/20191213115945910.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 30]: https://img-blog.csdnimg.cn/2019121311595064.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 31]: https://img-blog.csdnimg.cn/20191213120001790.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 32]: https://img-blog.csdnimg.cn/20191213120009816.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 33]: https://img-blog.csdnimg.cn/20191213120018407.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 34]: https://img-blog.csdnimg.cn/20191213121531484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[2019121312154213.png]: https://img-blog.csdnimg.cn/2019121312154213.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 35]: https://img-blog.csdnimg.cn/20191213121549981.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213121557585.png]: https://img-blog.csdnimg.cn/20191213121557585.png
[20191213134607634.png]: https://img-blog.csdnimg.cn/20191213134607634.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 36]: https://img-blog.csdnimg.cn/20191213134619880.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 37]: https://img-blog.csdnimg.cn/20191213134628387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213134634987.png]: https://img-blog.csdnimg.cn/20191213134634987.png
[20191213142747749.png]: https://img-blog.csdnimg.cn/20191213142747749.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 38]: https://img-blog.csdnimg.cn/20191213142803631.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 39]: https://img-blog.csdnimg.cn/20191213145319139.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 40]: https://img-blog.csdnimg.cn/20191213145330800.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 41]: https://img-blog.csdnimg.cn/20191213145344871.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 42]: https://img-blog.csdnimg.cn/2019121314535522.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 43]: https://img-blog.csdnimg.cn/20191213145401590.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 44]: https://img-blog.csdnimg.cn/20191213145414859.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213152436878.png]: https://img-blog.csdnimg.cn/20191213152436878.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 45]: https://img-blog.csdnimg.cn/20191213152446121.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213152500136.png]: https://img-blog.csdnimg.cn/20191213152500136.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 46]: https://img-blog.csdnimg.cn/20191213152514847.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213152527775.png]: https://img-blog.csdnimg.cn/20191213152527775.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 47]: https://img-blog.csdnimg.cn/20191213152536865.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 48]: https://img-blog.csdnimg.cn/20191213152551358.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 49]: https://img-blog.csdnimg.cn/20191213152601327.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 50]: https://img-blog.csdnimg.cn/20191213152610262.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 51]: https://img-blog.csdnimg.cn/20191213162937987.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 52]: https://img-blog.csdnimg.cn/20191213162947627.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 53]: https://img-blog.csdnimg.cn/20191213163002399.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 54]: https://img-blog.csdnimg.cn/20191213163012420.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213163021816.png]: https://img-blog.csdnimg.cn/20191213163021816.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 55]: https://img-blog.csdnimg.cn/20191213163030878.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 56]: https://img-blog.csdnimg.cn/20191213163035357.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213163043613.png]: https://img-blog.csdnimg.cn/20191213163043613.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 57]: https://img-blog.csdnimg.cn/20191213163055844.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213163103333.png]: https://img-blog.csdnimg.cn/20191213163103333.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 58]: https://img-blog.csdnimg.cn/20191213163113387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213163122816.png]: https://img-blog.csdnimg.cn/20191213163122816.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 59]: https://img-blog.csdnimg.cn/20191213163128447.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 60]: https://img-blog.csdnimg.cn/20191213165149273.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 61]: https://img-blog.csdnimg.cn/20191213165153833.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 62]: https://img-blog.csdnimg.cn/20191213181630720.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 63]: https://img-blog.csdnimg.cn/20191213181641960.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 64]: https://img-blog.csdnimg.cn/20191213181650553.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 65]: https://img-blog.csdnimg.cn/20191213181659281.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 66]: https://img-blog.csdnimg.cn/20191213181711519.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 67]: https://img-blog.csdnimg.cn/20191213181721577.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 68]: https://img-blog.csdnimg.cn/20191213181730795.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 69]: https://img-blog.csdnimg.cn/20191213181741624.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 70]: https://img-blog.csdnimg.cn/20191213181752702.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 71]: https://img-blog.csdnimg.cn/20191213181811192.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 72]: https://img-blog.csdnimg.cn/20191213181822160.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213181832653.png]: https://img-blog.csdnimg.cn/20191213181832653.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 73]: https://img-blog.csdnimg.cn/2019121318184253.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 74]: https://img-blog.csdnimg.cn/20191213181848674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20191213181852550.png]: https://img-blog.csdnimg.cn/20191213181852550.png