java函数式接口意义与场景

Posted 2023-03-09 纸绘

前言

想到记录下这篇主要是两个原因，1. 虽然自己很早就接触了函数式接口，但是基本没有深入探究过使用场景。2. 工作中接触了越来越多场景后，感觉对函数式接口有更多使用需求，能很好的美化自己代码（少写几行），并提高自己代码复用率。 

首先问问题：什么是函数式接口？为什么要使用函数式接口？什么场景下使用函数式接口？

        简单的一句话：函数式接口只是仅含一个未实现的方法的接口。      

        当你写业务代码发现越来越多重复的时候，就应该好好考虑要提取抽象逻辑，如果你暂时没有这个感觉，建议多写点代码或者把《clean code》看一遍。。总而言之，消除重复的正确用法应该是 我定规矩 -> 别人实现规矩 -> 别人造对象 -> 我用那个对象。从这个意义上说，任何接口都应该看作是广义的函数式接口。 函数式接口对于抽象逻辑是一个很好使的工具，允许将函数作为参数使用，java8之前是使用匿名类来实现的这点，但是匿名类写起来实在是太丑了。

一个简单case

        leetcode 239. 滑动窗口最大值 一题中，使用到了一个优先队列大顶堆的定义写法，如果使用匿名类的话，代码就是下面这样：

class Solution 
    public int[] maxSlidingWindow(int[] nums, int k) 
        int n = nums.length;
        PriorityQueue<int[]> queue = new PriorityQueue<int[]>(
            new Comparator<int[]>() 
                   public int compare(int[] p1, int[] p2) 
                   // 大顶堆是 p2 - p1, 小顶堆是 p1 - p2
                   return p1[1] != p2[1] ? p2[1] - p1[1] : p2[0] - p1[0];
                   
            
        );
        int[] result = new int[n - k + 1];
        for (int i = 0; i < k; i++) 
            int[] p = new int[]i, nums[i];
            queue.offer(p);
        
            
        for (int i = k - 1; i < n; i++) 
            if (i - k + 1 > 0) 
                queue.offer(new int[]i, nums[i]);
            
            while (queue.peek()[0] < i - k + 1) 
                queue.poll();
             
            result[i- k + 1] = queue.peek()[1];
        

        return result;
    

如果使用了函数式接口，这部分定义代码就简化了成了一行

        PriorityQueue<int[]> queue = new PriorityQueue<int[]>(
            (p1, p2) -> p1[1] != p2[1] ? p2[1] - p1[1] : p2[0] - p1[0]
        );

可以看下java doc 里 对于 Comparator 接口的定义，这里就是很典型的函数式接口，从另一方面说，也是扩展代码可复用性的一个例子（用一个比较器接口作为优先队列的构造参数，使得优先队列定义更加灵活）

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

// 这个注解只是对函数式接口做检查， 不写也可以
@FunctionalInterface
public interface Comparator<T> 
    
    int compare(T o1, T o2);

    // ... 其他都是非抽象函数

函数式接口概念详细说明：

自己详细把所有的相关概念都写出来太麻烦，找了一个写的比较好的博文贴下面，原始链接可以参考：详解JAVA8函数式接口全 - ---dgw博客 - 博客园

主要语法:

1.  () -> 代表了 lambda的一个表达式
2.  单行代码无需写return (无论函数式接口有没有返回值),花括号
3.  多行代码必须写花括号,有返回值的一定要写返回值
4.  单行代码且有参数的情况下可以不写 ()   如  s->System.out.println(s)
5.  (T t)中的参数类型可写可不写

1: 函数式接口

1.1 概念

函数式接口在java中是指: 有且仅有一个抽象方法的接口

函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖"是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

1.2 格式

接口中只能存在一个抽象方法

修饰符 interface 接口名称
    public abstract 返回值 方法名称(参数列表)
    // 其他方式 

// public abstract 可以不写 编译器自动加上
修饰符 interface 接口名称
       返回值 方法名称(参数列表)
    // 其他方式 

1.3@FunctionalInterface注解

@FunctionalInterface // 标明为函数式接口
public abstract MyFunctionInterface
    void mrthod(); //抽象方法

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。(该接口是一个标记接口)

