函数式编程

ps：

虽然平时接触的很多，但是没有太学习过，由此来学习一下。

目录

1.概述

2.Lambda表达式

3.Stream流

4.Optional

5.函数式接口

6.方法引用

7.高级用法

概念

为什么学习

• 读懂现代公司代码：Java 8+ 的 API、Spring、各类框架内部大量使用 FP 思维。

  高效处理大规模数据集合：Stream、Map、Reduce 能显著提升性能与简洁性。

  显著提高可读性：逻辑以操作链形式呈现，更贴近自然语言和数学函数。

  减少嵌套和控制结构：让开发者专注于“数据如何变化”而不是“怎么写循环”。

//查询未成年作家的评分在70以上的书籍 由于洋流影响所以作家和书籍可能出现重复，需要进行去重
List<Book> bookList = new ArrayList<>();
Set<Book> uniqueBookValues = new HashSet<>();
Set<Author> uniqueAuthorValues = new HashSet<>();
for (Author author : authors) {
    if (uniqueAuthorValues.add(author)) {
        if (author.getAge() < 18) {
            List<Book> books = author.getBooks();
            for (Book book : books) {
                if (book.getScore() > 70) {
                    if (uniqueBookValues.add(book)) {
                        bookList.add(book);
                    }
                }
            }
        }
    }
}
System.out.println(bookList);

使用函数式编程

List<Book> collect = authors.stream()
    .distinct()
    .filter(author -> author.getAge() < 18)
    .map(author -> author.getBooks())
    .flatMap(Collection::stream)
    .filter(book -> book.getScore() > 70)
    .distinct()
    .collect(Collectors.toList());
System.out.println(collect);

优雅美观，可读性高，让人们更关注目的

编程思想

面向对象思想需要关注用什么对象完成什么事情。而函数式编程思想就类似于我们数学中的函数。它主要关注的是对数据进行了什么操作。

• 代码简洁，开发快速
• 接近自然语言，易于理解
• 易于"并发编程"

项目	面向对象编程（OOP）	函数式编程（FP）
核心关注点	“谁”去做 —— 关注对象、类、职责	“做什么” —— 关注对数据执行的操作
思维方式	构建对象体系，通过对象之间交互完成任务	组合操作链，通过数据流动形成结果
代码结构	强调状态、属性、方法	强调函数组合、不可变数据
可读性	随复杂度增加容易出现嵌套、分支地狱	结构线性、链式表达更清晰
代码简洁度	较冗长，需要显式控制流程与状态	简洁，减少样板代码，专注逻辑
并发友好性	对象有状态，天生不利于并发	数据不可变，天然适配并发处理
适用场景	复杂业务模型、对象交互丰富的系统	大数据处理、集合计算、流式操作
优点	业务抽象强、结构稳定	表达力强、清晰高效、可并行执行
典型问题	嵌套地狱、过度封装	对初学者不够直观、调试链略难

Lambda表达式

概念

​ Lambda是JDK8中一个语法糖。他可以对某些匿名内部类的写法进行简化。它是函数式编程思想的一个重要体现。让我们不用关注是什么对象。而是更关注我们对数据进行了什么操作。

核心原则

可推导 可省略

(参数列表)->{代码}

案例

省略思路

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("你知道吗 我比你想象的 更想在你身边");
    }
}).start();

    public Thread(Runnable task) {
        this(null, null, 0, task, 0, null);
    }

@FunctionalInterface
public interface Runnable {
    /**
     * Runs this operation.
     */
    void run();
}

我们传参是接口，我们new是必须有实现类的

可以使用Lambda的格式对其进行修改。修改后如下：

    new  Thread( ()->{
            System.out.println("你知道吗 我比你想象的 更想在你身边");
        }).start();

我们不必关心对象，只需要再括号里面指定参数名字。

例二:

现有方法定义如下，其中IntBinaryOperator是一个接口。先使用匿名内部类的写法调用该方法。

   public static int calculateNum(IntBinaryOperator operator){
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }

applyAsInt实现这个实现相加

public static void main(String[] args) {
        int i = calculateNum(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });
        System.out.println(i);
    }

   int q=calculateNum((a,b)->{return a+b;});

另外一种

    public static void main(String[] args) {
        int i = calculateNum((int left, int right)->{
            return left + right;
        });
        System.out.println(i);
    }

例三：

现有方法定义如下，其中IntPredicate是一个接口。先使用匿名内部类的写法调用该方法。

public class test01 {

    public static void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if(predicate.test(i)){
                System.out.println(i);
            }
        }
    }
    public static void main(String[] args) {
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value%2==0;
            }
        });
    }
}

       printNum((value)->{return value%2==0;});

例四

现有方法定义如下，其中Function是一个接口。先使用匿名内部类的写法调用该方法。

  public static <R> R typeConver(Function<String,R> function){
        String str = "1235";
        R result = function.apply(str);
        return result;
    }
    public static void main(String[] args) {
        Integer result = typeConver(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });
        System.out.println(result);
    }

插播 泛型

泛型是什么（一句话）

让方法或类在不知道具体类型的情况下写代码，编译时再决定类型。

就像“可重复利用的模具”，放进去什么材料就产出对应的东西。

public static <R> R typeConver(Function<String,R> function)

<R>：泛型声明

R：返回类型

Function<String, R>：参数类型

必须声明泛型，不然还以为是什么类名字

开始优化

R apply(T t);

String result2=typeConver((s)->{return s;});

 float result2=typeConver((s)->{return Float.valueOf(s);});

编译器怎么做的

编译器从返回值处可以得到类型。然后再编译，当然勤奋的我怎么使用asm。

例五

  public static void foreachArr(IntConsumer consumer){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            consumer.accept(i);
        }
    }
    public static void main(String[] args) {
        foreachArr(new IntConsumer() {
            @Override
            public void accept(int value) {
                System.out.println(value);
            }
        });
    }

  foreachArr((a)->{System.out.println(a);});

当然还可以继续优化

foreachArr(System.out::println);

这样优化，实事求是的讲过于抽象了。但是工作中大家觉得代码没问题是可以快捷键进行最佳Lab的

恶心他人，强化自己

省略规则

• 参数类型可以省略
• 方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
• 方法只有一个参数时小括号可以省略
• 以上这些规则都记不住也可以省略不记