函数式接口

最新推荐文章于 2023-09-05 17:59:47 发布

heromps

最新推荐文章于 2023-09-05 17:59:47 发布

阅读量134

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/heromps/article/details/107645181

版权

java 专栏收录该内容

47 篇文章 0 订阅

订阅专栏

函数式接口

概念

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

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

格式

值要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 { 
  public abstract 返回值类型 方法名称(可选参数信息); 
  // 其他非抽象方法内容 
}

由于接口中抽象方法的public abstract是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionInterface{
  void myMethod();
}

@FunctionalInterface注解

与@Override注解的作用类似，java8中专门为函数式接口引入了一个新的注解：@FunctionalInterface。该注解可用于一个接口的定义上：

@FunctionalInterface
public interface MyFunctionInterface{
  void myMethod();
}

一旦未使用该注解来定义接口，编译期回强制检查该接口是否确实有且仅有一个抽象方法，否则报错。即使不适用一个注解，值要接口满足函数式接口的定义，这仍然是一个函数式接口。

自定义函数式接口

对于刚刚定义好的MyFunctionInterface函数式接口，典型使用场景就是作为方法的参数：

package demo.function;

public class Demo {
    //使用自定义的函数接口作为参数
    private static void doSomething(MyFunctionInterface myFunctionInterface){
        myFunctionInterface.myMethod();//调用自定义的函数接口
    }

    public static void main(String[] args) {
        doSomething(()-> System.out.println("Lambda执行啦！"));
    }
}

函数式编程

在兼容对象特性的基础上，java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。

Lambda延缓执行

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

性能浪费案例

日志可以加快帮助我们定位相关问题，记录程序运行过程中的情况，以便项目的监控和优化

一种典型的场景就是对参数进行有条件的使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

package demo.function;

public class DemoLogger {
    public static void log(int level, String msg){
        if(level==1){
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        String hero = "hero ";
        String msg = "msg ";
        String msg1 = "msg1 ";

        log(1,hero+msg+msg1);
    }
}

代码中的问题：无论级别是否满足要求，作为log方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别判断不符合要求，字符串的拼接操作就白做了，性能浪费

备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

Lambda优化

使用Lambda需要一个接口：

package demo.function;

@FunctionalInterface
public interface MessageBuilder {
    String buildMessage();
}

然后对log方法进行改造：

package demo.function;

public class DemoLogger {
    public static void log(int level, MessageBuilder msg){
        if(level==1){
            System.out.println(msg.buildMessage());
        }
    }

    public static void main(String[] args) {
        String hero = "hero ";
        String msg = "msg ";
        String msg1 = "msg1 ";

        log(1,()->hero+msg+msg1);
    }
}

如此一来，只有当级别满足要求的时候，才会进行三个字符串的拼接，否则三个字符串不会进行拼接

证明Lambda的延迟

代码如下：

package demo.function;

public class DemoLogger {
    public static void log(int level, MessageBuilder msg){
        if(level==1){
            System.out.println(msg.buildMessage());
        }
    }

    public static void main(String[] args) {
        String hero = "hero ";
        String msg = "msg ";
        String msg1 = "msg1 ";

        log(2,()->{
            System.out.println("Lambda执行");
            return hero+msg+msg1;
        });
    }
}

优化后，在不符合级别要求的情况下，Lambda将不会执行。从而节省性能。

使用Lambda作为参数和返回值

java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替换。使用Lambda表达式作为参数方法，其实就是使用函数式接口作为方法参数

例如java.lang.Runnable接口就是一个函数式接口，假如一个startThread方法使用该接口作为参数，那么可以使用Lambda进行传参。这种情况其实和Thread类的构造方法参数为Runnable没有本质区别

package demo.function;

public class DemoRunable {
    private static void startThread(Runnable task){
        new Thread(task).start();
    }

    public static void main(String[] args) {
        startThread(()-> System.out.println("线程任务执行了！"));
    }
}

类似的，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，可以调用该方法获取

package demo.function;

import java.util.Arrays;
import java.util.Comparator;

public class DemoComparator {
    private static Comparator<String> newCompatator(){
        return (a, b) -> b.length() - a.length();
    }

