java学习——函数式接口

最新推荐文章于 2025-05-24 22:27:29 发布
原创 最新推荐文章于 2025-05-24 22:27:29 发布 · 353 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #学习 #jvm

本文详细介绍了Java中的函数式接口概念，包括Supplier、Consumer、Predicate和Function接口的用法，并通过实例演示了如何使用Lambda表达式简化接口实现。重点展示了如何在Demo1、Demo2、Demo3和Demo4中运用这些接口及其Lambda形式。

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

函数式接口

概念：

函数式接口在Java中是指：有且仅有⼀个抽象方法的接口。

函数式接口注解 @FunctionalInterface - > JDK8

@xxx -> 注解 ：给JVM看 参与编译 // /**/ -> 注释：给程序员看，不参与编译

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

4个常用的函数式接口：

  1. Supplier ： 生产者 -> T get（）：生产对象
  2. Consumer ：消费者 -> void accept(T t)
  3. Predicate：判断 -> boolean test（T t）：判断t对象，判断逻辑自定义
  4. Function<T, R> function1: 类型转换
    R apply(T t): 将t对象 转换成 R 类型
    Function andThen(Function<R, V> after):
    function1.andThen(Function<R, V> after).apply(T t)
    R r = function1.apply(T t);
    V v = after.apply(R r);

Supplier实现：

主函数：
public class Demo1 {
    //为了使用Lambda表达式，定义了一个方法，将Supplier作为方法参数
    //Supplier是一个函数式接口
    public static Person creatPerson(Supplier<Person> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        String name = "lucy";
        int age = 18;
        //传统方法实现
        Person p1 = creatPerson(new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person(name, age);
            }
        });
        System.out.println(p1);

        //参数是一个函数是接口,所以可以使用lambda表达式
        //Supplier的方法是 T get()   T -> Person
        //lambda表达式简化后实现
        Person p2 = creatPerson(() -> new Person(name, age));
        System.out.println(p2);
    }
}
Person类：
public class Person {
    private String name;
    private int age ;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Person{name='lucy', age=18}
Person{name='lucy', age=18}

Consumer实现：

实现1：
public class Demo2Consumer {
    //Consumer是一个函数式接口
    public static void print(Consumer<Person> consumer, Person p) {
        consumer.accept(p);
    }

    public static void main(String[] args) {
        String name = "lucy";
        int age = 18;
        Person p = new Person(name, age);
        //传统方法实现
        print(new Consumer<Person>() {
            @Override
            public void accept(Person p) {
                System.out.println(p.getName() + "今年" + p.getAge() + "岁");
            }
        }, p);
        //lambda表达式简化后实现
        print((t -> System.out.println(t.getName() + "今年" + t.getAge() + "岁!")),p);
    }
}

lucy今年18岁
lucy今年18岁!
实现2：
public class Demo2ConsumerAndthen {
    //Consumer是一个函数式接口
    public static void print(Consumer<Person> consumer1, Consumer<Person> consumer2, Person p) {
        consumer1.andThen(consumer2).accept(p);
    }

    public static void main(String[] args) {
        String name = "lucy";
        int age = 18;
        Person p = new Person(name, age);
        //传统方法实现
        print(new Consumer<Person>() {
            @Override
            public void accept(Person p) {
                System.out.print("她的名字叫" + p.getName());
            }
        }, new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println("今年" + p.getAge() + "岁了");
            }
        }, p);
        //lambda表达式简化后实现
        print(t -> System.out.print("她的名字叫" + t.getName()),
                t -> System.out.println("今年" + p.getAge() + "岁了!!"), p
        );
    }
}

她的名字叫lucy今年18岁了
她的名字叫lucy今年18岁了!!

Predicate实现：

实现1：
public class Demo3Predicate {
    public static void print(Predicate<Person> predicate, Person[] ps) {
        for (Person p : ps) {
            if (predicate.test(p)) {
                System.out.println(p);
            }
        }
    }
    public static void main(String[] args) {
        Person[] ps = {new Person("张三", 15),
                new Person("张翰", 30),
                new Person("王五", 18),
                new Person("张无忌", 60),
                new Person("王五", 56)
        };
        //传统写法：
        //打印姓张的人
        print(new Predicate<Person>() {
            @Override
            public boolean test(Person p) {
                return p.getName().startsWith("张");
            }
        }, ps);
        System.out.println("----------------");
        //简化写法
        print(t->t.getName().startsWith("张"),ps);
    }
}

