Java 8 函数式编程

今天打开Oracle Java官网一看，Java已经更新到 13 了

https://www.oracle.com/technetwork/java/javase/jdk-relnotes-index-2162236.html

而我们仍然大多使用的是Java 7的一些语法。后续，我们将使用 Java 8的一些新特性来方便编写Flink程序， 所以今天我们来看看Java 8中的重要新特性。

关于Java 8的新特性，可以在Oracle官网中查看到：https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html ，

本篇主要内容如下：

1. Lambda表达式
2. 方法引用
3. Stream API
4. Optional类

1、Lambda表达式

Lambda表达式是Java 8中重要的新特性之一，它可以让我们的Java代码变得更加简洁。Java 8允许将Lamdba表达式作为一个方法参数或者作为一个数据变量来传递。Lambda表达式也可以让我们更加简洁地实现单方法接口（称为功能接口）。大家可以参考Java 8的Lambda的官网链接来学习Lambda表达式的更多知识：https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax

语法

lambda表达式由以下内容组成：

• 括号内用逗号分隔的形式参数列表
• 注意：可以省略lambda表达式中参数的数据类型
• 注意：如果只有一个参数，则可以省略括号）
• 箭头符号 –>
• 主体，由单个表达式或语句块组成
• 注意：如果主体只有一个表达式，则返回值就是该表达式。否则，可以使用return语句
• 注意：如果表达式主体不是表达式，则必须要用大括号括起来

(参数1, 参数2) => 表达式

可以把lambda表达式看作匿名方法。

示例1

public class LambdaDemo {
    // 定义一个接口，接口中只有一个方法
    interface IntegerMath {
        int operation(int a, int b);
    }

    // 定义一个调用上述接口的方法
    public int operateBinary(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }

    public static void main(String[] args) {
        // 使用 lambda表达式可以快速实现一个接口
        IntegerMath addition = (a, b) -> a + b;
        LambdaDemo lambdaDemo = new LambdaDemo();

        System.out.println(lambdaDemo.operateBinary(1, 1, addition));
    }
}

示例2

使用Lambda表达式实现线程

// 使用Lambda表达式实现一个线程
        Thread thread1 = new Thread(() -> {
            while(true) {
                System.out.println("测试...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();

我们在讲解到 Stream API时，还会大量使用 lambda 表达式，此处，我们就把 lambda 表达式理解为快速实现匿名内部类的一种简洁方式即可。

2、方法引用

通过 Lambda表达式可以创建匿名方法。但是，有些时候，如果Lambda表达式只调用现有方法。或者我们在实现某个接口时，只需要引用某个类的方法。这种情况我们可以使用方法引用来实现。

说明	示例
对静态方法的引用	ContainingClass::staticMethodName
对特定对象的实例方法的引用	containingObject::instanceMethodName
对特定类型的任意对象的实例方法的引用	ContainingType::methodName
对构造函数的引用	ClassName::new

public class LambdaDemo {
    // 定义一个接口，接口中只有一个方法
    interface IntegerMath {
        int operation(int a, int b);
    }

    // 定义一个调用上述接口的方法
    public int operateBinary(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }

    public static int add(int a, int b) {
        return a + b;
    }

    public int sub(int a, int b) {
        return a - b;
    }

    public static void main(String[] args) {
        LambdaDemo lambdaDemo = new LambdaDemo();
        // 使用LambdaDemo::add引用静态方法
        System.out.println(lambdaDemo.operateBinary(1, 1, LambdaDemo::add));
        // 引用实例方法
        System.out.println(lambdaDemo.operateBinary(1, 1, lambdaDemo::sub));
    }
}

方法引用可以方便地将代码分离出来，让代码更有效地组织，变得更容易维护。

3、Stream API

Java 8 API添加了一个新的抽象称为流Stream。

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

Stream API可以让我们的代码变得更高效、整洁。这也是Java 8函数式编程中非常重要的一部分。

生成流

我们可以基于Java的集合通过调用 stream() 方法来快速为集合创建流。

ArrayList<Integer> integers = new ArrayList<>();
        for(int i = 0; i < 10; ++i) integers.add(i);

        // 为 integers 列表集合生成流
        Stream<Integer> stream = integers.stream();

Stream重要操作

map

map方法用于将Stream中的每个元素转换为其他的元素。

ArrayList<Integer> integers = new ArrayList<>();
        for(int i = 0; i < 10; ++i) integers.add(i);

        // 为 integers 列表集合生成流
        Stream<Integer> stream = integers.stream();
        
        Integer[] integerArray = {1, 2, 3, 4, 5};
        // 调用map方法，对整形数组的每个数字增加1
        Stream<Integer> integerStream = Arrays.stream(integerArray)
                .map(n -> n + 1);
        // 将流转换为列表
        List<Integer> integerList = integerStream.collect(Collectors.toList());
        // 打印
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

forEach

上述的遍历方式很不方便，我们可以直接使用流中提供的forEach方法来遍历流中的数据。

Arrays.stream(integerArray)
                // 调用map方法，对整形数组的每个数字增加1
                .map(n -> n + 1)
                // 调用forEach方法，遍历打印每个元素（方法引用）
                .forEach(System.out::println);

filter

使用filter可以过滤出一些元素。

// 过滤能够整除2的元素
        Arrays.stream(integerArray)
                // 过滤能够整除2的数字
                .filter(n-> n % 2 == 0)
                .forEach(System.out::println);

flatMap

flatMap可以先对数据进行转换，然后进行扁平化操作。

// 需求：将以下字符串数组中的人名全部打印出来
        String[] nameArray = {"zhangsan lisi wangwu", "zhaoliu shengqi"};
        Arrays.stream(nameArray)
                .flatMap(x -> Arrays.stream(x.split(" ")))
                .forEach(System.out::println);

注意：flatMap要求传入的Lambda表达式输出的还是一个Stream

count

获取元素个数

// 获取流中元素的数量
        System.out.println(Arrays.stream(nameArray).count());

distinct

去重

String[] fruitsArray = {"apple", "apple", "orange", "pear"};
        Arrays.stream(fruitsArray)
                // 去重
                .distinct()
                .forEach(System.out::println);

sorted

排序

// 使用 stream进行排序
        integers1.stream()
                // 排序：默认使用升序排序
                .sorted()
                // 使用降序排序
                .sorted((a, b) -> b - a)
                .forEach(n -> System.out.print(n + " "));


        System.out.println();

reduce

// 使用 reduce 对数值求和
        System.out.println(integers1.stream()
                .reduce((a, b) -> a + b)
                .get());

4、Optional类

Optional类是一个可以为null的容器对象，我们很多时候都需要对null进行额外处理。而使用Optional可以省去对null的判断。可以使用 isPresent()判断是否有值，使用get()可以获取到元素值。

Integer a = null;
        Optional<Integer> a1 = Optional.ofNullable(a);
        System.out.println(a1.isPresent());

        Integer b = 1;
        Optional<Integer> b1 = Optional.of(b);
        System.out.println(b1.isPresent());
        System.out.println(b1.get());