Java8 Lambda&Stream

lambda

匿名函数 ：简化Java中的匿名内部类 事件监听Actionlistener (接口)

内部类 类在其他地方用不到，就把类定义在类的内部

好处：内部可以使用外部类成员

其他地方发现不了

内部类只用一次

Java8前，函数/方法是不能当作参数传递，必须将函数包装在对象中，核心

就是函数而完成某个功能，还要创建对象

lambda表达式是一个匿名函数，可理解为一段可以传递的代码，让代码更加简洁，提高代码的表达能力。

其本质是语法糖（是某种语法简化开发），由编译器进行推断帮助用户包装转换为常规代码。

Java语法糖除开lamdba 以外还由泛型，拆箱。

3.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; }

实例

import javax.swing.*;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String >arr= new ArrayList<>();
        arr.add("a");
        arr.add("b");
        arr.add("c");
        /*arr.sort((a,b)->{
            return a.compareTo(b);
        });
         */
        arr.sort((o1,o3)->{
            return o1.compareTo(o3);
        });
        System.out.println(arr);
        arr.forEach((a)->{//遍历
            System.out.println(a);
        });
    }
}

Stream 

stream是Java的新特性，以声明的方式进行处理数据集合，可看作遍历数据集的高级迭代器.

java中的集合支持Stream方法，会返回流。

流：从支持数据处理操作的源，生成的与那苏序列。

元素列表：和集合一样，流提供接口，去访问特定元素类型的一组有序值。

数据源：获取数据的源如集合。

Stream处理数据的过程

数组/集合——>流——>操作——>结果（数组/集合）

数组集合与Stream的区别

数组和集合类偏向于存储数据（各种结构）

Stream更偏向于数据操作

流的中间操作

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

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

distinct: 去除重复元素

limit(n): 获取 n 个元素

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

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

package Stream;

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

public class Demo {
    public static void main(String[] args) {
        /*
        1.获取流
        2.操作
        filter：过滤流中的某些元素, sorted(): 自然排序，流中元素需实现 Comparable 接口
          distinct: 去除重复元素
        limit(n): 获取 n 个元素
         skip(n): 跳过 n 元素，配合 limit(n)可实现分页
          map(): 将其映射成一个新的元素
         */
            ArrayList<Integer> arrayList=new ArrayList<>();
            arrayList.add(1);
            arrayList.add(2);
            arrayList.add(3);
            arrayList.add(4);
            arrayList.add(2);
            Stream<Integer> stream = arrayList.stream();
                /* arrayList.stream()
                          .filter(e->{
                              return e<5;
        }).distinct().sorted((o1, o2) -> {
            return  o2-o1;
                 }).forEach((e)->{
                     System.out.println(e);
                 });

                 */
           arrayList.stream().skip(2).limit(2).forEach((e)->{
               System.out.println(e);
           });
    }
}

终端操作

forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

回 true，否则返回 false

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

回 true，否则返回 false

findFirst：返回流中第一个元素

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

package Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo1 {
    public static void main(String[] args) {
         /*
        1.获取流
        2.操作
        filter：过滤流中的某些元素, sorted(): 自然排序，流中元素需实现 Comparable 接口
          distinct: 去除重复元素
        limit(n): 获取 n 个元素
         skip(n): 跳过 n 元素，配合 limit(n)可实现分页
          map(): 将其映射成一个新的元素
         */
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(2);
        Stream<Integer> stream =arrayList.stream();
                /* arrayList.stream()
                          .filter(e->{
                              return e<5;
        }).distinct().sorted((o1, o2) -> {
            return  o2-o1;
                 }).forEach((e)->{
                     System.out.println(e);
                 });

                 */
      /*Integer min=arrayList.stream().distinct().min((o1, o2) -> {//获取最小
          return o1-o2;
      }).get();
        System.out.println(min);
       */
        /*long sum =arrayList.stream().distinct().reduce((o1, o2)->{//求和
            return o1+o2;
        }).get();
        System.out.println(sum);
         */
       /*long count=arrayList.stream().count();//元素个数
        System.out.println(count);

        */
        Boolean result=arrayList.stream().distinct().anyMatch((e)->{//部分满足条件
            return e<3;
        });
        System.out.println(result);
        Boolean result1=arrayList.stream().distinct().allMatch((e)->{//全部满足条件
            return e<6;
        });
        System.out.println(result1);
    }
}