    public static void main(String[] args) {
        String[] arrays ={"ab","abc","abcd" };
        System.out.println(Arrays.toString(arrays));
        Arrays.sort(arrays,newCompatator());
        System.out.println(Arrays.toString(arrays));
    }
}

常用函数式接口

JDK中提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在java.util.functipn包中被提供

Supplier接口

java.util.function.Supplier<T>接口包含一个无参的方法：T get().用来获取一个泛型参数指定类型的对象数据i。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据

package demo.function;

import java.util.function.Supplier;

public class DemoSupplier {
    private static String getSupplier(Supplier<String> function){
        return function.get();
    }

    public static void main(String[] args) {
        String hello = "hello ";
        String mps = "mps";
        System.out.println(getSupplier(()->hello+mps));
    }
}

求数组元素最大值

题目

使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。要求：接口的泛型使用java.lang.Integer类

实现

package demo.function;

import java.util.function.Supplier;

public class DemoSupplier {
    private static Integer getSupplier(Supplier<Integer> function){
        return function.get();
    }

    public static void main(String[] args) {
      int[] array = {2,1,3,5,6,7,345,890};

      int maxNum = getSupplier(()->{
          //计算数组最大值
          int max =array[0];
          for (int i : array) {
              if(i > max){
                  max =i;
              }
          }
          return max;
      });
        System.out.println(maxNum);
    }
}

Consumer接口

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

抽象方法：accept

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

package demo.function;

import java.util.function.Consumer;

public class DemoConsumer {
    private static void consumerString(Consumer<String>consumer){
        consumer.accept("hello");
    }

    public static void main(String[] args) {
        consumerString(s-> System.out.println(s));
    }
}

默认方法：andThen

如果一个方法的参数和返回值全部都是Consumer类型，那么就可以实现效果：消费数据的时候，先做一个操作，然后在做一个操作，实现组合。这个方法就是Consuer接口中的default方法addThen，JDK源码：
```
default Consumer<T> andThen(Consumer<? super T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            this.accept(var2);
            var1.accept(var2);
        };
    }
```
注意：java.util.Objects的requireNonNUll静态方法将会在参数为null时主动抛出NullPointerException异常。省去了重复编写if语句和抛出空指针异常的麻烦

实现组合，需要两个或多个Lambda表达式即可，而addThen的语义正是“一步接一步”操作，例如两个步骤组合的情况：

package demo.function;

import java.util.function.Consumer;

public class DemoConsumerAndthen {
    private static void consumerString(Consumer<String>one,Consumer<String> two){
        one.andThen(two).accept("hello");
    }

    public static void main(String[] args) {
        consumerString(s -> System.out.println(s.toUpperCase()),s -> System.out.println(s.toLowerCase()));
    }
}

运行结果首先打印完全大写的HELLO，然后打印完全小写的hello。

格式化打印信息

题目
- 下面字符串中由很多信息，情按照格式“姓名：xx。性别：xx。”的格式将信息打印出来。要求将打印姓名的动作作为第一个Consumer接口的lambda实例，将打印性别的动作作为第二个Consumer接口的lambda实例，将两个Consumer接口按照顺序“拼接”到一起。

解答

package demo.function;

import java.util.function.Consumer;

public class DemoConsumerAndthen {
    private static void consumerString(Consumer<String>one,Consumer<String> two,String[] array){
        for (String s : array) {
            one.andThen(two).accept(s);
        }
    }

    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
        consumerString(s -> System.out.println("姓名："+s.split(",")[0]),s -> System.out.println("性别："+s.split(",")[1]),array);
    }
}

Predicate接口

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

抽象方法：test

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

package demo.function;

import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Predicate<String> predicate){
        boolean veryLong = predicate.test("helloWorld");
        System.out.println("字符串很长吗 "+veryLong);
    }

    public static void main(String[] args) {
        method(s -> s.length()>5);
    }
}

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。