1.4 调用自定义函数接口

public class Test_Functional 
    // 定义一个含有函数式接口的方法
    public static void doSomthing(MyFunctionalInterface functionalInterface) 
        functionalInterface.mehod();//调用自定义函数式接口的方法
    
    public static void main(String[] args) 
        //调用函数式接口的方法
        doSomthing(()->System.out.println("excuter lambda!"));
    

2:函数式编程

2.1:lambda的延迟执行

 有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

性能浪费的日志案例

注：日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。一种典型的场景就是对参数进行有条件使用，

例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class Demo01Logger 
    private static void log(int level, String msg) 
        if (level == 1) 
            System.out.println(msg);
        
     
    public static void main(String[] args) 
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, msgA + msgB + msgC);//级别1 不一定能够满足 但是 字符串连接操作还是执行了 那么字符串的拼接操作就白做了，存在性能浪费
    

备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数(包装为数组)传入方法中，

仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug("变量的取值为。", "os", "macOS") ，其中的大括号  为占位符。如果满足日志级别要求，

则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

体验Lambda的更优写法

@FunctionalInterface
public interface MessageBuilder 
    String buildMessage();

public class Demo02LoggerLambda 
    private static void log(int level, MessageBuilder builder) 
        if (level == 1) 
            System.out.println(builder.buildMessage());// 实际上利用内部类 延迟的原理,代码不相关 无需进入到启动代理执行
        
    
    public static void main(String[] args) 
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
       log(2,()->
                System.out.println("lambda 是否执行了");
                return msgA + msgB + msgC;
        );
    

2.2 使用Lambda作为参数和返回值#

假设有一个 方法使用该函数式接口作为参数，那么就可以使用Lambda进行传参.如线程中的Runable接口

public class Runnable 
    private static void startThread(Runnable task) 
            new Thread(task).start();
    
    public static void main(String[] args) 
            startThread(() ‐> System.out.println("线程任务执行！"));
    

如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式(类始于new 内部类的实现方式 方法中可以实现构造内部类)

public class lambda_Comparator 
    //下面给出 lambda 以及实际替代的内部类写法
    private static Comparator<String> newComparator()
        return (a,b)->b.length()-a.length();
    
    private static Comparator<String> newComparator1()
        return new Comparator<String>() 
            @Override
            public int compare(String a, String b) 
                return b.length()-a.length();    
            
        ;
    
    public static void main(String[] args) 
        String[] array="abc","ab","abcd";
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, newComparator1()); // 方式一
        Arrays.sort(array,(a,b)->b.length()-a.length());//更简单的方式
        System.out.println(Arrays.toString(array));
    

3:常用函数式接口

3.1 Supplier接口(供应接口)

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，

这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

public class Test_Supplier 
    private static String test_Supplier(Supplier<String> suply) 
        return suply.get(); //供应者接口
    
    public static void main(String[] args) 
         // 产生的数据作为 sout 作为输出
         System.out.println(test_Supplier(()->"产生数据"));
         
         System.out.println(String.valueOf(new Supplier<String>() 
             @Override
            public String get() 
                return "产生数据";
            
        ));
    

3.2 练习：求数组元素最大值

public class use_Supplier_Max_Value 
    private static int getMax(Supplier<Integer> suply) 
        return suply.get();
    
    public static void main(String[] args) 
        Integer [] data=new Integer[] 6,5,4,3,2,1;
        int reslut=getMax(()->
            int max=0;
            for (int i = 0; i < data.length; i++) 
                max=Math.max(max, data[i]);
            
            return max;
        );
        System.out.println(reslut);
    

3.3 Consumer接口

java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

public class Test_Comsumer 
    public static void generateX(Consumer<String> consumer) 
        consumer.accept("hello consumer");
    
    public static void main(String[] args) 
        generateX(s->System.out.println(s));
    

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合

default Consumer<T> andThen(Consumer<? super T> after) 
    Objects.requireNonNull(after);
    return (T t) ‐>  accept(t); after.accept(t); ; 
    //1:  返回值为Consumer 那么需要 ()-> 表示函数式接口
    //2:  accept(t);为生产一个数据供应给 (T t)中的t
    //3:  after.accept(t);为利用这个t再次生成新的函数式接口 实现类始于builder的设计模式

