java8特性详解

---

一、功能

  父类：BasicStream
  子类：Stream、IntStream、LongStream、DoubleStream
  包含两个类型，中间操作(intermediate operations)和结束操作(terminal operations)
  下面是所有方法的属于那一端操作的方法：

parallelStream 使用问题

https://blog.csdn.net/qq_30336433/article/details/103809403
https://blog.csdn.net/xuxiaoyinliu/article/details/73040808

List 转 Map方式

Stream将List转换为Map，使用Collectors.toMap方法进行转换。
背景：User类，类中分别有id，name,age三个属性。List集合,userList，存储User对象

1、指定key-value，value是对象中的某个属性值。
Map<Integer,String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId,User::getName));

2、指定key-value，value是对象本身，User->User 是一个返回本身的lambda表达式
Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));

3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身
Map<Integer,User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

4、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身，key 冲突的解决办法，这里选择第二个key覆盖第一个key。
Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));

注意：用Collectors的toMap方法转换List，一般会遇到两个问题。一个是转换map，key重复问题；另一个是空指针异常，即转为map的value是null。

分组

Collectors.groupingBy()3个方法的使用示例

/**员工
 * @author Yang
 * @create 2020-07-09 19:57
 */
public class Employee {
    
    private String name;   // 姓
    private String city;   // 城市
    private Integer sales;  // 销售额

    public Employee(String name, String city, Integer sales) {
        this.name = name;
        this.city = city;
        this.sales = sales;
    }

    public Employee(String city, Integer sales) {
        this.city = city;
        this.sales = sales;
    }

    public Employee() {
    }

    // getter(),setter() ....略
    
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", city='" + city + '\'' +
                ", sales=" + sales +
                '}';
    }
}

    //-------------------生成测试数据---------------------
    private List<Employee> getEmps(){
        List<Employee> list = new ArrayList<>();
        Random rd = new Random();
        String[] citys = {"北京","上海","广州","杭州","深圳"};
        String[] firstName = {"张","李","杨","宁","刘","王","高","葛"};
        Integer[] sales = {100,50,30,20};

        for (int i = 0; i < 10; i++) {
            String city = citys[rd.nextInt(5)];
            Integer sale = sales[rd.nextInt(4)];
            String fname = firstName[rd.nextInt(firstName.length)];

            list.add(new Employee(fname,city,sale));
        }

        return list;
    }

方法1-- groupingBy(Function)
一个参数：一个分组器，使用提供的字段对集合元素进行分组，返回一个Map<字段，相同字段值的元素集>

/**
 *  groupBy方法1，groupingBy(Function)
 *
 *  要求：先按city分组，每个分组里面是一个员工集合
 */
@Test
public void test5(){
    List<Employee> emps = getEmps();

    Map<String, List<Employee>> map = emps.stream().collect(Collectors.groupingBy(Employee::getCity));

    map.forEach((key,val)->{
        System.out.println("城市："+key+" ---员工集： "+val);
    });
}
/**
 * 城市：广州 ---员工集： [Employee{name='1', city='广州', sales=100}, Employee{name='5', city='广州', sales=20}, Employee{name='6', city='广州', sales=30}, Employee{name='8', city='广州', sales=30}]
 * 城市：上海 ---员工集： [Employee{name='0', city='上海', sales=30}]
 * 城市：杭州 ---员工集： [Employee{name='2', city='杭州', sales=50}, Employee{name='7', city='杭州', sales=30}]
 * 城市：北京 ---员工集： [Employee{name='3', city='北京', sales=30}, Employee{name='4', city='北京', sales=50}, Employee{name='9', city='北京', sales=30}]
 */

方法2-- groupingBy(Function,Collector)
2个参数：一个是分组器，按提供的字段进行分组。一个收集器，下面举例了3种用途

/**
 *  groupBy方法2，groupingBy(Function,Collector)
 *
 *  要求：先按city分组 ，再对组里面的成员，统计总销售额
 */
