Java函数式编程与泛型用法

jdk都更新到21了，java8的函数式编程到底理解没

解耦

首先讲一个编程的原则，解耦。这个概念都说烂了，但是具体怎么做呢。

解耦其实就是解除依赖。

想想十几年前百花齐放的手机充电线，到现在的Type-C，对消费者的好处就是不用带一大堆不同的充电线了，对企业的好处就是不用为生产特定的接口改生产线。

说回到代码上，要怎么解除依赖，解除什么依赖。

简化代码，就是把逻辑和控制分开

先说总结，函数式解决对于状态的依赖，泛型，解决对于类型的依赖。都是对于控制的操作
逻辑，就是指业务逻辑。与语言无关

下面举个例子说明什么是函数式编程，他是如何解除对状态的依赖(说明函数式编程的优势)

函数式编程

它的理念就来自于数学中的代数。

大家耳熟能详的斐波那契数列的函数式表示如下

f(x)=f(x-1)+f(x-2)

对于函数式编程来说，它只关心定义输入数据和输出数据相关的关系，对应数学自变量和应变量。

有状态和无状态

累加

// 非函数式，有状态
int cnt =0;
public void increment(){
    cnt++;
}

纯函数累加

如果写成纯函数，应该是下面这个样子。

// 函数式，无状态
public int increment(int cnt){
    return cnt+1;
}

这个是你传给我什么，我就返回这个值的 +1 值，你会发现，代码随便拷，而且与线程无关，代码在并行时候不用锁，因为是复制了原有的数据，并返回了新的数据。

字符串处理

再给一个稍微复杂一点的例子

找出偶数；乘以 3；转成字符串返回。

版本1 非函数式

平铺直叙的代码

import java.util.ArrayList;
import java.util.List;

public class Example {
    // 定义一个函数 process，处理偶数并返回字符串
    public static String process(int num) {
        // 过滤掉非偶数
        if (num % 2 != 0) {
            return null;
        }
        num = num * 3;
        String result = String.format("The Number: %d", num);
        return result;
    }

    // 测试函数
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 处理列表中的元素
        List<String> results = new ArrayList<>();
        for (int num : nums) {
            String result = process(num);
            if (result != null) {
                results.add(result);
            }
        }
        // 输出结果
        for (String result : results) {
            System.out.println(result);
        }
    }
}

我需要手动维护nums的数据，代码阅读上如果没有注释，你也会比较晕。

版本2：函数式代码

public class Example {
    // 定义一些函数，用于过滤和映射元素
    public static Predicate<Integer> even_filter = num -> num % 2 == 0;
    public static Function<Integer, Integer> multiply_by_three = num -> num * 3;
    public static Function<Integer, String> convert_to_string = num -> String.format("The Number: %d", num);

    // 测试函数
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 过滤元素，映射元素，输出结果
        nums.stream()
                .filter(even_filter)
                .map(multiply_by_three)
                .map(convert_to_string)
                .forEach(System.out::println);
    }
}

看着是不是有点眼熟，那么这段代码还可以简化

版本3 最简化版函数式代码

import java.util.Arrays;
import java.util.List;

public class Example {
    // 测试函数
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 过滤元素，映射元素，输出结果
        nums.stream()
            .filter(num -> num % 2 == 0)
            .map(num -> num * 3)
            .map(num -> String.format("The Number: %d", num))
            .forEach(System.out::println);
    }
}

突然间的释怀，好家伙这不就是lambda表达式吗，函数式接口跑哪去了，点进去.map接口看源码

/**
     * Returns a stream consisting of the results of applying the given
     * function to the elements of this stream.
     *
     * 
This is an intermediate
     * operation.
     *
     * @param  The element type of the new stream
     * @param mapper a non-interfering,
     *               stateless
     *               function to apply to each element
     * @return the new stream
     */
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

入参其实就是版本2写的函数式接口

减少代码函数只是运用函数式接口附带的，它的主要优势是

特征一、stateless： 函数不维护任何状态。函数式编程的核心精神是 stateless，比如上面filter 操作只考虑当前元素的状态，即判断当前元素是否为偶数，不需要考虑其他元素或外部状态的影响，简而言之就是它不能存在状态，打个比方，你给我数据我处理完扔出来。里面的数据是不变的。

特征二、immutable： 输入数据是不能动的，动了输入数据就有危险，所以要返回新的数据集。

这两个特征带来的效果就是并行无风险。

在累加的例子中，如果有外部变量也操作了cnt的值，程序固定输入就可能得到不同输出，是有风险的。

函数方法的用法

apply()

apply() 方法是 Java 8 中 Function 接口中的一个方法，它接受一个参数，然后将这个参数应用到函数中，返回一个结果。

public double doubleNumber(int a) {
    return a * 2.0;
}

public void fun2() {
    // 将 doubleNumber 方法作为参数传递给 Function 接口的实现
    Function<Integer, Double> doubleFunc = this::doubleNumber;
		// Function doubleFunc = a -> a * 2.0; 等价

    // 应用函数，得到结果 20
    System.out.println(doubleFunc.apply(10));
}

andThen()

下面是一个更复杂的例子，用于解释 apply()和 andThen()方法的用法：

复制代码
public void fun() {
    // 定义一个 Function 对象，用于将字符串转换为整数
    Function<String, Integer> strToInt = s -> Integer.parseInt(s);

    // 定义一个 Function 对象，用于将整数加倍
    Function<Integer, Integer> doubleInt = i -> i * 2;

    // 定义一个 Function 对象，将字符串转换为整数并加倍
    Function<String, Integer> strToDoubleInt = strToInt.andThen(doubleInt);

    // 将字符串 "10" 应用到 strToDoubleInt 函数中，得到结果 20
    Integer result = strToDoubleInt.apply("10");

    // 输出结果20
    System.out.println(result);
}

andThen() 方法将 strToInt 和 doubleInt 两个函数串联起来得到了一个新的Function。

compose()

它返回一个组合函数，其中参数化函数将首先执行，然后是第一个函数。如果任一函数的计算抛出错误，则会将错误转发给组合函数的调用者。

我理解就是在出入参相同的时候简化了andThen用法

public class Example {
    public static void main(String args[]){
        Function<Integer, Integer> strToInt = s -> s+1 ;
        strToInt = strToInt.compose(i -> i * 2);

        System.out.println(strToInt.apply(10));
    }
}

出入参不同的示例

import java.util.function.Function;

// Main class
public class Example {

	// Main driver method
	public static void main(String args[]){
		Function<Integer, Double> half = a -> a / 2.0;
		Function<String, Integer> strToInt = s -> Integer.parseInt(s);
		strToInt = strToInt.compose(i -> i * 2);

		System.out.println(half.apply("10"));
	}

    // 定义一个 Function 对象，用于将字符串转换为整
}7.5

identity()

此方法返回一个函数，该函数返回其唯一的参数。

// Java Program to Illustrate identity() method

// Importing Function interface
import java.util.function.Function;

// Main class
public class Example {

	// Main driver method
	public static void main(String args[])
	{
		Function<Integer, Integer> i = Function.identity();

		// 输出10
		System.out.println(i.apply(10));
	}
}

你说，不就原值返回这玩意能有啥用呢

结合示例

把list