java高级：函数式接口

最新推荐文章于 2024-12-21 20:39:36 发布
最新推荐文章于 2024-12-21 20:39:36 发布
阅读量329 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java eclipse 概率论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbbeddd/article/details/120180502
本文探讨了Java中的函数式接口，包括如何判断接口是否为函数式接口，使用FUNCTIONINTERFACE注解，以及它们在方法参数和返回值中的应用。重点讲述了lambda表达式的延迟特性和在日志等级控制中的应用。此外，还介绍了常见的函数式接口，如Supplier、Consumer、Predicate和Function，通过实例展示了这些接口的使用方法和组合操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1什么是函数式接口：

                                

2如何判断函数式接口是否成功创建：使用FUNCTIONINTERFACE注解（使用方法同@override）

                                

3 函数式接口的使用：一般可以作为方法的参数和返回值来使用（在这里重新复习接口内容知识）

         1.如果主方法调用的方法，该方法传递进来的参数是一个接口，那么可以：

                1主方法中传入的参数可以是：接口的实现类

                2主方法中传入的参数可以是：接口的匿名内部类

                3如果方法中的参数是函数式接口，则可以使用lambda表达式

package com.bed.hanshushijiekou;
//使用三种方法来调用接口的抽象方法
public class mainfangfa {
    //第一种方法:直接把接口传递进来,然后调用接口中的方法。
    public static void method1(myInterface myinter){
        myinter.method();
    }
    public static void main(String[] args) {
    //第二种方法:调用方法一,然后参数传递接口的实现类
        method1(new myInterfaceimpl());
    //第三种方法。参数传递接口的匿名内部类。
        method1(new myInterface() {
            @Override
            public void method() {
                System.out.println("传递接口的匿名内部类重写接口中的方法");
            }
        });
    //同样是第三种方法使用lambda表达式
        method1(()-> System.out.println("使用lambda表达式传递接口的匿名内部类重写接口中的方法"));
    }
}

                 补充知识点：lambda表达式可以看作是匿名内部类的语法糖。但是lambda表达式省去

                                      了.class文件,所以效率更高

        添加知识点：lambda表达式的延迟性:

        现有如下代码 ：

                                

         日志只有传入等级为一级时才显示信息,当传入等级为其他等级时，msg1+msg2+msg3的组

         合操作就是多余的。这时我们可以使用lambda表达式的延时特性来节省资源。避免性能浪费        代码实现：

//创建一个接口里面有一个抽象类方法
package com.bed.hanshushijiekou.demo01;

public interface msgplus {
    public abstract String msgplus();
}

//执行日志
package com.bed.hanshushijiekou.demo01;

public class RiZhishow {
    public static void msgshow(int level,msgplus msg){
        if(level==1){
            System.out.println(msg.msgplus());
        }
    }
    public static void main(String[] args) {
        String msg1="hello";
        String msg2="bed";
        String msg3="java";

        msgshow(2,()->{
            return msg1+msg2+msg3;//重写接口中的抽象方法
        });
    }
}

     1.使用lambda表达式作为方法的参数：（其实上面的方法就是一个大的演示框架，而下面的

                主方法的lambda就相当于往构建好的大框架（接口的实现类）中添加更细致的操作步骤而已）

         如果主方法调用的方法，该方法传递进来的参数是一个接口，那么可以：

                1主方法中传入的参数可以是：接口的实现类

                2主方法中传入的参数可以是：接口的匿名内部类

                3如果方法中的参数是函数式接口，则可以使用lambda表达式

        ​​​​​​​        ​​​​​​​        

代码实现：

package com.bed.hanshushijiekou;

public class ThreadRunable {
    public static void startThread(Runnable r){//参数是Runnable接口
        new Thread(r).start();//开启多线程
    }

    public static void main(String[] args) {
        //方法1传递匿名内部类（老方法）
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"->"+"线程启动了");
            }
        });
        //方法2使用lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"->"+"线程启动了");
        });
    }
}

  2.使用lambda表达式作为方法的返回值：

        如果主方法调用的方法，该方法的返回值是一个接口，那么可以：

                1可以直接返回：接口的实现类

                2可以直接返回：接口的匿名内部类

                3如果返回值是函数式接口，则可以使用lambda表达式

案例3 使用自定义比较器对字符组进行比较