例如判断一个字符串既要包含大写“H”，又要包含大写“w”，那么：

package demo.function;

import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Predicate<String> one,Predicate<String> two){
        boolean veryLong = one.and(two).test("helloWorld");
        System.out.println("字符串符合吗 "+veryLong);
    }

    public static void main(String[] args) {
        method(s -> s.contains("H"),s -> s.contains("W"));
    }
}

默认方法：or

默认方法or实现逻辑关系中的”或“

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不

变：

package demo.function;

import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Predicate<String> one,Predicate<String> two){
        boolean veryLong = one.or(two).test("helloWorld");
        System.out.println("字符串符合吗 "+veryLong);
    }

    public static void main(String[] args) {
        method(s -> s.contains("H"),s -> s.contains("W"));
    }
}

默认方法：nagate

”非“（取反）

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：

package demo.function;

import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Predicate<String> one){
        boolean veryLong = one.negate().test("helloWorld");
        System.out.println("字符串符合吗 "+veryLong);
    }

    public static void main(String[] args) {
        method(s -> s.length()<5);
    }
}

集合信息筛选

题目
- 数组当中由许多条”姓名+性别“的信息如下，通过Predicate接口的拼装，将符合要求的字符串筛选到集合ArrayList中，需要同时满足必须为女生，姓名为四个字

解答

package demo.function;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class DemoPredicate {
    private static List<String>  method(String[] Array,Predicate<String>one,Predicate<String>two){
        List<String> list = new ArrayList<>();
        for (String s : Array) {
            if (one.and(two).test(s)) {
                list.add(s);
            }
        }
        return list;
    }

    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        List<String> method = method(array, s -> "女".equals(s.split(",")[1]), s -> s.split(",")[0].length() == 4);
        System.out.println(method);
    }
}

Function接口

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

抽象方法：apply

Function接口中最主要的抽象方法为：R apply(T t),根据类型T的参数获取类型R的结果。

使用场景：将String类型转换为Integer类型。

package demo.function;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Function<String, Integer>function){
        Integer apply = function.apply("10");
        System.out.println(apply+20);
    }

    public static void main(String[] args) {
        method(s -> Integer.parseInt(s));
    }
}

默认方法：andThen

Function接口中由一个默认的andThen方法，用来进行组合操作

该方法用于先做什么，在做什么的场景

package demo.function;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class DemoPredicate {
    private static void method(Function<String, Integer>one,Function<Integer,Integer>two){
        Integer apply = one.andThen(two).apply("10");
        System.out.println(apply+20);
    }

    public static void main(String[] args) {
        method(s -> Integer.parseInt(s)+10,s -> s*10);
    }
}

自定义函数模型拼接

题目
- 使用Function进行函数的拼接，按照顺序需要执行的多个函数操作为：String str = “赵丽颖,20”;
- 将字符串截取数字年龄部分，得到字符串
- 将上一步的字符串转换为int类型的数字
- 将上一步的int数字累加100，得到结果int数字
解答

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class DemoPredicate {
    private static int  method(String str,Function<String, String>one,Function<String,Integer>two,Function<Integer,Integer>three){
        return one.andThen(two).andThen(three).apply(str);

    }

    public static void main(String[] args) {
        String str = "赵丽颖,20";
        int method = method(str, s -> s.split(",")[1], s -> Integer.parseInt(s), s -> s + 100);
        System.out.println(method);
    }
}

heromps

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
函数式接口

函数式接口概念函数式接口在java中指的是，有且只有一个抽象方法的接口函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现的式Lamda，所以函数式接口就是可以适用于Lamda使用的接口。只有确保接口中有且仅有一个抽象方法，java中的Lamda才能顺利地进行推到格式值要确保接口中有且仅有一个抽象方法即可：修饰符 interface 接口名称 { public abstract 返回值类型方法名称(可选参数信息); // 其他非抽象方法内容 }由于接口中抽象
复制链接

扫一扫