函数式编程

• 基本概念
• 函数对象类型
• 闭包和柯里化
• 高阶函数
• Stream API
• 并行流
• 具体应用
• 原理
• 其他

基本概念

合格的函数

• input->output
• 不引用外部可变数据（stream-final)

函数的本质是规则，函数对象固化规则，使之可传递

1. 行为参数化

public class FunctionalPro {

    @AllArgsConstructor
    @ToString
    static class Student {
        private String name;
        private Integer age;
        private String sex;
    }

    public static void main(String[] args) {
        List<Student> list = Arrays.asList(
                new Student("张无忌",18,"男"),
                new Student("杨不悔",16,"女"),
                new Student("周芷若",19,"女"),
                new Student("宋青书",20,"男")
        );

        //lambda本质是接口的匿名实例化
        System.out.println(filter(list, student -> student.name.equals("张无忌")));

        System.out.println(filter(list, student -> student.age < 19));

        System.out.println(filter(list, student -> student.sex.equals("女")));
    }

    @FunctionalInterface //确保只有一个抽象方法
    interface Lambda {
        boolean predicate(Student student);
    }

    static private List<Student> filter(List<Student> list, Lambda pred) {
        List<Student> res = new ArrayList<>();
        for(Student student : list) {
            if(pred.predicate(student)) {
                res.add(student);
            }
        }
        return res;
    }
}

2. 延迟执行

行为参数化后带来的结果就是可以自行选择执行时机，外部if->内部if，提高了整体性

public class FunctionalPro {

    public static void main(String[] args) {

        int logLevel = 1;

        if(logLevel == 1) {
            excute();
        }

        showLog(logLevel, () -> excute()); //等价showLog(logLevel, FunctionalPro::excute);
    }

    static void showLog(int level, Supplier<String> supplier) {
        if(level == 1) {
            System.out.println(supplier.get());
        }
    }

    static String excute() {
        System.out.println("执行耗时操作");
        return "需要的结果";
    }

}

函数对象类型

什么是函数接口（Functional Interface)：a Single Abstract Method(SAM) interface

@FunctionalInterface //确保只有一个抽象方法
interface Lambda {
    boolean predicate(Student student);
}

什么是函数对象(Functional Object)：函数接口（Functional Interface）的实现类

类型：

1. lambda表达式 Lmbda lambda = student -> student.age <= 18
2. 方法引用（现有方法转为含数据对象）

本质：静态方法直接调用，非静态方法需要对象调用

Jdk中已定义的函数接口：

闭包和柯里化

闭包：

捕获外部变量，变量需要时final或者effective final

public class FunctionalPro {
    public static void main(String[] args) {
        List<Runnable> list = new ArrayList<>();
        for(int i = 0; i < 10; i++) {
            int k = i + 1;
            Runnable task = () -> System.out.println(Thread.currentThread()+"：执行任务"+k);
            list.add(task);
        }

        ExecutorService executorService = Executors.newCachedThreadPool();
        for(Runnable task : list) {
            executorService.submit(task);
        }
    }
}

柯里化：

让接收多个参数的函数转换成一系列接收一个参数的函数（闭包传递前端参数），让函数分步执行

代码见：currying.java

高阶函数

含义：是其它函数对象的使用者。

作用：

• 将通用、复杂的逻辑隐含在高阶函数
• 内将易变、未定的逻辑放在外部的函数对象中

实现简单流：

代码见：SimpleStream.java

Stream API

流的特性：一次使用，两类操作（中间操作 lazy，终结操作 eager）

构建与生成：

//构建流
List.stream();
Arrays.Stream();
Stream.of(1,2,3);
//生成流
IntStream.range(1,10).forEach(System.out::println);

IntStream.iterate(1, x->x+1).limit(10).forEach(System.out::println);
IntStream.iterate(1, x->x<=9, x->x+1).forEach(System.out::println);

IntStream.generate(()->ThreadLocalRandom.current().nextInt(100)).limite(10).forEach(System.out::println);
ThreadLocalRandom.current().ints(5, 0, 100).forEach(System.out::println);
    

流操作：

代码见： StreamAPI.java

下游收集器：

代码见： DCollector.java

基本类型流：

• IntStream
• LongStream
• DoubleStream

基本流方法：

Stream API汇总见： Stream.html

并行流

方法： .parallel()

并发收集器组成部分：

一般用法：

1. CONCURRENT+UNORDERED+线程安全容器
2. 默认 + 线程不安全容器

效率：

• 数据量少时： 单线程收集
• 数据量多时： 多线程Concurent收集 > 多线程非Concurrent收集
• 处理基本类型时： 基本流 $\approx$ 普通循环 >> 普通Stream流

代码见： ParallelStream

具体应用

1. 统计分析

代码见： AnalysisTest.java

2. 异步处理

代码见： AsynchronousTest.java

3. 框架设计
   • 半成品软件，帮助开发者快速构建应用程序
   • 框架提供的都是固定不变的、已知的、可以重用的代码
   • 而那些每个应用不同的业务逻辑，变化的、未知的部分，则在框架外由开发者自己实现
   • 函数对象用来传递这种可变的部分

代码见： FrameWorkTest.java 【方法引用的偏门用法：根据反射得到方法实现类】

4. 并行计算

代码见： ParallelTest.java

原理

Lambda和MethodReference本质都是语法糖，会被翻译为类，对象，方法

// -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles
// for (Method method : C01Lambda1.class.getDeclaredMethods()) {
//     System.out.println(method);
// }
public class C01Lambda1 {
    public static void main(String[] args) throws Throwable {
        BinaryOperator<Integer> lambda = (a, b) -> a + b;
        

        
        System.in.read();
    }
    
    // 类和对象：运行时生成
    static final class MyLambda implements BinaryOperator<Integer> {
        private MyLambda() {}
        @Override
        public Integer apply(Integer a, Integer b) {
            return lambda$main$2(a, b);
        }
    }

    // 方法：编译时生成
    private static Integer lambda$main$2(Integer a, Integer b) {
        return a + b;
    }
}

其他

• 练手写的代码：github地址
• 流操作简图