3.4 练习：格式化打印信息

 请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来

public class use_Consumer_FormattorName 
    public static void formattorPersonMsg(Consumer<String[]> con1, Consumer<String[]> con2) 
        // con1.accept(new String[] "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" );
        // con2.accept(new String[] "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" );
        // 一句代码搞定
        con1.andThen(con2).accept(new String[]  "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" );
    
    public static void main(String[] args) 
        formattorPersonMsg((s1) -> 
            for (int i = 0; i < s1.length; i++) 
                System.out.print(s1[i].split("\\\\,")[0] + " ");
            
        , (s2) -> 
            System.out.println();
            for (int i = 0; i < s2.length; i++) 
                System.out.print(s2[i].split("\\\\,")[1] + " ");
            
        );
        System.out.println();
        printInfo(s->System.out.print(s.split("\\\\,")[0]),
                  s->System.out.println(","+s.split("\\\\,")[1]),datas);
    
    // 自身自销 有意思
    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) 
        for (String info : array)  // 这里每次产生 迪丽热巴。性别：女  String 数据 逻辑那边顺序处理就行
            one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。  
        
    

3.5 Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口

 (s)->  函数式接口有参数 表示有有产生数据

 (s)-> 具体的返回数据 看要是否原函数式接口给出了

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

默认方法：and or nagte (取反)

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实

现“并且”的效果时,类始于 Consumer接口 andThen()函数 其他三个雷同

default Predicate<T> and(Predicate<? super T> other) 
    Objects.requireNonNull(other); 
    return (t) ‐> test(t) && other.test(t);

判断字符串是否包含o h 的and or not

   

public class Use_Predicate 
    // 判断字符串是否存在o  即使生产者 又是消费者接口
    private static void method_test(Predicate<String> predicate) 
         boolean b = predicate.test("OOM SOF");
         System.out.println(b);
    
    // 判断字符串是否同时存在o h 同时
    private static void method_and(Predicate<String> predicate1,Predicate<String> predicate2) 
        boolean b = predicate1.and(predicate2).test("OOM SOF");
        System.out.println(b);
    
    //判断字符串是否一方存在o h 
    private static void method_or(Predicate<String> predicate1,Predicate<String> predicate2) 
        boolean b = predicate1.or(predicate2).test("OOM SOF");
        System.out.println(b);
    
    // 判断字符串不存在o 为真   相反结果
    private static void method_negate(Predicate<String> predicate) 
         boolean b = predicate.negate().test("OOM SOF");
         System.out.println(b);
    
    public static void main(String[] args) 
        method_test((s)->s.contains("O"));
        method_and(s->s.contains("O"), s->s.contains("h"));
        method_or(s->s.contains("O"), s->s.contains("h"));
        method_negate(s->s.contains("O"));
    

静态方法：not  isEquals

返回值为Predicate<T> 说明最终由tets为最终处理结果

 static <T> Predicate<T> not(Predicate<? super T> target) 
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    

boolean b = Predicate.not((String s)->s.contains("J")).test("Java"); // 直接构造lambda 断言可能包
    // 使用静态方法判断是否为同一个对象
    private static void method_isEqual(Predicate<String> predicate) 
        boolean b = Predicate.isEqual(predicate).test(predicate);
        System.out.println(b);
    

3.6 练习：集合信息筛选

请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合

ArrayList 中，需要同时满足两个条件：

1. 必须为女生；

2. 姓名为4个字。

/**
     * 1. 必须为女生； 
     * 2. 姓名为4个字。
     */
    public static void main(String[] args) 
        String[] array =  "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" ;
        getFemaleAndname((s) -> s.split("\\\\,")[0].length() == 4, 
                (s) -> s.split("\\\\,")[1].equals("女"), array);
    
    private static void getFemaleAndname(Predicate<String> one,
            Predicate<String> two, String[] arr) 
        for (String string : arr) 
            if (one.and(two).test(string)) 
                System.out.println(string);
            
        
    

