【Java】四大函数式接口

Peanutty

于 2024-03-02 18:18:18 发布

阅读量293

点赞数 3

分类专栏： JAVA基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/hhb442/article/details/136420031

版权

JAVA基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

本文介绍了Java中四种重要的函数式接口：Consumer处理无返回值输入，Function处理类型转换，Predicate进行条件判断，Supplier提供默认值。并通过stream流计算和lambda表达式展示了它们在遍历、映射和过滤操作中的应用。

摘要由CSDN通过智能技术生成

消费型接口Consumer

消费型接口
接收一个输入，没有返回值

在stream流计算中 forEach() 接收一个消费型接口Consumer用于遍历元素

/**
 * 消费型接口
 * 接收一个输入，没有返回值
 */
public class demo01 {
    public static void main(String[] args) {
        //TODO 消费型接口,接收一个输入，没有返回值
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("dsada");

        //TODO 在流计算中 forEach() 接收一个消费型接口Consumer用于 遍历元素
        ArrayList<String> list = new ArrayList<>();
        list.stream().forEach(consumer);

        //lambda表达式
        Consumer<String> consumer1 = (str)->{
            System.out.println(str+"====");
        };
        consumer1.accept("dsadsa");

    }
}

函数形接口Function

函数形接口
接收一个类型的参数，返回一个类型的参数

在stream流计算的 map（）方法中，map() 方法接收一个 Function 接口用于类型映射

/**
 * 函数形接口
 * 接收一个类型的参数，返回一个类型的参数
 */
public class demo01 {
    public static void main(String[] args) {
        // 匿名内部类，
        // Function接口
        //TODO 两个泛型 接收一个类型的参数，返回一个类型的参数

        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };
        //TODO 在流计算的 map（）方法中，map() 方法接收一个 Function 接口用于类型映射
        ArrayList<String> list = new ArrayList<>();
        list.stream().map(function);

        System.out.println(function.apply("dsad"));

        //lambda表达式
        Function<String, String> function2 = (str)->{ return str;};
        System.out.println(function2.apply("dsad"));
    }
}

断定型接口Predicate

断定型接口
接收一个输入参数，返回一个布尔值

在stream流计算中 filter() 接收一个断定型接口Predicate用于过滤元素

/**
 * 断定型接口
 * 接收一个输入参数，返回一个布尔值
 */
public class demo01 {
    public static void main(String[] args) {
        // TODO 断定型接口  接收一个输入参数，返回一个布尔值
        Predicate<String> StringPredicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };

        //TODO 在流计算中 filter() 接收一个断定型接口Predicate用于过滤元素
        ArrayList<String> list = new ArrayList<>();
        list.stream().filter(StringPredicate);

        System.out.println(StringPredicate.test(""));
    }
}

供给型接口Supplier

供给型接口
没有参数，只有返回值

/**
 * 供给型接口
 *  没有参数，只有返回值
 */
public class demo01 {
    public static void main(String[] args) {
        //TODO 没有参数，只有返回值
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "1024";
            }
        };

        System.out.println(supplier.get());

        //lambda表达式
        Supplier<String> supplier1 = () -> "1024";
        System.out.println(supplier1.get());

    }
}