JAVA函数式接口 与 匿名内部类、Lambda表达式、方法引用

最新推荐文章于 2024-07-12 11:53:05 发布
最新推荐文章于 2024-07-12 11:53:05 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： Java学习 文章标签： java 开发语言 后端 lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43420351/article/details/121296222
版权

函数式接口 (Functional Interface)

函数式接口主要指的是只包含一个抽象方法的接口，例如：java.lang.Runnable、java.util.Cpmparator接口等等。
java.lang.Runnable接口
Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范，则会报错。在Java8中增加了java.util.function包(包内提供了大量的函数式接口)：
java.util.function

匿名内部类

没有名字的内部类

语法格式：
父类/接口类型 引用变量名 = new 父类/接口类型(参数列表){
方法的重写
}；

Lambda表达式

Lambda表达式是实现函数式接口的重要方式，利用Lambda表达式可以使代码变得更加简洁。

语法格式：（参数列表） -> { 方法体 }；

函数式接口 与 匿名内部类、lambda表达式 （代码）

简单封装一个Person类备用

public class Person {
    private String name;
    private int 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;
    }
    public void show(){
        System.out.println("~(@^_^@)~咻咻咻");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

下面的代码就是函数式接口的相关使用
在使用函数式内部类时，需要确定自己要使用的带不带参数，带几个参数，需不需要返回值。一些常用的函数式接口如下：

接口名称方法声明及功能介绍
Consumervoid accept(T t) ；根据指定的参数执行操作
SupplierT get() ； 得到一个返回值
Function<T,R>R apply(T t) ；根据指定的参数执行操作并返回
Predicateboolean test(T t) ；判断指定的参数是否满足条件

测试代码如下：

public class FunctionalInterface {

    public static void main(String[] args) {

        // 1. 匿名内部类的语法格式： 父类/接口类型 引用变量名 = new 父类/接口类型(){ 方法的重写 }
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是既没有参数又没有返回值的方法");
            }
        };
        runnable.run();

        // 2.使用lambda表达式实现函数式接口对象的实现
        //  一个参数可省略参数类型和小括号
        //  只有一条语句时可省略大括号
        //  只有一条语句且是return时,可省略大括号及return
        Runnable runnable1 = () -> System.out.println("lambda表达式实现的既没有参数又没有返回值的方法");
        runnable1.run();

        System.out.println("-----------------------------");

        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println( o +"有参但没有返回值的方法");
            }
        };
        consumer.accept("友情提示1：");

        Consumer consumer1 = (Object o) -> System.out.println( o +"有参但没有返回值的方法");
        Consumer consumer2 = (o) -> System.out.println( o +"有参但没有返回值的方法");
        Consumer consumer3 = o -> System.out.println( o +"有参但没有返回值的方法");
        consumer1.accept("友情提示2");

        System.out.println("-----------------------------");

        Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return "我是一个无参有返回值的函数式接口方法";
            }
        };
        System.out.println(supplier.get());

        Supplier supplier1 = () -> {return "我是一个无参有返回值的函数式接口方法";};
        Supplier supplier2 = () ->  "我是一个无参有返回值的函数式接口方法";
        supplier1.get();

        System.out.println("------------------------------");


        Function function = new Function() {
            @Override
            public Object apply(Object o) {
                return o;
            }
        };
        System.out.println(function.apply("Function<T,r>是一个有参有返回值的函数式接口"));

        Function function1 = o -> o;
        System.out.println(function1.apply("11"));
    }
}

方法的引用

方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行。就是我通过类名或者对象名，直接指向该类或者该对象中的某一个方法。

匿名内部类、lambda和方法引用其实是相通的，从匿名内部类到lambda到方法引用是一个进化的过程，是一个简化的过程，更加是一个从抽象的过程。作用都是实现接口方法，换句话说就是实现接口；只是这个接口只有一个抽象方法。

方法的引用使用一对 :: 通过类或对象指向方法，通常使用方式如下：

  • 对象的非静态方法引用 ObjectName :: MethodName
  • 类的静态方法引用 ClassName ::StaticMethodName
  • 类的非静态方法引用 ClassName :: MethodName
  • 构造器的引用 ClassName :: new
  • 数组的引用 TypeName[] :: new

方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加
紧凑简洁，从而减少冗余代码。

对应代码如下（跟课程练习时写的代码，太长了，慎看…）：

