java函数式编程

June 21, 2022

参考https://www.jishuchi.com/read/onjava8/12012

Lambda，方法引用

java

public class Main {
    public static void main(String[] args) {
        OneParam ref = Lambda::methodRef; // 静态方法的引用，类或者对象名::方法名
        ref.func(123);

        OneParam lambda = Lambda.one; // Lambda
        lambda.func(456);

        // 我们发现，方法引用和 Lambda 实际上都是函数式接口的实现，是实例对象而不是 Method（方法）
        // 也就是说，等效于：
        OneParam obj = new OneParam() {
            @Override
            public void func(int i) {
                System.out.println(i);
            }
        };
        obj.func(789);
    }
}

// @FunctionalInterface 注解让编译器检查接口是否为函数式接口，因为函数式接口只有一个抽象方法
// 其他的方法都是 default 方法或 static 方法或重载 Object 方法（如 boolean equals(Object obj)）
@FunctionalInterface
interface OneParam {
    // 这个接口内部只能有一个抽象方法，对应类型为 OneParam 的 lambda 表达式/方法引用
    void func(int a);
}
// 总而言之，只有一个方法的接口，可以视作函数式接口

class Lambda {
    static OneParam one = (int a) -> System.out.println(a);

    static void methodRef(int a) {
        System.out.println(a);
    }
}

绑定 this，构造函数引用

通过 类名::new 获取构造函数引用。

java

public class Main {
    public static void main(String[] args) {
        OneParam s = Lambda::say; // 普通（非静态）方法引用
        s.func(new Lambda(), "Hello"); // 必须关联到一个对象，此时，函数式接口的第一个参数必须为绑定的对象

        Con con = Lambda::new; // 构造函数引用
        con.make().say("greet");
    }
}

@FunctionalInterface
interface Con {
    Lambda make();
}

@FunctionalInterface
interface OneParam {
    void func(Lambda aThis, String s);
}

class Lambda {
    private String name = "Lambda";

    public void say(String greet) {
        System.out.println(greet + " " + name);
    }

}

java.util.function.*

标准库本身提供了一些实用函数式接口 API
详细内容参见文档https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

例如，interface Function<T, R>表示只有一个参数 T，返回 R 的方法：

java

import java.util.function.*;
public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = (String s) -> s.length();
        System.out.println(length.apply("Hello World")); // 11
    }
}

流式编程，Stream API

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

java

import java.util.*;
import java.util.stream.*;
import java.util.function.*;

public class Main {
    public static void main(String[] args) {
        // 给定初值和操作函数生成流
        Stream<Integer> s1 = Stream.iterate(0, i -> i + 1);
        // 生成含一个或多个元素的流
        Stream<Integer> s2 = Stream.of(1, 2, 3, 4, 5);

        // 通过Supplier生成流
        Stream<Integer> s3 = Stream.generate(() -> (int) (Math.random() * 100));
        Stream<Integer> s4 = Stream.generate(new Supplier<Integer>() {
            int n = 0;

            public Integer get() {
                n++;
                return n;
            }
        });

        // 通过集合生成流
        Stream<String> s5 = Arrays.stream(new String[] { "A", "B", "C" });
        Stream<String> s6 = List.of("X", "Y", "Z").stream();

        s1.limit(10).forEach(System.out::print);
        System.out.println();
        s2.limit(10).forEach(System.out::print);
        System.out.println();
        s3.limit(10).forEach(System.out::print);
        System.out.println();
        s4.limit(10).forEach(System.out::print);
        System.out.println();
        s5.limit(10).forEach(System.out::print);
        System.out.println();
        s6.limit(10).forEach(System.out::print);
        System.out.println();

        // 合并两个流
        Stream.concat(Stream.of(1, 2, 3), Stream.of(4, 5)).forEach(System.out::print);

        // 转换为数组
        Integer[] a1 = Stream.of(1, 2, 3, 4, 5).toArray(Integer[]::new);
        // 转换为集合
        List<Integer> a2 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toList());
        Set<Integer> a3 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toSet());
        Map<Integer, Integer> a4 = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toMap(i -> i, i -> i));

        Map<String, List<String>> a5 = Stream
                .of("Apple", "Banana", "Blackberry", "Coconut", "Avocado", "Cherry", "Apricots")
                .collect(Collectors.groupingBy(s -> s.substring(0, 1), Collectors.toList()));

    }
}