Java 8 Lambda 表达式&Stream

Java 8 Lambda 表达式

1.Lambda 表达式简介

Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。

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

2.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 表达式的正文有一条以上的语句必须包含在大括号（代码块） 中，且表达式的返回值类型要与匿名函数的返回类型相同。

3.什么是功能接口（Functional ）

Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能 接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽 象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释 的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

以下是自定义功能接口的示例：

@FunctionalInterface
public interface WorkerInterface {
       public void doSomeWork();
}

正如其定义所述，功能接口只能有一个抽象方法。如果我们尝试在其中添加一个 抽象方法，则会抛出编译时错误。例如：

@FunctionalInterface
public interface WorkerInterface {
       public void doWork();
       public void doMoreWork();
}

案例:

@FunctionalInterface
public interface Shape {
       void area(int a,int b);
}
Shape d = (a, b)->{System.out.println(a+b);};
      d.area(1, 2);

4.Lambda 表达式的例子

1 线程初始化

//匿名内部类方式
new Thread(new Runnable() {
    @Override
    public void run() {
           System.out.println("Hello world");
    }
}).start();
// lambda 表达式方式
new Thread(
    () -> System.out.println("Hello world")
).start();

2 事件处理

// 匿名内部类方式
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
           System.out.println("Hello world");
    }
});
// lambda 表达式方式
button.addActionListener( (e) -> {
    System.out.println("Hello world");
});

3 遍历输出（方法引用）

输出给定数组的所有元素的简单代码。请注意，还有一种使用 Lambda 表达式 的方式。

//普通方式
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for (Integer n : list) {
    System.out.println(n);
}
// 使用 -> 的 Lambda 表达式
list.forEach(n -> System.out.println(n)

Java8Stream

什么是 Stream？

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。

要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全 不同的概念。

简单案例:

public static void main(String[] args) {
​
       List<Apple> applestore = new ArrayList();
       applestore.add(new Apple(1,"red",500,"河南"));
       applestore.add(new Apple(2,"red",400,"陕西"));
       applestore.add(new Apple(3,"green",300,"上海"));
       applestore.add(new Apple(4,"green",200,"湖北"));
       applestore.add(new Apple(5,"green",100,"湖南"));
}

我们的需求是在 applestore 集合中找出红色苹果手机.

使用 Stream 流快速实现操作

List<Apple> apples = applestore
                     .stream()
                     .filter(a -> a.getColor().equals("red"))
                     .collect(Collectors.toList());

这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想 要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。 同时可以将这些操作链接起来，达到一种流水线式的效果：

集合 —> 流 —> filter —> 流 —> sorted —> map —> result

Java8 中的集合支持一个新的 Stream 方法，它会返回一个流

什么是流呢？

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

元素列表

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

数据源

获取数据的源，比如集合

数据处理操作

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

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

语法:

List<Integer> list =
              widgets.stream()
              .filter(b -> b.getColor() == RED)
              .sorted((x,y) -> x.getWeight() - y.getWeight())
              .sum();

获取流

使用 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(): 将其映射成一个新的元素

Stream.of(2,4,1,5,3,7,7,6)
                .distinct()//去重
                .sorted()//进行排序
                .filter((e)->{return e>3;})//过滤筛选
                .skip(0)//跳过n个元素
                .limit(2)//获取n个元素
                .forEach(a-> System.out.println(a));//终端操作输出

​

终端操作

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

Object[] objects = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct().sorted()
                .toArray();//将流中的元素倒入一个数组
        System.out.println(objects);
​
        Integer max = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct().sorted()
                .max((o1, o2) -> {return o1 - o2;})//取最大值
                .get();
        System.out.println(max);
​
        Long count = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .count();//求元素个数
        System.out.println(count);
​
        int sum = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct().sorted()
                .reduce((acc, n) -> acc + n)//求元素总和 返回的是Optional 需要get获取值
                .get();
        System.out.println(sum);
​
        boolean b1 = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .anyMatch((o2)->{return o2>3;});//如果元素里有一个满足条件的，就返回true
        System.out.println(b1);
​
        boolean b2 = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .allMatch((o2)->{return o2>3;});//如果元素所有都满足条件，就返回true
        System.out.println(b1);

​