public static void main(String[] args) {

        // 1.使用匿名内部类的方式通过函数式接口Runnable中的方法实现对Person中show方法的调用
        Person person = new Person("章法",13);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                person.show();
            }
        };
        runnable.run(); // ~(@^_^@)~咻咻咻

        System.out.println("--------------------------------------------------");
        // 2.使用lambda表达式的方式通过函数式接口Runnable中的方法实现对Person中show方法的调用
        Runnable runnable1 = () -> person.show();
        runnable1.run();// ~(@^_^@)~咻咻咻

        System.out.println("--------------------------------------------------");
        // 3.使用方法引用的方式实现Person类中show方法的调用
        Runnable runnable2 = person::show;  // 方法引用
        runnable2.run();


        System.out.println("--------------------------------------------------");
        // 4.使用函数内部类的方式实通过函数式接口Consumer中的方法实现Person中setName方法的使用
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                person.setName(s);
            }
        };
        consumer.accept("guanyu");
        System.out.println("Person = " + person);

        System.out.println("--------------------------------------------------");
        // 5.使用lambda表达式的方法实现Person类中setName方法的使用
        Consumer<String> consumer1 = s -> person.setName(s);
        consumer1.accept("liubei");
        System.out.println("Person = " + person);

        System.out.println("--------------------------------------------------");
        // 6.使用  方法引用 的方式使用Person类中serName方法的使用
        Consumer<String> consumer2 = person::setName;
        consumer2.accept("zhangfei");
        System.out.println("Person = " + person);


        System.out.println("--------------------------------------------------");
        // 7.使用函数内部类的方式实通过函数式接口Supplier中的方法实现Person中getName方法的使用
        Supplier<String> stringSupplier = new Supplier<String>() {
            @Override
            public String get() {
                return person.getName();
            }
        };
        System.out.println(stringSupplier.get());

        Supplier<String> stringSupplier1 = () -> person.getName();
        System.out.println(stringSupplier1.get());

        Supplier<String> stringSupplier2 = person::getName;
        System.out.println(stringSupplier2.get());


        System.out.println("--------------------------------------------------");
        // 8.(类的静态方法引用)使用匿名内部类的方式通过函数式接口Function中的方法实现Integer类中parseInt方法(将字符串转换为整数)的调用
        Function<String,Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        System.out.println(function.apply("12345"));// 12345

        Function<String,Integer> function1 = s -> Integer.parseInt(s);
        System.out.println(function1.apply("12345"));// 12345


        Function<String,Integer> function2 = Integer::parseInt;
        System.out.println(function2.apply("12345")); // 12345

        System.out.println("--------------------------------------------------");
        // 9.(类的静态方法引用)使用匿名内部类的方式通过函数式接口Comparator中的方法实现Integer类中compare方法的调用
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(comparator.compare(1, 2)); // -1

        Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(comparator1.compare(1, 2));  // -1

        Comparator<Integer> comparator2 = Integer::compare;
        System.out.println(comparator2.compare(1, 2));  // -1

        System.out.println("--------------------------------------------------");
        // 10.(类的静态方法引用)使用匿名内部类的方式通过类名来调用非静态方法
        // 其中一个参数作为调用对象来调用方法时，可以使用上述方式  更加抽象
        Comparator<Integer> comparator3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator3.compare(1, 2));  // -1

        Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator4.compare(1, 2));  // -1


        Comparator<Integer> comparator5 = Integer::compareTo;
        System.out.println(comparator5.compare(1, 2));  // -1

        System.out.println("--------------------------------------------------");
        // 11.(构造器的引用)使用匿名内部类的方式通过Supplier函数式接口采用无参方式创建Person类型的对象并返回
        Supplier<Person> supplier = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(supplier.get());   // Person{name='null', age=0}

        Supplier<Person> supplier1 = () -> new Person();
        System.out.println(supplier1.get());   // Person{name='null', age=0}

        Supplier<Person> supplier2 = Person::new;
        System.out.println(supplier2.get());   // Person{name='null', age=0}

        System.out.println("--------------------------------------------------");
        // 12.(构造器的引用)使用匿名内部类的方式通过BiFunction函数式接口采用有参方式创建Person类型的对象并返回
        BiFunction<String,Integer,Person> biFunction = new BiFunction<String, Integer, Person>() {
            @Override
            public Person apply(String s, Integer integer) {
                return new Person(s,integer);
            }
        };
        System.out.println(biFunction.apply("zhanfei", 30));  // Person{name='zhanfei', age=30}

        BiFunction<String,Integer,Person> biFunction1 = (s,integer)->new Person(s,integer);
        System.out.println(biFunction1.apply("liubei", 40));   // Person{name='liubei', age=40}

        BiFunction<String,Integer,Person> biFunction2 = Person::new;
        System.out.println(biFunction2.apply("guanyu", 35));   // Person{name='guanyu', age=35}


        System.out.println("--------------------------------------------------");
        // 12.(数组的引用)使用匿名内部类的方式通过Function函数式接口采用创建指定数量的Person类型的对象数组并返回
        Function<Integer,Person[]> function3 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer integer) {
                return new Person[integer];
            }
        };
        System.out.println(Arrays.toString(function3.apply(3)));   // [null, null, null]

        Function<Integer,Person[]> function4 = integer -> new Person[integer];
        System.out.println(Arrays.toString( function4.apply(4)));   // [null, null, null, null]

        Function<Integer,Person[]> function5 = Person[]::new;
        System.out.println(Arrays.toString(function5.apply(5)));    // [null, null, null, null, null]
    }