package com.bed.hanshushijiekou;

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

public class ComparatorReturn {
    //因为要改造Comparator，所以方法的返回值是新的Comparator比较器接口
    //方法就叫作getComparator
    public static Comparator<String> getComparator(){
        //111返回值是匿名内部类new Comparator（老方法）
      /*  return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串长度降序排序
                return o2.length()-o1.length();
            }
        };
        //222新方法：因为Comparator接口是一个函数式接口,所以使用lambda表达式
        return (String o1, String o2)->{return o2.length()-o1.length();};
        //333lambda表达式简化*/
        return (o1, o2)->o2.length()-o1.length();//对数组长度进行排序
    }

    public static void main(String[] args) {
        String[] arr={"aaa","bbbbb","c","dd"};
        Arrays.sort(arr,getComparator());//用我们自己定义的方法对arr进行排序
        System.out.println(Arrays.toString(arr));
    }
}

第二部分：常用的函数式接口：

        1、Supprlier接口：生产型接口，泛型参数传递什么类型，返回值就是什么类型

        

package com.bed.hanshushijiekou;

import java.util.function.Supplier;

public class getSupplier {
    //定义一个方法,参数是Supplier接口
    public static String getString(Supplier<String> sup){
        return sup.get();//调用Supplier接口中的get方法,此处返回值也是String类型的
    }

    public static void main(String[] args) {
       // 参数是接口，直接使用lambda表达式，重写Supplier中的get方法，使其返回值满足上面方法（String类型）

        String s = getString(() -> "bed");
        System.out.println(s);
    }
}

           案例：使用Supplier函数式接口获取数组的最大值：

                （其实上面的方法就是一个大的演示框架，而下面的主方法就相当于往构建好的大框架

                        （接口的实现类、lambda表达式）中添加更细致的操作步骤而已）

package com.bed.hanshushijiekou;

import java.util.function.Supplier;

public class SupplierGetMax {
    public static int getmax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        int[] arr={1,677,66,1,5,56,-23};
        int mmax=getmax(()->{
            int max=arr[0];
            for (int i : arr) {
                if(i>max){
                    max=i;
                }
            }
            return max;//这个就是sup.get方法的返回值
        });
        System.out.println(mmax);
    }
}

                2、Consumer接口（消费者，使用者）：

        ​​​​​​​        ​​​​​​​        

         案例，1Consumer的get方法：使用Consumer来逆转名字

package com.bed.hanshushijiekou.ConsumerPratice;

import java.util.function.Consumer;

public class ConsumerPractice {
    public static void getReverse(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        getReverse("baierdong",(String name)->{
            String rename=new StringBuffer(name).reverse().toString();
            System.out.println(rename);
        });
    }
}

          案例2Consumer的andthen方法：（接力棒操作）

                使用Consumer给字符先变成大写，然后改成小写

package com.bed.hanshushijiekou.ConsumerPratice;

import java.util.function.Consumer;

public class ConsumerAndThen {
    public static void upAndLow(String s, Consumer<String> con1,Consumer<String> con2){
        //先用con1调用accept方法，再使用con2调用accept方法
        con1.andThen(con2).accept(s);
    }

    public static void main(String[] args) {
        upAndLow("xiaobaitu",
           (s)->{//con1的accept方法
               System.out.println(s.toUpperCase());
        }, (s)->{//con2的accept方法
               System.out.println(s.toLowerCase());
                });
    }
}

  案例3、Consumer的andthen方法：

        ​​​​​​​        ​​​​​​​        

        案例重点：1分两次切割，一次是分开数组，一次是按逗号分开        

                          2注意按逗号拆分后，会变成数组状态，前面的元素顺序为【0】第二位元素

                            顺序为【1】......往后以此类推。详情见代码。

package com.bed.hanshushijiekou.ConsumerPratice;

import java.util.function.Consumer;

public class FenZuXianShi {
    //先用此方法拆分数组,拆成一个个的字符串
    public static void chaiFen(String[] main, Consumer<String> con1,Consumer<String> con2){
        for (String s : main) {
            con1.andThen(con2).accept(s);//在该步骤对拆分好的单个数组s进行操作
        }
    }