@Test
public void test3(){
    List<Employee> emps = getEmps();
    for (Employee emp : emps) {
        System.out.println(emp);
    }

    Map<String, Integer> map = emps.stream().
            collect(Collectors.groupingBy(Employee::getCity, Collectors.summingInt(Employee::getSales)));
    //                                    先按city分组                                  再对组里面的成员，统计总销售额
    map.forEach((key,val)->{
        System.out.println("城市："+key+" 销售总额："+val);
    });
}
/**
 * Employee{name='0', city='上海', sales=50}
 * Employee{name='1', city='广州', sales=20}
 * Employee{name='2', city='广州', sales=30}
 * Employee{name='3', city='广州', sales=20}
 * Employee{name='4', city='杭州', sales=30}
 * Employee{name='5', city='杭州', sales=50}
 * Employee{name='6', city='北京', sales=50}
 * Employee{name='7', city='广州', sales=20}
 * Employee{name='8', city='杭州', sales=100}
 * Employee{name='9', city='广州', sales=30}
 * 城市：广州 销售总额：120
 * 城市：上海 销售总额：50
 * 城市：杭州 销售总额：180
 * 城市：北京 销售总额：50
 */

/**
 * groupBy方法2，groupingBy(Function,Collector)
 *
 * 即：获取每个城市的姓氏集
 * 先按城市分组，再对每个组里面的员工姓名放入Set，得到每个城市的姓氏集
 */
@Test
public void test4(){
    List<Employee> emps = getEmps();
    Map<String, Set<String>> map = emps.stream().collect(Collectors.groupingBy(Employee::getCity, Collectors.mapping(Employee::getName, Collectors.toSet())));
    map.forEach((key,val)->{
        System.out.println(""+key+" ---人员姓名： "+val);
    });
}
/**
 * 上海 ---人员姓名： [葛]
 * 广州 ---人员姓名： [张, 刘, 王]
 * 杭州 ---人员姓名： [杨, 刘, 葛]
 */

    /**
     * groupBy方法2，groupingBy(Function,Collector)
     * 要求：每个城市中销售额最大的员工
     *      先按城市分组，在求分组里面销售额最大的员工
     */
    @Test
    public void test6(){
        List<Employee> emps = getEmps();
        
        Map<String, Employee> map = emps.stream().collect(Collectors.groupingBy(Employee::getCity,
                Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Employee::getSales)), Optional::get)));

        map.forEach((key,val)->{
            System.out.println("城市："+key+" 销售额最大员工："+val);
        });
    }
   /**
     * Employee{name='杨', city='北京', sales=100}
     * Employee{name='杨', city='杭州', sales=20}
     * Employee{name='葛', city='深圳', sales=30}
     * Employee{name='张', city='上海', sales=50}
     * Employee{name='杨', city='广州', sales=50}
     * Employee{name='张', city='上海', sales=20}
     * Employee{name='张', city='上海', sales=50}
     * Employee{name='刘', city='北京', sales=50}
     * Employee{name='高', city='深圳', sales=100}
     * Employee{name='葛', city='深圳', sales=30}
     * 城市：广州 销售额最大员工：Employee{name='杨', city='广州', sales=50}
     * 城市：上海 销售额最大员工：Employee{name='张', city='上海', sales=50}
     * 城市：杭州 销售额最大员工：Employee{name='杨', city='杭州', sales=20}
     * 城市：深圳 销售额最大员工：Employee{name='高', city='深圳', sales=100}
     * 城市：北京 销售额最大员工：Employee{name='杨', city='北京', sales=100}
     */

方法3-- groupingBy(Function,Supplier,Collector)
参数：一个分组器，一个最终类型的生产者，一个收集器

下面的示例：先按城市分组，然后收集每个城市的姓氏集，然后放入一个TreeMap，得到最终结果。（按城市名称排了序

   /**
     * 3个参数的方法：groupingBy(Function,Supplier,Collector)
     * 要求：要计算每个城市中人的姓氏集，并对城市名称进行排序
     * 先按城市分组，在对每个城市
     */
    @Test
    public void test7(){
        List<Employee> emps = getEmps();
        TreeMap<String, Set<String>> map = emps.stream().collect(Collectors.groupingBy(Employee::getCity, TreeMap::new, Collectors.mapping(Employee::getName, Collectors.toSet())));
        map.forEach((key,val)->{
            System.out.println("城市："+key+" 姓氏集："+val);
        });
    }
    /**
     * 城市：上海 姓氏集：[刘]
     * 城市：北京 姓氏集：[宁, 李]
     * 城市：广州 姓氏集：[张, 高, 葛]
     * 城市：杭州 姓氏集：[张, 高, 葛]
     */