Person{name='张三', age=15}
Person{name='张翰', age=30}
Person{name='张无忌', age=60}
----------------
Person{name='张三', age=15}
Person{name='张翰', age=30}
Person{name='张无忌', age=60}
实现2：
public class Demo3PredicateAnd {
    public static void print(Predicate<Person> predicate1, Predicate<Person> predicate2, Person[] ps) {
        for (Person p : ps) {
            if (predicate1.and(predicate2).test(p)) {
                System.out.println(p);
            }
        }
    }

    public static void main(String[] args) {
        Person[] ps = {new Person("张三", 15),
                new Person("张翰", 30),
                new Person("王五", 18),
                new Person("张无忌", 60),
                new Person("王五", 56)
        };
        //传统写法：
        //打印姓张的人,且年龄小于50岁
        print(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getName().startsWith("张");
            }
        }, new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() < 50;
            }
        }, ps);
        System.out.println("----------------");
        //简化写法
        print(t -> t.getName().startsWith("张"),
                t -> t.getAge() < 50, ps);
    }
}

Person{name='张三', age=15}
Person{name='张翰', age=30}
----------------------------
Person{name='张三', age=15}
Person{name='张翰', age=30}

Function实现：

主函数：
public class Demo4Transfer {
    public static Date transfer(Function<String, Date> function, String str) {
        return function.apply(str);
    }