    public static void main(String[] args) {
        String[] nameage={"bed1,19","bed2,29","bed3,39"};
        chaiFen(nameage,
            (part)->{
            //用[]来把name和age组成为一对；
            String name=part.split(",")[0];//按逗号分开后，拿出[0]号位置元素，也就是name
            System.out.print("姓名"+name+",");
                },
            (part)->{
            String age=part.split(",")[1]; //按逗号分开后，拿出[1]号位置元素，也就是age
            System.out.println("年龄"+age+"。");
                });
    }
}

      2、predicate接口（判断接口）：

        ​​​​​​​        ​​​​​​​        ​​​​​​​        

         1.predicate的第一种方法：and（&&）

        ​​​​​​​        ​​​​​​​        ​​​​​​​        

package com.bed.hanshushijiekou.predicate;

import java.util.function.Predicate;

public class CompareNum {
    public static boolean compare(String s, Predicate<String> pre1,Predicate<String> pre2){
        //pre1条件和pre2条件是否同时符合
        return pre1.and(pre2).test(s);//该语句等于pre1.test(s)&&pre2.test(s)
    }

    public static void main(String[] args) {
        String s="abcdef";
        boolean b=compare(s,
                (s1)->{
                    return s.contains("a");
                },
                (s1)->{
                    return s.length()>5;
                });
        System.out.println(b);
    }
}

            2.predicate的第二种方法：or（ | | ）

        

           3.predicate的第三种方法：negate（ ！）

        ​​​​​​​        ​​​​​​​        

 案例1 人员筛选：

//筛选器，筛除大于35岁的女性
package com.bed.hanshushijiekou.predicate;

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

public class PersonFilter {
    public static ArrayList<String> filter(String[] s, Predicate<String> pre1,Predicate<String> pre2){
        //创建一个数组用来接收结果
        ArrayList<String> fire=new ArrayList<>();
        for (String person : s) {//将数组中的每一组数据拿出来筛选
            if(pre1.and(pre2).test(person)){//如果两个条件同时满足
                fire.add(person);
            }
        }
        return fire;
    }

    public static void main(String[] args) {
        String[] person={"男,35","女,25","男,25","女,40"};
        ArrayList<String> fire=filter(person,
                (String p)->{
                    //按逗号进行分割,判断性别是否为男
                    String sex = p.split(",")[0];
                    return sex.equals("女");
                },
                (String p)->{
                    //按逗号进行分割,判断年龄是否大于35岁
                    String s = p.split(",")[1];
                    Integer i=new Integer(s);//对分隔的字符串进行强制转换
                    return i>=35;
                });
        for (String s : fire) {
            System.out.println(s);
        }
    }
}

3.Function接口：转换接口，吃的是草产的是奶

                1、Function接口中的apply方法

        ​​​​​​​        

package com.bed.hanshushijiekou.Function;

import java.util.function.Function;

public class Function1 {
    public static void getInt(String str, Function<String,Integer> fun){
        Integer apply = fun.apply(str);
        System.out.println(apply);
    }

    public static void main(String[] args) {
        String str="12345";
        getInt(str,(String s)->{
            return Integer.parseInt(s);
        });
    }
}

         1、Function接口中的andthen方法：用来进行组合操作（或是理解为接力棒操作）

        ​​​​​​​        ​​​​​​​        ​​​​​​​        

package com.bed.hanshushijiekou.Function;

import java.util.function.Function;

//实现 1：先将字符串拆分（String to String）
// 2：将字符串转变为Integer类型 （String to Integer）
// 3：转变后再+10（Integer to Integer）
public class FunctionAndthen {
    public static int getInt(String str, //三次转换为用三个FUNCTION接口
                             Function<String,String> fun1,
                             Function<String,Integer> fun2,
                             Function<Integer,Integer> fun3){
       return fun1.andThen(fun2).andThen(fun3).apply(str);
    }

    public static void main(String[] args) {
        String str="bed,9";
        int age=getInt(str,
                (s)->{
                   return s.split(",")[1];//得到的结果还是String类型
                },
                (stoi)->{//从上一个Function进行接力棒操作
                    return Integer.parseInt(stoi);//由String得到Integer
                },
                (i)->{
                    return i+20;//接力棒操作
                });
        System.out.println(age);
    }
}

