javaSE Lambda、Stream

lambda

java 8之后为了简化语法，推出了Lambda语言
Lambda 就是一个匿名函数，简化了匿名类的语法，以后可以将匿名函数当参数传递，由java进行判断，补全常规代码
Lambda 表达式的本质只是一个"语法糖"
Java 8 也引入了一个注释，即@FunctionalInterface，当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

Lambda 表达式的结构

• Lambda 表达式可以具有零个，一个或多个参数。
• 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。 例如 (int a,int b)与 (a,b)相同。
• 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。
• 空括号用于表示一组空的参数。例如 () -> 42。
• 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。 例如 a -> return a*a。
• Lambda 表达式的正文可以包含零条，一条或多条语句。 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式 的返回值类型要与匿名函数的返回类型相同。
• 如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。
• Java 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写，例如：

/*左侧：lambda 表达式的参数列表 

右侧：lambda 表达式中需要执行的功能，即 lambda 体 */

(arg1, arg2...) -> { body } 

(type1 arg1, type2 arg2...) -> { body } 

以下是一些 Lambda 表达式的例子： 

//无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略
() -> System.out.println("Hello World"); 

//无参数，有返回值 
() -> { return 3.1415 };

//有参数，无返回值 
(String s) -> { System.out.println(s); } 

//有一个参数，无返回值
s -> { System.out.println(s); } 

//有多个参数，有返回值
(int a, int b) -> { return a + b; } 

//有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 
(a, b) -> { return a - b; }

Stream

Stream流是 java8推出的新功能，与IO流完全不同，提供了对象数据集合进行操作的各种方法，我们只需要告诉声明式其应该什么

java中的集合、数组主要是存储数据，而Stream主要作用是对集合进行操作

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

**元素列表:**和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

**数据源 😗*获取数据的源，比如集合。

**数据处理操作 😗*流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合

获取流

使用 Collection 接口下的 stream()

List<String> list = new ArrayList<>(); 

Stream<String> stream = list.stream(); 

使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10]; 

Stream<Integer> stream = Arrays.stream(nums);

使用 Stream 中的静态方法：of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6); 

使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt")); 

Stream<String> lineStream = reader.lines(); 

流操作

流操作可以分为两类：中间操作和终端操作。回看之前的代码：

//获得流
List<Apple> apples = applestore 
.stream() 
//中间操作
.filter(a -> a.getColor().equals("red")) 
//终端操作
.collect(Collectors.toList()); 

简化一下就是：

数据源 => 中间操作 => 终端操作 => 结果

诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。中间操作

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

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

数据集合–>Stream–>filter–>Stream–>sorted–>流–>tolist/sum/max–>result

就是一个对集合进行遍历操作的高级迭代器

示例：

Integer[] array={3,4,3,2,5,1,7,8};
Arrays.stream(array)//返回一个Stream对象
      .filter((e)->{return e<6;})//对流进行一个过滤操作，返回一个流对象
      .sorted((a,b)->{return a-b;})//对流进行一个排序操作，返回一个流对象
      .skip(O)//跳过限定数量的元素
      .limit(2)//限制取出的个数
      .forEach((e)->{
          System.out.println(e);
      })
    //求和
    Integer  sum=Arrays.stream(array)
    .distinct()
    .redcue((a,b)->{  return a+b })
    .get();
   // 将元素装到数组中
    Object []objs=Arrays.stream(array)
    .distinct()
    .toArray()
    //数组元素装到Map
        Map<Integer,String> carmap=Arrays.stream(cars)
                    .collect(Collectors.tpMap(Car::getNum,Car::getColor));//在集合中选出两个属性作为键、值
          //取出Car数组中的其中一个属性
        List<Integer>  listnum=Arrays.stream(cars)
            .map(Car::getNum)
            .collect(Collectors.toList());