java 函数式接口 详解

最新推荐文章于 2024-04-06 22:58:30 发布
最新推荐文章于 2024-04-06 22:58:30 发布
阅读量794 收藏 3
点赞数 1
分类专栏： Java 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45519487/article/details/105761509
版权

1.函数式接口

1.1 概念

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

      函数式接口，就是适用于函数式编程场景的接口。在java中函数式编程就体现在Lambda，因此函数式接口就是能够适用于lambda使用的接口。只有确保接口中有且仅有一个抽象方法，lambda才能进行顺利的推导。

1.2 格式

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

       因为接口中抽象方法的修饰符可以省略。例；

public interface MyFunctionalInterface {
           void myMethod();
}

  1.3 @FunctionalInterface注解

      此注解和@override注解的作用类似。该住处应用于函数式接口的定义上。

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

    一旦使用了该注解来定义函数式接口，编译器就会检查该接口是否是有且仅有一个抽象方法。

1.4 自定义函数式接口

    将函数式接口作为方法的参数。

public class Demo {
    private static void dos(FunctionInterface fi){
        fi.method();
    }

    public static void main(String[] args) {
        Demo.dos(()->{System.out.println("lambda表达式");});
    }
}

  

2.函数式编程

2.1 lambda的延迟执行

   有些代码执行后，结果不一定会被使用，进而就是造成资源的浪费，lambda表达式是延迟执行的，这就可以可以解决这种资源浪费的问题。

  性能浪费的日志案例：

     日志可以帮助我们快速的解决定位的问题，记录长须过程中的情况，以便瞠目的监控和优化。

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

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 m="你好";
        String s="日志";
        String g="吗？";
        log(1,m+s+g);
    }
}

   这段代码就存在资源浪费的问题，因为不管level是够满足要就，系统会都会把这三个字符串拼接起来，作为参数，传到方法中。

   lambda表达式的更优写法

     lambda表达式的使用前提必须要有函数式接口。

public class DemoLogger1 {
    private static void log(int level,Message msg){
        if(level==1){
            System.out.println(msg.pinjie());
        }
    }

    public static void main(String[] args) {
        String m="你好";
        String s="日志";
        String g="吗？";
        log(1,()->{return m+s+g;});
    }
}

     这个代码只有在level满足要求时，才会对三个字符串进行拼接。

验证Lambda表达式的延迟性

public class DemoLogger1 {
    private static void log(int level,Message msg){
        if(level==1){
            System.out.println(msg.pinjie());
        }
    }

    public static void main(String[] args) {
        String m="你好";
        String s="日志";
        String g="吗？";
        log(2,()->{
            System.out.println("lambda表达式执行了");
            return m+s+g;});
    }
}

   从上述代码可以看出，level不满足条件，lambda表达式没有执行。

2.2 lambda表达式作为参数和返回值

   lambda表达式的原理实际上就是匿名对象。如果方法的参数是一个函数接口，那就该函数接口就可以被lambda表示替代。

  例如：java.lang.Runnable接口就是一个函数式接口。现在有一个方法使用该接口作为参数，那么就可以使用lambda表示进行提到。

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

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

 如果一个方法的返回值类型是函数式接口，那么就可以直接返回一个lambda表达式。

   例如，需要一个方法来获取java.util.Comparator接口类型的对象作为排序器时候，就可以调用该方法获取。

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

    public static void main(String[] args) {
        String[] arr={"abc","acvd","a"};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr,newComparator());
        System.out.println(Arrays.toString(arr));
    }
}

3.常用函数式接口

3.1 Supplier接口

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

public class DemoSupplier {
    private static String getstring(Supplier<String> supplier){
        return supplier.get();
    }
    public static void main(String[] args) {
        String msg="你好";
        String getstring = getstring(() -> { return msg; });
        System.out.println(getstring);
    }
}

3.2 练习:求数组元素的最大值

      使用Supplier接口作为方法的参数，通过lambda表达式求出int数组中的最大值。

public class DemoSupplier {
    private static int getmax(Supplier<Integer> supplier){
        return supplier.get();
    }
    public static void main(String[] args) {
        int[] arr={1,3,4,6,9};
       Integer getmax = getmax(() -> {
           int max=arr[0];
           for (int i = 0; i < arr.length; i++) {
               if(max>arr[i]){
                   max=max;
               }else{
                   max=arr[i];
               }
           }
           return max;
        });
        System.out.println(getmax);
    }
}

3.3 Consumer接口

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

  抽象方法：accept

    Consumer接口中包含抽象方法void accpet(T t),消费一个指定的泛型。