bbbeddd
关注
java中函数式编程apply的用法实例？
gb4215287的博客
06-20 1375
java中函数式编程apply的用法实例？
【一看就懂的java学习】高级篇 之 函数式接口
qq_38785034的博客
05-07 680
函数式接口函数式接口概述函数式接口作为方法的参数函数式接口作为方法的返回值常用函数式接口Supplier接口 函数式接口概述 函数式接口：有且仅有一个抽象方法的接口 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口 只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导 如何检测一个接口是不是函数式接口 @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是则失败 注意 自定义函
探索Java中的函数式接口与Streams API的高级用法
宋小黑的博客
03-06 1234
所谓函数式接口，其实就是只定义一个抽象方法的接口。虽然听起来很简单，但这个定义背后的含义是深远的。Java中的Lambda表达式，就是建立在函数式接口的基础上的。它们使得咱们可以用更简洁的方式来表示方法传递，或者说是行为的传递。这在之前的Java版本中是难以想象的。来，小黑给咱们举个例子。假设咱们需要一个接口，用于对整数进行某种形式的处理。// 输出 8这种方式虽然行得通，但是对于这么简单的行为，写一个实现类似乎太繁琐了。// 同样输出 8看，是不是简洁多了？
java高级——接口
kk1213_的博客
09-13 281
接口 从java8开始，接口中允许定义默认方法 备注：接口中的默认方法可以解决接口升级的问题 默认方法的格式： public default 返回值类型方法名称（参数列表）{ //方法体 } 注意： 1.接口的默认方法，可以通过接口实现类对象直接调用 2.接口的默认方法，也可以在接口的实现类中进行覆盖重写 接口中的常量 格式： public static final 数据类型 常量名称=数据值； 注意事项： 1.接口中的常量，可以省略public static fina
java高级开发--内建函数式接口
Sandm_Wzm的博客
05-19 238
Lamdba的核⼼心在于：函数式接口。⽽而函数式接口的核⼼心：只有一个抽象⽅方法。 java.util.function实际上函数式编程分为以下四种接口： 功能型函数式接⼝口：public interface Function<T, R> R apply(T t); 供给型函数式接⼝口： public interface Supplier T get(); 消费型函数式接⼝口：pub...
JAVA高级部分(接口)
2303_79546217的博客
11-06 105
实现的关系,可以单实现,可以多实现,甚至可以在继承的同时实现多个接口的执行(在倒数第一张代码的最后几行也有体现,接口AB,又实现了C)接口在日常生活当中就十分常见,插座,手机,电脑的接口等等,站在设计者的角度来看,这个接口的形状,更像是一种设计的规则。在接口当中是不存在逻辑问题的,因为在其中构建的方法本身就没有逻辑.因为这样的存在,接口之间才能够多线进行一个继承。在接口当中构建的成员方法都会是一个抽象的方法,会在相应的方法前自主的添加abstract。1.没有任何的成员变量,普通的成员方法。
函数式接口
高级Java开会工程师的博客
03-25 272
函数式接口、函数式编程
java开发高端说法_Java8 @FunctionalInterface
weixin_35294082的博客
02-26 223
函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。也就是说声明这样的接口，是可以灵活的以方法来传参。一、java8的函数式接口介绍函数式接口其实就是一个抽象接口类，在Java 8之前已有的函数式接口有以下。java.lang.Runnablejava.util.concurrent.Callablejava.util.Comparator等等...使用方法其实上述所说的接口类只...
Java高级API(上)
timid_lazy的博客
05-04 2206
API文档 JDK中包含大量的API类库,所谓API(Application Programming Interface,应用程序编程接口),就是一些已经写好,可以直接调用的功能.(在Java语言中,这些功能以类的形式封装) JDK API包含类库功能强大,经常使用的有: 字符串操作, 集合操作, 文件操作, 输入输出操作, 网络编程, 多线程, 等待. JDK包结构 为了便于使用和维护,JDK类库按照包结构划分,不同功能的类,划分在不同的包中; 经常使用的包如下所示:
Java高级语法笔记-接口（interface）
IT1995的博客
01-09 5064
接口interface 接口和抽象类写法是一样的（只定义一个声明） interface的使用：定义一个类，implements这个接口。（对比abstract class,extends） interface不能实例化（和抽象类差不多） 要用implements的那个类去实例。 接口的含义： 接口是一种设计方法，跟C/C++里的回调类似。 函数指针 举例：有一
分享函数式接口妙用
zhangan_的博客
02-21 311
分享函数式接口妙用 业务问题： 通过rpc远程传来一个表示code的int值。 一个表示desc的string字符串。想获取code对应的Type枚举中的三个枚举类型中的desc（其实就是传过来的desc字符串，但是由于是远程传来，不知道是否有对应枚举，所以需要查询一次才会调用查询数据库的sql语句） 修改之前的代码内容 想要效果：判断传来的 code值Type枚举里有没有，有的话再根据type 去找对应的枚举有没有传来的desc /** * @author zhangan * @date 2022
函数式接口的使用
zijikanwa
03-23 330
文章目录一. 背景二. 正常写法三. 使用函数式接口改良 一. 背景 最近在降低代码重复度的时候，发现有很多方法的整体流程相同，只是中间某些环节的细节不同。为了降低代码重复度，第一次知道函数式接口可以这样用，写出来看着还是很高级的，下面记录一下。 二. 正常写法 可以看到，TestApiImpl中三个方法都用了try…catch…的写法，整体流程类似，只是处理方式不同，看起来代码很冗余。 public interface TestApi { ResultModel<ATestDTO&
java1.8 interface_JDK1.8新特性——FunctionInterface
weixin_42596011的博客
03-07 1306
函数式接口FunctionInterface特征：接口中只定义了一个方法。接口中允许存在重写Object类的抽象方法。PageAction .java@FunctionalInterfacepublic interface PageAction {List> execute();}BaseCurdService.java 分页方法定义，当使用分页时，我们并不知道来自于那个Mapper，这里我...
java学习——函数式接口
weixin_46534686的博客
07-19 352
函数式接口在Java中是指有且仅有⼀个抽象方法的接口。
写了这么多年 Java，今天讲讲 Function一些高级玩法
最新发布
龚小帅的博客
12-21 884
Java 是一门严谨的编程语言，面向对象的特性让我们很早就开始接触类和对象的世界，但随着 Java 8 引入了函数式编程的一些特性，Function接口悄然走进了我们的生活。作为一个开发者，可能你在项目中见到过Function，也可能用过它，但你真的了解它的强大威力吗？今天，我们就一起来深入剖析 Java 中的Function接口，看看它如何在函数式编程的世界里大显身手，帮助你写出更加优雅、高效的代码。首先，了解一下Function接口的基本定义。Function。
Java8之函数式接口
Java小菜鸟
07-20 148
apply ()方法就是该接口的唯一方法，也就是继承该Function接口，唯一需要实现的方法；其中传入两个泛型：T为参数类型，R为方法返回类型。只有一个方法的接口；可以用@FunctionalInterface注解标识（注解非必须使用）自定义函数式接口也可不加注解，该注解只是起到一个提示编译器进行规范检查的作用。供给型接口，顾名思义只提供，即返回结果，类似生产者。有一个输入参数，返回值只能是布尔值。1.函数型接口：Function。消费型接口，即只消费，没有返回值。有一个输入参数，有一个输出。
【Java 8 新特性】Java 8中的Function.apply方法
热门推荐
猫巳的博客
05-18 3万+
Java 8中的Function.apply方法参考文献 java.util.function.Function是一个接口，已经在Java 8中引入。 Function是一个函数接口。 因此它可以用来接受lambda表达式。 函数接受一个参数并返回结果。 函数接口包含一种方法apply()。 这是函数接口方法。 查找apply()方法的声明。 R apply(T t) 其中T是函数参数，R是结果。 要使用它，我们需要定义功能。 假设我们在学生类中有一个方法customShow()，它将接受Function
Java 函数式接口 FunctionInterface 解析
u012688704的博客
01-14 1963
    函数式编程是 java 8 的新特性，lambda 表达式中用到了很多函数式接口。比如 Runnable 接口 ： public class Mytest { public static void main(String[] args) { new Thread( ()-&gt; System.out.println( Thread.currentThread() +" i...
Java 1.8之函数式接口
@you的博客
08-28 535
第一章 函数式接口 1.1 概念函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的fo...
深入解析Java8：Lambda表达式及其函数式接口应用
为了与Lambda表达式配合使用，Java提供了一些预定义的函数式接口，如java.util.function包下的Predicate、Consumer、Supplier和Function等。这些接口被广泛用于Lambda表达式。 4. 使用举例 在实际编程中，Lambda...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值