    public static void main(String[] args) {
        String str1 = "2022-07-19 11:48:19";
        //传统写法
        Date date = transfer(new Function<String, Date>() {
            @Override
            public Date apply(String s) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    return sdf.parse(str1);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, str1);
        System.out.println(date);
        String str2 = "2022-07-19 11:49:27";
        //简化写法
        Date date1 = transfer((t) -> {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            try {
                return sdf.parse(t);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }, str2);
        System.out.println(date1);
    }
}

Tue Jul 19 11:48:19 CST 2022
Tue Jul 19 11:49:27 CST 2022
Ccccrush_
关注
JAVA系列---函数式接口
lipviolet的博客
06-13 845
该接口在jdk8的实现增加了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可放心的通过lambda表达式来实例化。函数式编程也不会改变java的核心：bean.method(param)，jvm只能将bean当参数，所以jvm其实还是将Lambda表达式的结果当成对象，由此表象上看似java支持了函数语句当参数。但上面的并不是我们常见的代码，那是因为我们常用的是极简风，以下是简化过程：参数类型省略-》参数占位省略-》返回语句省略。
【一看就懂的java学习】高级篇 之 函数式接口
qq_38785034的博客
05-07 680
函数式接口函数式接口概述函数式接口作为方法的参数函数式接口作为方法的返回值常用函数式接口Supplier接口 函数式接口概述 函数式接口：有且仅有一个抽象方法的接口 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口 只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导 如何检测一个接口是不是函数式接口 @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是则失败 注意 自定义函
Java 函数式接口（Functional Interface）
最新发布
SSSYUsssyu的博客
05-24 1190
Java 函数式接口是一种特殊的接口，它只包含一个抽象方法（Single Abstract Method, SAM），但可以包含多个默认方法或静态方法。函数式接口是 Java 8 引入 Lambda 表达式的基础，通过函数式接口可以将行为作为参数传递，实现更简洁、灵活的代码。可以通过// 唯一的抽象方法// 默认方法（非抽象）System.out.println("计算结果: " + result);// 使用 Lambda 表达式实现// 输出: 8// 输出: 计算结果: 10。
Java函数式接口
刘皇叔说Java的博客
08-12 1948
Java函数式接口（Functional Interface）是Java 8引入的一个重要特性，它指的是那些有且仅有一个抽象方法的接口（但可以有多个默认方法或静态方法）。这一特性与Lambda表达式紧密相关，因为Lambda表达式可以作为函数式接口的实现。函数式接口在Java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。
【Java 基础篇】Java 函数式接口详解
繁依Fanyi的博客
06-26 4022
本文详细介绍了Java函数式接口的概念、语法和使用方法。函数式接口是Java 8引入的重要特性，支持函数式编程的方式。通过函数式接口，可以将函数作为参数传递给方法，或者作为返回值返回，实现灵活的函数组合和处理。通过学习和应用函数式接口，开发人员可以编写更加简洁、可读性高的代码，并享受函数式编程的好处。希望本文对你理解和应用Java函数式接口有所帮助！
Java 函数式接口详解及使用
kuroshiro的博客
06-28 2450
Java 函数式接口详解及使用
Java开发『函数式编程』——函数式接口
成都汇智动力的博客
09-03 336
提到函数式编程我们首先需要了解的就是函数式接口，我们之前讲解的Lambda 表达式的主要服务对象就是函数式接口了。 所以这章我们就来认识下函数式接口： 函数式接口的定义 在java中函数式接口（Functional Interface）指的是只能有一个抽象方法但是可以有多个非抽象方法的接口。 函数式接口上一般会有@FunctionalInterface 修饰，但是不是必须的。 @FunctionalInterface 主要是为了更好的让编译器检查当前接口是否是函数式接口。 例如：线程的Runnable接
【Java】—— 函数式编程：Lambda表达式、方法引用
张修宇的博客
11-10 832
JDK 8开始新增的一种语法形式，可以替代匿名内部类对象，让程序更简洁。注意：只能替代函数式接口（有且仅有一个抽象方法的接口）的匿名内部类！！
快速学习Java8新特性第三讲——函数式接口
李阿昀的博客
12-06 1345
不知你有没有想过，Lambda表达式默认找的是接口中哪个抽象方法来实现的呢？假设说接口中有多个抽象方法，Lambda表达式默认实现的是哪个呢？你可以带着这个疑问开始本讲的阅读之旅。 函数式接口是什么？ Lambda表达式可以很简洁的代替匿名内部类的代码编写，而匿名内部类往往是实现某一接口的一个抽象方法。所以，在使用Lambda表达式时，我们最应该关注的应该是接口的抽象方法，并且这个接口还必须只有一...
JAVA开发中的工具类——基于函数式接口的重试工具类
Knight_hf的专栏
02-18 986
在实际的项目开发中，为了保证程序的健壮性，一些场景在代码执行失败的时候需要进行重试操作。该文章介绍了一个基于JAVA函数式接口实现的重试的工具类。 import com.google.common.collect.Lists; import lombok.Data; import lombok.extern.slf4j.Slf4j; import java.time.LocalDateTime; import java.util.List; import java.util.concurrent.
Java Lambda表达式和函数式接口实例分析
08-25
Java 8专门为函数式接口提供了@FunctionalInterface注解，该注解通常放在接口定义前面，该注解对程序功能没有作用，它用于告诉编译器执行更严格的检查——检查该接口必须是函数式接口，否则就会报错。 Lambda表达式...
JAVA学习-常用函数式接口
qq_48772498的博客
02-12 718
函数式接口指的是有且只有一个抽象方法的接口，在学习 函数式编程和Lambda表达式中我们经常遇到，但是这些函数式接口都是我们自定义的，其实，在 Java 中，有着自带的函数式接口，以下就是一些常用的函数式接口。 Function 接口 @FunctionalInterface public interface Function<T, R> 功能性接口，接受一个 T 类型的参数，将结果以 R 类型的方式输出，函数式方法是 apply(T)。 public static void ..
Java学习笔记——函数式接口
anhanjie的博客
02-15 464
一、函数式接口概述 函数式接口：有且仅有一个抽象方法的接口。 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于 Lambda表达式使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的 Lambda表达式才能顺利地进行推导。 可以在接口定义的上方加上一个注解@FunctionalInterface来表示该接口是一个 函数式接口。如下所示： @FunctionalInterface public interface MyInterface { void show
java学习(常用函数式接口)
qq_41302368的博客
07-21 412
Supplier函数式接口 java.util.function.Supplier接口包含一个无参的方法，T get()。 用来获取一个泛型参数指定类型的对象数据。 Supplier接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据。 import java.util.function.Supplier; public class DemoS...
5.函数式接口
xixihaha_coder的博客
06-01 375
函数式编程lambda表达式
java中函数式接口的使用
wopoli的博客
07-07 2392
只存在一个抽象方法的接口。 1.3 使用格式： 创建函数式接口的格式： @FunctionalInterface // 注解，用于检测接口是否为函数式接口，是编译成功、否编译失败 public Interface 接口名称{ public abstract 数据类型(例如：void int boolean) 方法名称(); 其他非抽象方法，即默认、静态、私有方法(可以省略) } 1.5 注意事项： 二、Supplier接口 2.1 功能 返回泛型参数指定数据类型数据的接口，用于生产数据。 2.3 注
java 函数式接口
weixin_43932553的博客
03-11 902
函数式接口 1. 概念 函数式接口就是一个有且只有一个抽象方法的接口（可以有其他非抽象的方法）。函数式接口可以转化Lambda表达式。 2. 使用 2.1 @FunctionalInterface 注解使用 @FunctionalInterface 注解，作用是检查当前接口是否符合函数式接口的规范 @FunctionalInterface public interface FunctionalTy...
Java 函数式接口
sokenna的博客
08-14 6012
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值