Lambda与Stream流

1.概述

Lamda和Stream都是jdk8的新特性，十分实用

Lamda是对匿名函数类的简化，极大提高了代码的简洁性

Steam流是对数据进行处理的流

2.Lambda

()->{} 是通用的lambda表达式

在jdk中在java.util.function包中给我们定义了很多通用型函数接口

在下面介绍4种常见的通用型接口

Comsumer消费型

void accept(T t);  接收一个参数没有返回值

        List.of(1,3, 3).forEach(System.out::println);

Function 函数型

R apply(T t);

System.out.println(toUpperCase("abc", String::toUpperCase));
static String toUpperCase(String s,Function function){
        return function.apply(s);
}
interface StringUtils{
    String toUpperCase(String s,Function function);
 }

Supplier 供给型

T get()

//获得4-8的的4个数集合
System.out.println(getRandomList(4,()->(int)(Math.random()*(8-4+1))+4));
    static List getRandomList(int s,Supplier function){
        List list = new ArrayList<>();
        for (int i = 1;i<=s;i++){
            list.add(function.get());
        }
        return list;
    }
interface RandomList{
    List  getRandomList(int s,Supplier function);
}

Preducate断言型

boolean test(T t)

 System.out.println(getFilterList(List.of("abc","ab","aer","ab","adf","adg"),(s)->!s.equals("ab")));
    static List  getFilterList(List s,Predicate function){
        List list = new ArrayList<>();
        for (String str:s){
            if (function.test(str)) {
                list.add(str);
            }
        }
        return list;
    }
interface FilterList{
    List  getFilterList(List s,Predicate function);
}

3.函数引用

方法引用是一种lambda表达式的一种简化

类似于通过对象去调用方法

对象::实例方法

数据类型::静态方法

数据类型::实列方法        参数的第一个当对象使用去调用方法

构造器引用    数据类型::new

规则：

        1.Lambda中的参数列表和返回值必须要和Lambda体中的参数列表和返回值一一对应

        2.Lambda的返回类型必须和方法体中的返回类型一致

                lambda表达式只有一个参数作为对象去调用方法或者是作为参数被调用。

                lambda表达式存在多个参数第一个参数作为对象去调用方法其他参数作为方法参数一一对应。

对象::实列方法 

List.of(1,3, 3).forEach(System.out::println);

引用类型::实列方法

BiPredicate pre2 = String::equals;

类名::静态方法

 Comparator com2 =Integer::compare;
 System.out.println(com2.compare(100,102));

引用类型::new 

Supplier employee = Employee::new;
Function employee2 = Employee::new;
//调用无参构造 
System.out.println(employee.get());
//调用有参构造
System.out.println(employee2.apply("zhangsan"));

4.Stream流

stream：对数据进行操作

特点：

        stream本身不会存储数据 （只进行逻辑处理）

        stream流不会修改源对象的数据，每次结果返回新的stream流

        延迟加载：当发生终止行为时，才会执行一系列中间结果

        流都是一次性流，不能重复使用多次，一旦使用完就销毁

流程：

        创建stream流

        一系列中间结果

        终止行为

创建stream流 

Collection->Stream
Arrays->stream
Stream.of()

        //并行流
        Stream stream = List.of(1, 2, 3).parallelStream();
        Stream stream5 = List.of(1, 2, 3).stream();
        String[] str = {"as","a","e","i","e"};
        Stream stream1 = Arrays.stream(str);
        Stream integerStream = Stream.of(1, 5, 6);

中间操作

过滤 filter 参数  断言型
去重 distinct()
截取  limit(long) 从第一个开始截取几个
跳过  skip(long) 跳过前n个
排序  sorted() --> 内部比较器
      sorted(Comparator) -->外部比较器
映射  map(Function) 参数是每一条数据，映射成一个新的结果返回，最后返回一个持有所以映射后的新的结果的流

stream1.filter((s)->!s.equals("a")).distinct().skip(1).limit(2).sorted().forEach(System.out::println);
        stream2.map((s)->{
            if (s.equals("e")){
                return 1;
            }else{
                return 0;
            }
        }).forEach(System.out::println);

终止操作

1)遍历 foreach(Consumer)
2)查找与匹配
 allMatch-检查是否匹配所有元素
 anyMatch-检查是否至少匹配一个元素
 noneMatch-检查是否没有匹配所有元素
 findFirst-返回第一个元素
 findAny-返回当前流中的任意元素
 count-返回流中元素的总个数
 max-返回流中最大值
 min-返回流中最小值
3)规约 reduce
map->reduce
加工->计算结果
4) 收集
collect()

        List list = Arrays.asList(
                new Employee("bcd", 27, 9500),
                new Employee("aaa", 29, 10000),
                new Employee("abc", 28, 8000),
                new Employee("bc", 28, 9000),
                new Employee("bc", 28, 9000),
                new Employee("cde", 30, 12000)
        );
        //判断每一个员工是否都>=20岁
        System.out.println(list.stream().distinct().allMatch((s) -> s.getSalary() >= 20));
        //查找薪资最低的员工
        //Optional存储一个数据的容器类型->jdk8新增的容器类型-->帮助避免出现空指针异常
        System.out.println(list.stream().sorted((d1, d2) -> (int) (d1.getSalary() - d2.getSalary())).findFirst().get());
        //并行流
        System.out.println(list.stream().findAny().get());
        System.out.println(list.parallelStream().findAny().get());
        //规约
        //找到公司所有员工的薪资，求和
        System.out.println(list.stream().map(Employee::getSalary).reduce((d1, d2) -> (d1 + d2)).get());
        //收集collect  把最终的结果进行收集  统计
        //平均薪资
        System.out.println(list.stream().collect(Collectors.averagingDouble(Employee::getSalary)));
        //static  Collector> toList() 返回 Collector ，将输入元素累积到新的 List 。
        System.out.println(list.stream().filter(e -> e.getAge() >= 28).collect(Collectors.toList()));
        //static  Collector> toSet() 返回 Collector ，将输入元素累积到新的 Set 。
        System.out.println(list.stream().filter(e -> e.getAge() >= 28).collect(Collectors.toSet()));
        //返回键值对
        //Collector> toMap(Function keyMapper, Function valueMapper) 返回 Collector ，它将元素累积到 Map其键和值是将提供的映射函数应用于输入元素的结果。
        //需要先去重
        Map collect = list.stream().distinct().collect(Collectors.toMap(Employee::getName, Employee::getSalary));
        System.out.println(collect);