JDK1.8新特性之函数式接口

于 2021-04-25 21:54:41 发布
阅读量332 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54605990/article/details/116139156
版权
本文介绍了JDK1.8中的函数式接口概念，强调其作为Lambda表达式基础的重要性。@FunctionalInterface注解用于确保接口只包含一个抽象方法。自定义函数式接口常用于方法参数和返回值。举例说明了Consumer、Supplier、Function和Predicate等常见内置函数式接口的应用。

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

函数式接口

​ 函数式接口在java指定的是：有且仅有一个抽象方法的接口就称为函数式接口。

​ 函数式接口，设用于函数式编程的，在java当中的函数式编程体现在Lambda，所以函数式接口就是用来服务Lambda表达式。只有确定接口当中有且仅有一个抽象方法，java中的Lambda才能顺利进行推导

​ 备注： “语法糖"是指使用更加便利方便，但是原理不变的代码语法。就比如遍历集合时使用for-each语法，其实底层使用的是迭代器，这便是"语法糖”。

@Functionallnterface注解
与@Override注解作用类似，java 8 专门为函数式接口引入的一个新注解@FunctionalInterface,该注解主要定义在接口上。一旦在接口上使用该注解，编译期将会强制检查该接口是不是一个函数式接口，该接口中是不是有且仅有一个抽象方法，如果不是，编译报错

自定义函数式接口的用途
对于自定义的函数式接口，一般用于方法的参数和返回值上

格式：

修饰符 interface InterfaceName{
	// 只能定义一个抽象方法
	public abstract 返回值类型 方法名称(参数列表);
	// 还可以定义其他的非抽象方法
}

示例：

package com.hong.lambda;

/**
 * @Author hongCheng
 * @Date 2021/4/25 15:54
 * @Version 1.0
 */
public class InterfaceTest {
    public static void main(String[] args) {
        USB uPan = new USB() {
            @Override
            public void show() {
                System.out.println("使用右眼");
            }
        };
        test(uPan);

        //改进①
        USB jianPan = () -> System.out.println("使用键盘");
        test(jianPan);

        //改进②
        test(() -> System.out.println("使用蓝牙"));
    }

    //函数时接口方式的应用：作为方法的参数， 调用方法可以使用lambda表达式
    public static void test(USB usb) {
        usb.show();
    }
}

//函数式接口:接口中只有一个抽象方法，该接口就是函数式接口
@FunctionalInterface//检验该接口是否为函数式接口
interface USB {
    public void show();

    //JDK8以后新增的特性
    default void service() {
    }

    static void txt() {
    }
}

常见的函数式接口

  1. Comsumer

Consumer接口是一个类似消费者的接口，定义了一个名叫accept的抽象方法，它的入参是一个泛型T对象，没有任何返回值（void）

示例

package com.hong.interfacetest;

import java.util.function.Consumer;

/**
 * @Author hongCheng
 * @Date 2021/4/25 16:23
 * @Version 1.0
 */
public class ConsumerInterfaceTest {
    public static void main(String[] args) {
        //方式一
        //MyConsumer<Double> consumer = new MyConsumer<>();
        System.out.println("====方式二====");
        System.out.println("lambda方式");
        Consumer<Double> consumer = new Consumer<Double>(){

            @Override
            public void accept(Double aDouble) {
                System.out.println("今天消费了："+aDouble);
            }
        };
        fun(consumer, 12.0);

        System.out.println("=====改进①=====");
        Consumer<Double> consumer1 = (Double aDouble) -> {
            System.out.println("今天消费了："+aDouble);
        };
        fun(consumer1, 30.0);

        System.out.println("====改进②====");
        Consumer<Double> consumer2 = (Double aDouble)-> System.out.println("今天消费了"+aDouble);
        fun(consumer2,40.0);

        System.out.println("===改进③===");
        fun((Double aDouble)-> System.out.println("今天消费了："+aDouble),80.0);
    }
	//消费型函数式接口
    public static void fun(Consumer<Double> consumer, Double param) {
        consumer.accept(param);
    }
}
//方式一
class MyConsumer<Double> implements Consumer<Double> {
    @Override
    public void accept(Double aDouble) {
        System.out.println("我消费了：" + aDouble);
    }
}
  1. Supplier（无参有返回值）