public class Democonsume {
    private static void consunmerString(Consumer<String> f){
        f.accept("你好");
    }

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

    默认方法：andThen

    如果一个方法的参数和返回值都是Consumer类型。 那么在消费数据时，会做一个操作，然后在做一个操作，实现组合。这个方法就是Consumer接口中的default方法andThen。

   要实现组合，就需要两个或者多个lambda表达式，andThen的语义就是一步一步的执行；

public class DemoandThen {
    private static void consumerstring(Consumer<String> c1,Consumer<String> c2){
        c1.andThen(c2).accept("nihao");
    }

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

     运行结果是先输出大写的nihao,然后打印小写的nihao。

3.4 格式化打印

        下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。”的格式将信息打印出来。要求将打印姓名的动作作为第一个Consumer 接口的Lambda实例，将打印性别的动作作为第二个Consumer 接口的Lambda实例，将两个Consumer 接口按照顺序“拼接”到一起。

public class DemoandThen {
    private static void consumerstring(Consumer<String> c1,Consumer<String> c2,String[] arr){
        for (String s : arr) {
            c1.andThen(c2).accept(s);
        }

    }

    public static void main(String[] args) {
        String[] arr={"路飞，男","娜美，女","索隆，男","乔巴，动物"};
        consumerstring(s -> System.out.print(s.split("，")[0]+"性别："),
                       s -> System.out.println(s.split("，")[1]),
                       arr);
    }
}
路飞性别：男
娜美性别：女
索隆性别：男
乔巴性别：动物

  3.5 Predicate接口

       java.util.function.Predicate<T> 接口，对某种类型的数据进行判断，从而得到一个boolean值结果。

 抽象方法：test

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

public class DemoPredicate {
    public static void predicate(Predicate<String> predicate){
        boolean test = predicate.test("我是字符串");
        System.out.println(test);
    }

    public static void main(String[] args) {
        predicate(s->s.length()>3);
    }
}
true

       条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于3则true.

默认方法：and

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

public class DemoPredicate {
    public static void predicate(Predicate<String> p1,Predicate<String> p2){
        boolean test = p1.and(p2).test("我是字符串");
        System.out.println(test);
    }

    public static void main(String[] args) {
        predicate(s->s.length()>3,
                  s->s.length()<6);
    }
}
true

     默认方法：or

                  与and方法同类型

public class DemoPredicate {
    public static void predicate(Predicate<String> p1,Predicate<String> p2){
        boolean test = p1.or(p2).test("我是字符串");
        System.out.println(test);
    }

    public static void main(String[] args) {
        predicate(s->s.length()>3,
                  s->s.length()>6);
    }
}
true

  默认方法：negate

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

public class DemoPredicate {
    public static void predicate(Predicate<String> p1){
        boolean test = p1.negate().test("我是字符串");
        System.out.println(test);
    }

    public static void main(String[] args) {
        predicate(s->s.length()>3
                  );
    }
}
false

   3.6 集合信息筛选

     数组当中有多条“姓名+性别”的信息如下，请通过Predicate 接口的拼装将符合要求的字符串筛选到集合ArrayList 中，需要同时满足两个条件：

                    1. 必须为女生；

                    2. 姓名为4；

public class DemoPredicate {
    public static ArrayList<String> predicate(Predicate<String> p1, Predicate<String> p2, String[] arr){
        ArrayList<String> a=new ArrayList<>();
        for (String s : arr) {
            if(p1.and(p2).test(s)){
                a.add(s);
            }
        }
        return a;
    }

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

3.7 Function 接口

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

     抽象方法：apply

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

     例如:将String类型转换成Integer类型。

public class DemoFunction {
    public static void method(Function<String,Integer> f){
        Integer apply = f.apply("100");
        System.out.println(apply);
    }

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

  默认方法：andThen

      Function 接口中有一个默认的andThen 方法，用来进行组合操作，该方法同样用于“先做什么，再做什么”的场景，和Consumer 中的andThen 差不多：

public class DemoFunction {
    public static void method(Function<String,Integer> f1,Function<Integer,Integer> f2){
        Integer apply = f1.andThen(f2).apply("100");
        System.out.println(apply);
    }

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

    3.8 自定义函数模型拼接

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