3.7 Function接口

 java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件

        将T 转为 R

 // 将数字转换为String类型
    private static void numberToString(Function<Number, String> function) 
        String apply = function.apply(12);
        System.out.println("转换结果:"+apply);
    
    public static void main(String[] args) 
        numberToString((s)->String.valueOf(s));
    

默认方法 andThen  compose():

Function 接口中有一个默认的 andThen  compose方法，用来进行组合操作。JDK源代码如：

  default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) 
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));// 先执行调用者,再执行after的apply犯法
       // 这里的V 一个是作为输入值 一个是作为输出值  按照调用的顺序的不同 对于 T V 做输入 输出的顺序也不同 注意看
     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) 
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));// 后执行before的apply方法,后执行调用者apply方法
    

    注意调用的先后顺序

// 静态方法
    private static void method_andThen(Function<Integer, Integer> f1,Function<Integer, Integer> f2) 
        Integer apply = f1.andThen(f2).apply(2);
        System.out.println(apply);
    
    private static void method_compose(Function<Integer, Integer> f1,Function<Integer, Integer> f2) 
        Integer apply = f1.compose(f2).apply(2);
        System.out.println(apply);
    
    public static void main(String[] args) 
        numberToString((s)->String.valueOf(s));
        method_andThen(s->s+1, s->s=s*2);//6
        method_compose(s->s+1, s->s=s*s);//5
    

静态方法  identity

输入对象就是输出对象

//返回一个执行了apply()方法之后只会返回输入参数的函数对象
        Object apply = Function.identity().apply(2);
        System.out.println(apply);

3.8 练习：自定义函数模型拼接

题目

请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：

String str = "赵丽颖,20";

1. 将字符串截取数字年龄部分，得到字符串；

2. 将上一步的字符串转换成为int类型的数字；

3. 将上一步的int数字累加100，得到结果int数字。

MainString str = "赵丽颖,20";
        solotion(s->s.split("\\\\,")[1],s->Integer.parseInt(s),s->s+=100,str);
    

    private static void solotion(Function<String, String> o1, Function<String, 
            Integer> o2, Function<Integer, Integer> o3, String str) 
            Integer apply = o1.andThen(o2).andThen(o3).apply(str);
            System.out.println(apply);
    

4.扩展函数接口

　　扩展函数接口太多了, 但是掌握了基本的五大函数接口,相信你 其他函数接口都能够掌握,下面有时间会更新相关函数接口的用法

4.1: Operator 相同类型互相转换的接口

　　 BinaryOperator<Integer>的andthen() 方法不支持两个链接操作 也就是不需要再次BinaryOperator<Integer> 因为源代码规定不允许使用两次输入

// 单个同类型操作
        UnaryOperator<String> u_str=(s)->s.split(" ")[0];
        UnaryOperator<String> u_str1=(s)->s.concat(" ok");
        
        String apply = u_str.andThen(u_str1).apply("lambda Ok");
        System.out.println(apply);
        String apply1 = u_str.compose(u_str1).apply("lambda Ok");
        System.out.println(apply1);
        // 两个同类型操作
        BinaryOperator<Integer> way_add=(k,v)->k+v;
        BinaryOperator<Integer> way_mul=(k,v)->k*v;
        
        Integer res1 = way_add.apply(1,2);
        Integer res2 = way_mul.apply(1,2);
        System.out.println(res1);
        System.out.println(res2);
        
        Function<Integer, Integer> x=(k)->k*2;
        //注意不允许 way_add.andThen(way_mul).apply(1,2); andThen需要的是Function
        Integer apply2 = way_add.andThen(x).apply(1,2);
        System.out.println(apply2);
        
        // 最大值 最小值 (这里不能连续写 连U型apply 要报错)
        BinaryOperator<Integer> bi_max = BinaryOperator.maxBy(Comparator.naturalOrder());
        BinaryOperator<Integer> bi_min = BinaryOperator.minBy(Comparator.naturalOrder());
        
        Integer res3 = bi_max.apply(2, 3);
        Integer res4 = bi_max.apply(3, 2);
        System.out.println(res3);
        System.out.println(res4);