Supplier接口是对象实例的提供者，定义了一个名叫get的抽象方法，它没有任何入参，并返回一个泛型T对象

示例：

package com.hong.interfacetest;

import java.util.function.Supplier;

/**
 * @Author hongCheng
 * @Date 2021/4/25 16:43
 * @Version 1.0
 */
public class SupplierTest {
    public static void main(String[] args) {
        System.out.println("======方式①======");
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "hello world！";
            }
        };
        String test = testSupplier(supplier);
        System.out.println(test);
        
        System.out.println("=====方式②=====");
        Supplier<String> supplier1 = ()->{
            return "Hello Java";
        };
        String test1 = testSupplier(supplier1);
        System.out.println(test1);

        System.out.println("=====方式③=====");
        Supplier<String> supplier2 = ()-> "Hello MySQL";
        String test2 = testSupplier(supplier2);
        System.out.println(test2);

        System.out.println("=====方式④=====");
        String test3 = testSupplier(()->"Hello Redis");
        System.out.println(test3);
    }
    //供给型函数式接口
    public static String testSupplier(Supplier<String> supplier) {
        return supplier.get();
    }
}
  1. Function（有参有返回值）

Function接口是对实例进行处理转换的接口，定义了一个名叫apply的抽象方法，它的入参是一个泛型T对象，并返回一个泛型T对象

示例：

package com.hong.interfacetest;

import java.util.function.Function;

/**
 * @Author hongCheng
 * @Date 2021/4/25 16:55
 * @Version 1.0
 */
public class FunctiontTest {
    public static void main(String[] args) {
        System.out.println("====方式①====");
        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        };
        System.out.println(testFunction(function, "hello world!"));

        System.out.println("====方式②====");
        Function<String, String> function2 = (String s) -> {
            return s.toUpperCase();
        };
        System.out.println(testFunction(function2, "lili"));

        System.out.println("====方式③====");
        Function<String, String> function3 = s ->  s.toUpperCase();
        System.out.println(testFunction(function3, "hong"));

        System.out.println("====方式④====");
        System.out.println(testFunction(s ->  s.toUpperCase(), "cheng"));

    }
	//函数型接口
    public static String testFunction(Function<String, String> function, String str) {
        return function.apply(str);
    }
}
  1. Predicate

Predicate接口是判断是与否的接口，定义了一个名叫test的抽象方法，它的入参是一个泛型T对象，并返回一个boolean类型

示例：

package com.hong.interfacetest;

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

/**
 * @Author hongCheng
 * @Date 2021/4/25 17:11
 * @Version 1.0
 */
public class PredicateTest {
    /*public static void main(String[] args) {
        Predicate<String> predicate = new Predicate<String>() {

            @Override
            public boolean test(String s) {
                return s.length() > 5;
            }
        };
        System.out.println(testPredicate(predicate,"hong"));

    }
    //断言型接口
    public static Boolean testPredicate(Predicate<String> predicate,String str){
        return predicate.test(str);
    }*/

    public static void main(String[] args) {
        System.out.println("===方式①===");
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 5;
            }
        };
        List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaosi");
        System.out.println(testPredicate(predicate, list));

        System.out.println("===方式②===");
        Predicate<String> predicate2 = (String s) -> {
            return s.length() > 5;
        };
        List<String> list2 = new ArrayList<>();
        list2.add("elema");
        list2.add("meituan");
        list2.add("bangbang");
        list2.add("zuoye");
        System.out.println(testPredicate(predicate2, list2));

        System.out.println("===方式③===");
        Predicate<String> predicate3 = s -> s.length() > 5;
        List<String> list3 = new ArrayList<>();
        list3.add("xigua");
        list3.add("lizi");
        list3.add("pingguo");
        System.out.println(testPredicate(predicate3, list3));
    }

    //断言型接口
    public static List<String> testPredicate(Predicate<String> predicate, List<String> list) {
        List<String> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (predicate.test(list.get(i))) {
                list1.add(list.get(i));
            }
        }
        return list1;
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值