              String str = "赵丽颖,20";

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

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

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

public class DemoFunction {
    public static int method(Function<String,String> f1,
                             Function<String,Integer> f2,
                             Function<Integer,Integer> f3,String str){
        return f1.andThen(f2).andThen(f3).apply(str);
    }

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

  

         

 

 

 

 

 

 

     

  

 

王胖子总叫我减肥
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java之函数式接口(FunctionalInterface)
我的博客
12-03 5067
Java之函数式接口 FunctionalInterface
Java函数式接口详解
05-24
Java函数式接口详解
Java 函数式接口
sokenna的博客
08-14 5842
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
【Java 基础篇】Java函数式接口详解
繁依Fanyi的博客
09-23 611
函数式接口是指仅包含一个抽象方法的接口。在Java中，函数式接口用注解来标识，这个注解不是强制性的，但建议使用它来确保接口符合函数式接口的定义。函数式接口的关键特点是可以被Lambda表达式所实现。Lambda表达式是一种紧凑的语法，用于创建匿名函数，从而更容易地传递函数行为作为参数。函数式接口与Lambda表达式结合使用，可以实现更简洁和可读性强的代码。在这个示例中，Calculator是一个函数式接口，因为它只包含一个抽象方法calculate。
ElasticSearch、java的四大内置函数式接口、Stream流、parallelStream背后的技术、Optional类
qq_21698517的博客
03-26 1322
第四周笔记 一、ElasticSearch 1.安装 apt-get install lrzsz adduser -m es 创建用户组： useradd *-m* xiaoming(用户名) *PS：追加参数-m* passwd xiaoming(用户名) passwd xiaoming 输入新的 UNIX 密码： 重新输入新的 UNIX 密码： passwd：已成功更新密码 最大文件描述符数（max file descriptors）太低，需要增加至少到65535。 ulimit -Hn 65536
深入理解Java函数式接口
m0_50033700的博客
08-15 496
本文介绍了函数式编程在Java中的作用和重要性。首先解释了函数式接口的定义和特点，以及与Lambda表达式的关系。然后列举了Java中常用的函数式接口，包括Predicate、Function、Consumer和Supplier，并介绍了它们的用途和示例代码。最后，强调了函数式编程在Java中的应用价值和重要性。
Java基础篇--函数式接口
weixin_61500949的博客
05-27 4283
一、函数式接口概述： 1.函数式接口：有且仅有一个抽象方法的接口，java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口有且仅有一个抽象方法，java中的Lambda才能顺利的进行推导 二、如何检测一个接口是不是函数式接口呢？ 1.@FunctionalInterface 2.放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 @FunctionalInterface public interfaceSum
实例详解Java8函数式接口
08-28
Java8 函数式接口实例详解 Java8 中引入了函数式接口的概念，函数式接口是一个只有一个抽象方法的接口，它可以使用 Lambda 表达式或方法引用来创建实例。函数式接口的出现使得 Java8 的编程模型更加灵活和强大。...
详解JAVA8 函数式接口
08-18
JAVA8 函数式接口详解 JAVA8 函数式接口是JAVA8中的一种重要特性，它提供了一些常用的函数式接口，极大的提高了我们的开发效率。在本文中，我们将详细介绍JAVA8 函数式接口的相关知识点，包括四大核心函数式接口和...
Java函数式接口Supplier接口实例详解
08-25
Java 函数式接口 Supplier 接口实例详解 Java 函数式接口 Supplier 接口实例详解是 Java 函数式编程中一个非常重要的概念。Supplier 接口是 Java 中的一种函数式接口，主要用来提供对象数据的获取。该接口只有一个...
详解JAVA 函数式编程
08-18
JAVA 8 中引入了函数式编程的概念，提供了函数式接口、Lambda 表达式和方法引用等特性。 函数式接口是 JAVA 函数式编程的核心概念。函数式接口是指只有一个抽象方法的接口。函数式接口可以被用作Lambda 表达式的...
Java进阶—函数式接口
weixin_42214237的博客
02-09 2117
一、函数式接口 函数式接口在Java中是指：有且仅有一个抽象方法的接口，接口中可以包含其他的方法（默认，静态，私有） 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。 只有确保接口中有且仅有一个抽象方法，java中的Lambda才能顺利地进行推导。 语法糖： “语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法， 其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来
关于函数的返回值是一个接口类型的对象
yangzhouzhou的专栏
06-22 2232
<br />DAOFactory.java<br />package fo; public class DAOFactory { public static IUserInfoDAO getUserInfoDAO() //返回IUserInfoDAO接口类型 { return new UserInfoDAO(); //实际返回UserInfoDAO对象 } } <br />首先，返回的这个对象一定是对该接口实现的类的对象。其次，既然返回的是对象，而那么接口就是被实现了的
java实现多线程
luott_777的博客
09-27 257
java中提供两种方式实现线程，继承java.lang.Thread类与实现java.lang.Runnable接口 继承Thread类 public class Thread implements Runnable { 通过查看源码知道Thread类也是实现了Runnable接口 实现Runnable接口 @FunctionalInterface public interface Runnable { /** * When an object implementing interf.
Java常用函数接口
最新发布
日常技术分享
04-06 485
Java 8 中引入的常用函数式接口，也就是 java.util.function 包中的接口。这些接口提供了一种简洁的方式来定义函数，常用于 Lambda 表达式和方法引用。
JAVA基础之函数式接口
qq_64377514的博客
05-04 174
比较功能，对一些对象的集合施加了一个整体排序。没有要求每次调用供应商时都会返回新的或不同的结果。表示接受单个输入参数并且不返回结果的操作。表示一个参数的谓词（布尔值函数）。表示接受一个参数并产生结果的函数。以上内容属于自学，可能不是很全面，但为了方便日后的观看和复习，在此发文，如发现有错误请联系博主，欢迎指正。
Java学习 --- 函数式接口
qq_46093575的博客
07-08 609
1、一个接口中，只声明了一个抽象方法，这个接口就可以称为函数式接口。2、使用@FunctionalInterface注解，来检验当前接口是否是函数式接口实例代码，仅供参考： 三、Java函数式接口 四大接口 其他接口实例代码，仅供参考： 3.2、供给型接口 实例代码，仅供参考： 四、方法引用 1、当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用。2、方法引用本质上就是函数式接口的实例。3、类（对象）:: 方法名4、三种情况：对象 ::非静态方法 ，类 :: 静态方法 ，
深入解读函数式接口
zy1992As的博客
04-24 637
6.以上分析,仍然是按照面向对象中方法调用的思路展开的,但实质上,我们要注意,Function接口中的andThen方法,返回的是一个Function,里面采用的是lambda表达式,其实是在做函数模型的拼接,把两个函数模型fun1和fun2拼接出一个新的模型,返回新的模型。以及常用的函数式接口。在以后实际的编程过程中，对于集合的操作,可以通过Stream流完成,而Stream流中的很多方法的参数都是函数式接口,通过本文的学习,你已经掌握了函数式接口的使用,相信后面学习Stream流是非常容易的。
【Java】函数式接口
专注于Java领域开发 关注我 带你玩转Java
08-20 3251
函数式接口、函数式编程、常用函数式接口、
java8函数式编程详解
11-25
Java 8 引入了函数式编程的概念，其中最重要的两个特性是 Lambda 表达式和 Stream API。下面将对这两个特性进行详细介绍。 1. Lambda 表达式 Lambda 表达式是一种匿名函数，它可以作为参数传递给方法或存储在变量中。Lambda 表达式的语法如下： ``` (parameter1, parameter2, ..., parameterN) -> { statement1; statement2; ... } ``` 其中，参数列表可以为空，也可以包含多个参数；箭头符号 "->" 用于将参数列表和 Lambda 表达式的主体分开；体可以是一个语句块，也可以是一个表达式。 下面是一个 Lambda 表达式的例子： ```java (int x, int y) -> { return x + y; } ``` 这个 Lambda 表达式接受两个整数参数 x 和 y，返回它们的和。 Lambda 表达式可以用于函数式接口，即只包含一个抽象方法的接口。例如，下面是一个函数式接口的定义： ```java interface MyInterface { int myMethod(int x, int y); } ``` 可以使用 Lambda 表达式来实现这个接口： ```java MyInterface obj = (int x, int y) -> { return x + y; }; ``` Lambda 表达式还可以使用方法引用来简化代码。例如，可以使用静态方法引用来实现上面的例子： ```java MyInterface obj = Integer::sum; ``` 2. Stream API Stream API 是一种用于处理集合的 API，它提供了一种流式处理集合的方式。Stream API 可以用于对集合进行过滤、映射、排序等操作。 下面是一个使用 Stream API 进行过滤和映射的例子： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "pear"); List<String> result = list.stream() .filter(s -> s.startsWith("a")) .map(String::toUpperCase) .collect(Collectors.toList()); ``` 这个例子首先创建了一个包含四个字符串的列表，然后使用 stream() 方法将其转换为一个流。接着使用 filter() 方法过滤出以字母 "a" 开头的字符串，再使用 map() 方法将这些字符串转换为大写形式。最后使用 collect() 方法将结果收集到一个列表中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值