Java8常用特性 Stream,Lambda表达

Lambda：可以引用函数式接口，包含注释
@FunctionalInterface：只包含一个抽象方法的接口，称为函数式接口

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

好像没什么好说的，下面是常用方法，自行体会.：

import java.util.*;
import java.util.stream.Collectors;

public class Java8Test {
    public static void main(String [] args){
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("路飞",19));
        list.add(new Person("索隆",22));
        list.add(new Person("娜美",19));
        list.add(new Person("山治",20));

        //Lambda
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        }).start();
        
        list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge()-o1.getAge();
            }
        });


        //lambda形式
        new Thread(()-> System.out.println("hello")).start();
        
        list.sort((x,y)->y.getAge()-x.getAge());
        
        
        //Stream.......

        //将age属性封装到statistics,然后可以根据statistics求出max.min.sum.average;
        IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(Person::getAge));
        System.out.println(statistics.getAverage());//20.0
        System.out.println(statistics.getSum());//80

        //根据age属性排序desc;
        List<Person> collect = list.stream().sorted((x,y)-> y.getAge()-x.getAge()).collect(Collectors.toList());
      // 补充
        List<Person> collect = list.stream().sorted(( x, y) ->{
                                     if (x.age == y.age) {
                                         return x.name.compareTo(y.name);
                                     }
                                     return x.age - y.age;
                                 }
        ).collect(Collectors.toList());
        collect.forEach(x-> System.out.print(x.getName()+"："+x.getAge()));//索隆：22山治：20娜美：19路飞：19

        //过滤出娜美
        List<Person> collect1 = list.stream().filter(x -> !"娜美".equals(x.getName())).collect(Collectors.toList());
        collect1.forEach(x-> System.out.print(x.getName()));//路飞索隆山治
        System.out.println();

        //根据age distinct
        List<Integer> collect4 = list.stream().map(x -> x.getAge()).distinct().collect(Collectors.toList());
        System.out.println(collect4);//[19, 22, 20]

        //检查是否含有索隆
        boolean b = list.stream().anyMatch(x -> x.getName() == "索隆");
        //是否全都大于15岁
        boolean b1 = list.stream().allMatch(x -> x.getAge() > 15);
        System.out.println(b);//true
        System.out.println(b1);//true

        //根据年龄分类
        Map<Integer, List<Person>> collect2 = list.stream().collect(Collectors.groupingBy(x -> x.getAge()));
        collect2.keySet().forEach(x-> System.out.println(x));//192022
        collect2.get(19).forEach(x-> System.out.print(x.getName()));//路飞娜美

        //将集合的name成字符串
        String collect3 = list.stream().map(x -> x.getName()).collect(Collectors.joining(","));
        System.out.println(collect3);//路飞,索隆,娜美,山治

        //map reduce操作 和大数据处理的mr操作类似，x,y代表的是map映射出来的x.getAge() + 1的前后
        Integer integer = list.stream().map(x -> x.getAge() + 1).reduce((x, y) -> x + y).get();
        System.out.println(integer);//（19+1）+（22+1）+（19+1）+（20+1）=84

        //将list转成 (age,Person)的map,参数表示toMap(age,Person,(上一个key，下一个key)重复的时候，value取下一个，即key相同时 例19，new Person("娜美",19)会替换掉路飞那个！
        Map<Integer, Person> collect5 = list.stream().collect(Collectors.toMap(x -> x.getAge(), x -> x,(x,y)->(y)));
        collect5.keySet().forEach(x-> System.out.println(collect5.get(x).getName()));
        //娜美山治索隆


    }
}

class Person{
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public Integer getAge() {
        return age;
    }
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}