程序员ah鑫
关注
专栏目录
Java8--匿名类和函数式接口
Java和算法学习的博客
11-07 595
目录一、匿名类二、函数式接口 一、匿名类 Java 中的匿名类是没有名称的类。它们只是语法糖，以避免样板代码声明和实例化一个只需要一次性使用的类。 （1）它是一个没有名称的内部或本地类，只为其创建一个对象。 （2）匿名类是表达式，这意味着该类需要在另一个语句中定义。 （3）匿名类表达式需要 new 运算符、要实现的接口或要扩展的类的名称、包含构造函数参数的括号以及类声明体。 （4）它不能有构造函数（根据需要使用实例初始值设定项） （5）由于匿名类类似于本地类，它们也支持捕获变量（它们的行为类似于闭包——
java8 探讨与分析匿名内部类、lambda表达式、方法引用的底层实现的测试用例
03-21
在Java 8中，匿名内部类、Lambda表达式和方法引用是重要的新特性，它们极大地简化了代码，提升了代码的可读性和效率。下面将详细探讨这三个知识点，并结合提供的测试用例进行分析。 1. **匿名内部类**： 匿名内部类...
函数式接口+匿名内部类+lambda表达式+方法引用+比较器
最新发布
qq_42694498的博客
07-12 1404
想实现这个接口，有两种方法：匿名内部类（接口可以有多个抽象方法）和函数式接口（只能有一个抽象方法）函数式接口（）里就是参数列表，这个抽象方法m是无参的，就空着。{}里是唯一的抽象方法的方法实现。阅读源码可以看到，forEach方法里面是增强的for循环，之所以能用（）->{}函数式接口：只有一个抽象方法的接口（但可以有多个非抽象方法）Consumer也是函数式接口。
java 详解匿名内部类与函数式接口
weixin_39802680的博客
04-30 1861
引言 匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。 匿名内部类的前提必须是继承与类或实现相应接口。匿名实现类的总体效果就是父类的子类对象或子接口的实现接口。 不使用匿名内部类 1 创建 Animal 的抽象类并提供eat 方法 abstract class Animal{ public abstract void eat(); } 2 定义一个dog 继承自Animal class Dog extends Animal{ @Ov
【重难点】函数式接口、函数式编程、匿名内部类、Lambda表达式、语法糖
USTSD的博客
06-17 230
一、函数式接口 1、概念 仅有一个抽象方法的接口 适用于函数式编程(Lambda表达式) 常见：Runnable、Comparator<>、生产型接口Producer的get方法、消费型接口Consumer的accept方法、Predict接口的test方法 2、格式 加FunctionalInterface注解进行检测 如果不是函数式接口则编译失败 3、使用 编写实现类，对抽象...
函数式接口、匿名内部类、lambda表达式
m0_63803244的博客
07-11 747
FunctionalInterface注解标记，在idea中可以用这个注解验证是不是函数式接口。实现函数式接口可以转成lambda表达式。匿名内部类的格式：父类/接口 对象 = new 父类/接口（）{ 重写父类/接口中的方法 }；只有一个抽象方法的接口叫函数式接口，不能有两个，也不能有方法实现。继承了java.lang下的Thread，重写了Thread方法。1.代替实现函数式接口(idea可以自动转换)简化代码，常用的lambda表达式简写方式。
匿名内部类，函数式接口和Lambda
l10711097061的博客
03-09 391
匿名内部类，函数式接口和Lambda
Java Lambda表达式与匿名内部类的联系和区别实例分析
08-25
Java Lambda表达式与匿名内部类的联系和区别实例分析 Java Lambda表达式和匿名内部类是Java中两个重要的概念，它们都是用于实现函数式编程的方式，但它们之间存在一定的联系和区别。在本文中，我们将通过实例分析，...
Java Lambda表达式和函数式接口实例分析
08-25
如果采用匿名内部类语法来创建函数式接口的实例，只要实现一个抽象方法即可。在这种情况下，即可采用Lambda表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口。 Java 8专门为函数式接口提供了...
Java8简单了解Lambda表达式与函数式接口
08-28
Java8中的Lambda表达式和函数式接口 Java8中引入了Lambda表达式和函数式接口，这两大新特性给Java开发者带来了极大的便捷和灵活性。Lambda表达式是一种特殊的匿名函数，可以用来简化代码，使其变得更加简洁和易读。...
浅析Java8新特性Lambda表达式和函数式接口
08-29
Java 8 新特性 Lambda 表达式和函数式接口 Java 8 中引入的 Lambda 表达式是一种可以传递的代码，旨在简化代码，提高代码的可读性。 Lambda 表达式基于数学中的&lambda;演算得名，直接对应于其中的 lambda 抽象（lambda ...
匿名内部类&Lambda表达式&函数式接口
ZHUSHANGLIN的博客
12-13 1208
一. 匿名内部类 匿名内部类作用:简化代码 把子类继承父类/实现接口,重写父类/接口中的方法,创建子类对象合一步完成 匿名内部类的最终产物: 子类/实现类对象 格式: 在匿名内部类中，接口也是可以new出对象的 new 父类/接口(){ 从写重复父类/接口中的方法 }; 例如1： /* 线程的父类是Thread，原来的写法： 1.先创建MyThread类继承自Thread 2.使用...
函数式接口的匿名内部类与Lambda表达式的实现
weixin_46068252的博客
04-26 571
文章目录函数式接口一、函数式接口:二、Lambda表达式:三、常用函数式接口:实现代码： 函数式接口 一、函数式接口: 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator接口等 Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错 Java8中增加了java.util.function包，该包包含了常用的函数式接口 二、Lambda表达式: Lambda 表达式是实例
函数式接口@FunctionalInterface学习(函数编程思想)------------与匿名内部类对比
cszhang
11-30 1186
 在java8中 1、新推出了一个接口概念：函数式接口。 2、允许接口也可以有default方法，default方法可以方法体。 他满足以下规范： 接口有且只能有个一个抽象方法（抽象方法只有方法定义，没有方法体） 不能在接口中覆写Object类中的public方法（写了编译器也会报错） 允许有default实现方法。 如下例子是函数式接口： package zzu.zwl.main...
Java学习日志
XieXiao001的博客
03-14 427
内部类 : 类中定义类 外部类 内部类 分类: 成员内部类 私有内部类 静态内部类 局部内部类 匿名内部类 : 重点 成员内部类 内部类定义在外部类的成员位置 具有类的特点,可以继承其他父类,实现其他接口,具有成员的特点,可以被成员修饰符修饰... 注意: 成员内部类中不能定义静态内容,除了静态的常量 成员内部类中可以直接使用外部类的成员,包括私有的 外部类中可以通过成员内部类的对象调用成员内部类的成员
函数式接口、匿名实现类、Lambda表达式之间的关系
干就完了！！！
04-30 609
通过匿名实现类可以对接口中的抽象方法进行快速实现。进一步地，如果该接口是函数式接口（即只有一个抽象方法，其他方法可以有多个），那么可以用lambda表达式来进一步简化代码。
匿名内部类->lambda表达式->方法引用
qq_39100560的博客
07-09 179
package com.paddington; public class Demo { public static void main(String[] args) { /*//匿名内部类写法，直接new 接口来表示子类对象 printString(new Printable() { @Override p...
java 函数内部类_Java中的内部类
weixin_26851099的博客
02-12 219
有些时候我们需要在一个类中快速的访问另一个类的某些属性，此时可以使用到内部类。classOuter{privateString str1 ;privateString str2 ;publicOuter(String str1, String str2){this.str1 =str1;this.str2 =str2;}public classInner{publicString generate...
Java里接口、内部类和匿名类
Finneab的博客
04-17 577
Java 接口 匿名类 内部类
深入理解JAVA函数式编程：接口与Lambda表达式
开发者可以根据需求自定义函数式接口，例如在`Demo09FunctionalInterface`类中，定义了一个名为`doSomething`的方法，它接受一个自定义的函数式接口`MyFunctionalInterface`作为参数，并在方法内部调用该接口的`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值