lambda表达式&Stream

lambda表达式

1.前言

在Java中，为了将某些功能传递，总要取创建类，内部类，匿名内部类，为了更简便，jdk8之后，Java新增了Lambda表达式。

2.概念

lambda又称函数式编程，将函数作为参数进行传递，使得代码更简洁

3.结构

💀参数可以为0个，1个或多个；

💀可以显式声明参数的类型，(int a,int b)==(a,b),或编译器自动推断。

💀表达式返回值类型与匿名函数返回类型一致

4.功能接口

Lambda表达式只支持函数式接口，即只有一个抽象方法的接口，注释为：@FunctionalInterface

Stream

1.概念

💀Stream与流是两个完全不同的概念，它可以看作为高级迭代器。

💀Stream流使用声明方式来写，它将各个操作链接起来，达成流水线

简而言之，通过集合的stream方法获取流，对流进行一系列流操作，最后再构建为需要的集合。

2.获取流

💀Arrays中stream()，将数组转为流

int [] arrs={1,3,2,4,5,6,3};
        Arrays.stream(arrs);

3.流操作

3.1中间操作

filter：过滤流中的某些元素,

sorted(): 排序，流中元素需实现 Comparable 接口 distinct: 去除重复元素 limit(n): 获取 n 个元素 skip(n): 跳过 n 元素 map(): 将其映射成一个新的元素

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;

public class Stream2 {
    public static void main(String[] args){
        Stream.of(2,1,3,2,4,5,7,6,3)
                .distinct()
                .sorted((o1,o2)->{
                    return o1-o2;
                })
                /*.sorted((o1,o2)->{ //逆序
                    return o2-o1;
                })*/
                .skip(1)
                .forEach((e)->{
                    System.out.print(e+" ");//2 3 4 5 6
                });
        }
    }

3.2终端操作

forEach: 遍历流中的元素 toArray:将流中的元素倒入一个数组 Min:返回流中元素最小值 Max:返回流中元素最大值 count:返回流中元素的总个数 Reduce:所有元素求和 anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false findFirst：返回流中第一个元素 collect:将流中的元素倒入一个集合,Collection 或 M ap

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Stream3 {
    public static void main(String[] args) {
        Integer min=Stream.of(2,1,3,2,4,5,7,6,3)
                .min((o1,o2)->{
                    return o1-o2;
                })
                .get();
        System.out.println(min);//1

        /*Long count=Stream.of(2,1,3,2,4,5,7,6,3)
                .distinct()
                .count();
        System.out.println(count);*/

        Integer count=Stream.of(2,1,3,2,4,5,7,6,3)
                .reduce((a,b)->{
                    return a+b;
                })
                .get();
        System.out.println(count);//33

        Object[] objects=Stream.of(2,1,3,2,4,5,7,6,3)
                .distinct()
                .toArray();//将流对象转为数组
        System.out.println(Arrays.toString(objects));//[2, 1, 3, 4, 5, 7, 6]

        List list=Stream.of(2,1,3,2,4,5,7,6,3)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(list);//[2, 1, 3, 4, 5, 7, 6]

        boolean b=Stream.of(2,1,3,2,4,5,7,6,3)
                /*.allMatch((e)->{
                    return e<7;//false
                });*/
                .anyMatch((e)->{
                    return e<7;
                });
        System.out.println(b);//true
    }
}