浅析Java8新特性-Stream流操作：Stream概念、常见中间/终止操作符、创建stream的3种方式、串行流/并行流的区分、使用示例(遍历/匹配、过滤、聚合、映射、归约、归集、统计、分区分组、接合、排序、组合/提取、分页、并行、集合转Map、使用并行流注意点)

• 分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
• 分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "Washington"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "New York"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList.stream()
　　.collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map<String, List<Person>> group = personList.stream()
　　.collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> group2 = personList.stream()
　　.collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));

// 结果
// 员工按薪资是否大于8000分组情况：
{
false=[
　　Person{name='Jack', salary=7000, age=25, sex='male', area='Washington'}, 
　　Person{name='Lily', salary=7800, age=21, sex='female', area='New York'}
], 
true=[
　　Person{name='Tom', salary=8900, age=23, sex='male', area='Washington'}, 
　　Person{name='Anni', salary=8200, age=24, sex='female', area='New York'}
]
}
// 员工按性别分组情况：
{
female=[
　　Person{name='Lily', salary=7800, age=21, sex='female', area='New York'}, 
　　Person{name='Anni', salary=8200, age=24, sex='female', area='New York'}
], 
male=[
　　Person{name='Tom', salary=8900, age=23, sex='male', area='Washington'}, 
　　Person{name='Jack', salary=7000, age=25, sex='male', area='Washington'}
]
}
// 员工按性别、地区：
{
　　female={
　　　　New York=[
　　　　　　Person{name='Lily', salary=7800, age=21, sex='female', area='New York'}, 
　　　　　　Person{name='Anni', salary=8200, age=24, sex='female', area='New York'}
　　　　]
　　}, 
　　male={
　　　　Washington=[
　　　　　　Person{name='Tom', salary=8900, age=23, sex='male', area='Washington'}, 
　　　　　　Person{name='Jack', salary=7000, age=25, sex='male', area='Washington'}
　　　　]
　　}
}

List<Person> personList = new ArrayList<Person>();// 按工资升序排序（自然排序）
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
                .collect(Collectors.toList());
// 按工资倒序排序
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
                .map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄升序排序
List<String> newList3 = personList.stream()
                .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
                .collect(Collectors.toList());
// 先按工资再按年龄自定义排序（降序）- 自定义排序
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
            if (p1.getSalary() == p2.getSalary()) {
                return p2.getAge() - p1.getAge();
            } else {
                return p2.getSalary() - p1.getSalary();
            }
        }).map(Person::getName).collect(Collectors.toList());

11、提取/组合：流也可以进行合并、去重、限制、跳过等操作。

String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

12、分页操作：stream api 的强大之处还不仅仅是对集合进行各种组合操作，还支持分页操作。

　　例如，将如下的数组从小到大进行排序，排序完成之后，从第1行开始，查询10条数据出来，操作如下：

//需要查询的数据
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5, 10, 6, 20, 30, 40, 50, 60, 100);
List<Integer> dataList = numbers.stream().sorted(Integer::compareTo).skip(0).limit(10).collect(Collectors.toList());
System.out.println(dataList.toString());

13、并行操作

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// 采用并行计算方法，获取空字符串的数量
long count = strings.parallelStream().filter(String::isEmpty).count();
System.out.println(count);

public static void main(String[] args) {
    List<Person> personList = new ArrayList<>();
    personList.add(new Person("Tom",7000,25,"male","安徽"));
    personList.add(new Person("Jack",8000,30,"female","北京"));
    personList.add(new Person("Lucy",9000,40,"male","上海"));
    personList.add(new Person("Airs",10000,40,"female","深圳"));
    Map<Integer, Person> collect = personList.stream().collect(Collectors.toMap(Person::getAge, v -> v, (k1, k2) -> k1));
    System.out.println(collect);
}

{
　　40=Person{name='Lucy', salary=9000, age=40, sex='male', area='上海'}, 
　　25=Person{name='Tom', salary=7000, age=25, sex='male', area='安徽'}, 
　　30=Person{name='Jack', salary=8000, age=30, sex='female', area='北京'}
}

public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction) {
    return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}