Java8新特性之函数式接口-Supplier、Consumer、Predicate、Function详解

最新推荐文章于 2024-10-05 14:55:37 发布
最新推荐文章于 2024-10-05 14:55:37 发布
阅读量2.3k 收藏 11
点赞数 3
分类专栏： Java 文章标签： java lambda 函数式编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun10367/article/details/108426625
版权
本文深入解析Java函数式接口的定义与应用，包括@FunctionalInterface注解的使用，以及供给型、消费型、判断型和功能型接口的详细说明。通过具体示例，如Supplier、Consumer、Predicate和Function接口的代码演示，帮助读者掌握Lambda表达式的实践技巧。
摘要由CSDN通过智能技术生成

目录

1. 概述

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

Lambda表达式是用来实现SAM接口的，所谓SAM就是Single Abstract Method，即该接口中只有一个抽象方法需要实现，当然该接口可以包含其他非抽象方法。

从应用层面来讲，Java中的Lambda表达式可以看做是接口对应的匿名内部类的简化格式，但是二者在原理上不同。

@FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface，该注解可用于一个接口的定义上：

@FunctionalInterface
public interface MyFunctionalInterface {
	void myMethod();
}

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

JDK1.8之前，核心类库中就已经存在很多SAM接口了，例如：

（1）java.lang.Runnable

（2）java.util.concurrent.Callable

（3）java.util.Comparator

（4）java.lang.Comparable

（5）java.lang.Iterable

（6）java.io.FileFilter

（7）java.lang.reflect.InvocationHandler

…等

但是在JDK1.8，只有部分方法加了 @FunctionalInterface，那些没有加 @FunctionalInterface 的SAM接口，存在将来增加抽象方法变成非SAM接口的风险，因此建议只对加了 @FunctionalInterface 的接口使用Lambda表达式实现。
虽然在JDK1.8，Comparator接口中新增了一个抽象方法boolean equals(Object obj)，但它仍是函数式接口，在接口声明中也加了@FunctionalInterface 注解，因为关于FunctionalInterface注解，官方文档是这样说的：

If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.
如果接口中声明的抽象方法覆盖了java.lang.Object的公共方法，则该方法不会计入接口的抽象方法计数，因为该接口的任何实现都将具有java.lang.Object或其他地方的实现。

JDK1.8在 java.util.function 包增加了很多函数式接口，不过他们可以归纳为四类：供给型接口、消费型接口、功能型接口、判断型接口，一共43个

2. 供给型接口

这类接口名以单词Supplier结尾，Supplier：供应者。对应的Lambda表达式需要“对外提供”数据。

这类接口的抽象方法特点：无参，有返回值；

接口名抽象方法描述
SupplierT get()返回一个对象
BooleanSupplierboolean getAsBoolean()返回一个boolean值
DoubleSupplierdouble getAsDouble()返回一个double值
IntSupplierint getAsInt()返回一个int值
LongSupplierlong getAsLong()返回一个long值

典型代表—Supplier接口

java.util.function.Supplier<T>接口，对应的Lambda表达式需要对外提供一个符合泛型类型的对象数据。接口定义：

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

抽象方法 : T get()

用来获取一个泛型参数指定类型的对象数据。

代码示例：

public class SupplierDemo {
    public static void main(String[] args) {
        String strA = "Hello ";
        String strB = "World";
        
        //传参：Supplier<String> supplier = () -> strA + strB; 
        //调用重写的get方法：get() {return strA + strB;}
        String result = getString(() -> strA + strB);
        System.out.println(result);
    }

    static String getString(Supplier<String> supplier) {
        return supplier.get();
    }
}

求数组元素最大值

使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值，接口的泛型使用java.lang.Integer类。

代码示例:

public class IntArrayTest {
    public static void main(String[] args) {
        int[] array = {10, 5, 12, 3, 7, 15};
        pringMax(() -> {
            int max = array[0];
            for (int i = 1; i < array.length; i++) {
                if (array[i] > max) {
                    max = array[i];
                }
            }
            return max;
        });
    }

    static void pringMax(Supplier<Integer> supplier) {
        int max = supplier.get();
        System.out.println(max);
    }
}

3. 消费型接口

这类接口名称以单词Consumer结尾，Consumer：消费者。对应的Lambda表达式需要接收参数来完成功能。

这类接口的抽象方法特点：有参、无返回值

接口名抽象方法描述
Consumervoid accept(T t)接收一个对象用于完成功能
BiConsumer<T,U>void accept(T t, U u)接收两个对象用于完成功能
DoubleConsumervoid accept(double value)接收一个double值
IntConsumervoid accept(int value)接收一个int值
LongConsumervoid accept(long value)接收一个long值
ObjDoubleConsumervoid accept(T t, double value)接收一个对象和一个double值
ObjIntConsumervoid accept(T t, int value)接收一个对象和一个int值
ObjLongConsumervoid accept(T t, long value)接收一个对象和一个long值

典型代表—Consumer接口

java.util.function.Consumer<T> ：接收一个对象，来执行相关操作，其数据类型由泛型参数决定。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

抽象方法：void accept(T t)

接收一个对象，来执行相关操作

public class ConsumerDemo {
    public static void main(String[] args) {
        String str = "Hello world";
        //字符串转为小写
        convert(s -> System.out.println(s.toLowerCase()), str);
    }

    static void convert(Consumer<String> consumer, String str) {
        consumer.accept(str);
    }
}

默认方法：andThen，如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以：接收一个数据的时候，首先做一个操作，然后再做一个操作，实现组合。源码：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

代码示例：大小写转换

public class ConsumerDemo {
    public static void main(String[] args) {
        String str = "Hello world";
        //Consumer<String> c1 = s1 -> System.out.println(s1.toLowerCase());
        //Consumer<String> c2 = s2 -> System.out.println(s2.toUpperCase());
        convert(s1 -> System.out.println(s1.toLowerCase()),
                s2 -> System.out.println(s2.toUpperCase()), str);
    }

    static void convert(Consumer<String> c1, Consumer<String> c2, String str) {
        c1.accept(str);
        c2.accept(str);
        //andThen方法返回值为Consumer<T>接口的实现类对象：(T t) -> { accept(t); after.accept(t); }
        //先小写后大写：c1.accept(str); c2.accept(str);
        c1.andThen(c2).accept(str);
        //先大写后小写：c2.accept(str); c1.accept(str)
        c2.andThen(c1).accept(str);
    }
}

上面代码中，c1.andThen(c2) 返回Consumer接口的实现类对象，该对象调用accept(str)，此时重写的accept(str)方法的方法体为{c1.accept(str); c2.accept(str)}

4. 判断型接口

这类接口名称以单词Predicate结尾，Predicate：断言、判断。对某种类型的数据进行判断，从而得到一个boolean值结果。

这类接口的抽象方法特点：有参、返回值类型是boolean

接口名抽象方法描述
Predicateboolean test(T t)接收一个对象
BiPredicate<T,U>boolean test(T t, U u)接收两个对象
DoublePredicateboolean test(double value)接收一个double值
IntPredicateboolean test(int value)接收一个int值
LongPredicateboolean test(long value)接收一个long值

典型代表—Predicate接口

接口定义：

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
	//实现“与逻辑”方法
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
	//实现“非逻辑”方法
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
	//实现“或逻辑”方法
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
	//两个对象的equals方法比较
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

抽象方法：boolean test(T t)，用于条件判断的场景，条件判断的标准是传入的Lambda表达式逻辑

代码示例：

输出正数数组中的所有偶数：

public class PredicateTest {
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 6, 7, 10, 15, 20};
        System.out.println("所有偶数：");
        eval(array, n -> n%2 == 0);
    }

    static void eval(int[] array, Predicate<Integer> p) {
        for (int i : array) {
            if (p.test(i)) {
                System.out.println(i);
            }
        }
    }
}

默认方法：and，既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and ，源码：

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

输出大于等于6所有偶数：

public class PredicateTest {
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 6, 7, 10, 15, 20};
        System.out.println("大于等于6所有偶数：");
        eval(array, m -> m >= 6, n -> n%2 == 0);
    }

    static void eval(int[] array, Predicate<Integer> p1, Predicate<Integer> p2) {
        for (int i : array) {
            if (p1.and(p2).test(i)) {
                System.out.println(i);
            }
        }
    }
}

默认方法：or，与 and 的“与”类似，默认方法 or 实现逻辑关系中的或，源码：

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

输出大于6的整数或偶数：

public class PredicateTest {
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 6, 7, 10, 15, 20};
        System.out.println("大于6的整数或偶数：");
        eval(array, m -> m >= 6, n -> n%2 == 0);
    }

    static void eval(int[] array, Predicate<Integer> p1, Predicate<Integer> p2) {
        for (int i : array) {
            if (p1.or(p2).test(i)) {
                System.out.println(i);
            }
        }
    }
}

默认方法：negate，实现逻辑关系中的非，源码：

default Predicate<T> negate() {
    return (t) -> !test(t);
}

输出不大于7的整数：

public class PredicateTest {
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 6, 7, 10, 15, 20};
        System.out.println("不大于7的整数：");
        eval(array, n -> n > 7);
    }

    static void eval(int[] array, Predicate<Integer> p) {
        for (int i : array) {
            if (p.negate().test(i)) {
                System.out.println(i);
            }
        }
    }
}

5. 功能型接口

这类接口名称以单词Function或Operator结尾，用于完成某项功能并返回数据

这类接口的抽象方法特点：有参数、有返回值

接口名抽象方法描述
Function<T,R>R apply(T t)接收一个T类型对象，返回一个R类型对象结果
UnaryOperatorT apply(T t)接收一个T类型对象，返回一个T类型对象结果
DoubleFunctionR apply(double value)接收一个double值，返回一个R类型对象
IntFunctionR apply(int value)接收一个int值，返回一个R类型对象
LongFunctionR apply(long value)接收一个long值，返回一个R类型对象
ToDoubleFunctiondouble applyAsDouble(T value)接收一个T类型对象，返回一个double
ToIntFunctionint applyAsInt(T value)接收一个T类型对象，返回一个int值
ToLongFunctionlong applyAsLong(T value)接收一个T类型对象，返回一个long值
DoubleToIntFunctionint applyAsInt(double value)接收一个double值，返回一个int值
DoubleToLongFunctionlong applyAsLong(double value)接收一个double值，返回一个long值
IntToDoubleFunctiondouble applyAsDouble(int value)接收一个int值，返回一个double值
IntToLongFunctionlong applyAsLong(int value)接收一个int值，返回一个long值
LongToDoubleFunctiondouble applyAsDouble(long value)接收一个long值，返回一个double值
LongToIntFunctionint applyAsInt(long value)接收一个long值，返回一个int值
DoubleUnaryOperatordouble applyAsDouble(double operand)接收一个double值，返回一个double值
IntUnaryOperatorint applyAsInt(int operand)接收一个int值，返回一个int值
LongUnaryOperatorlong applyAsLong(long operand)接收一个long值，返回一个long值
BiFunction<T,U,R>R apply(T t, U u)接收一个T类型和一个U类型对象，返回一个R类型对象
BinaryOperatorT apply(T t, T u)接收两个T类型对象，返回一个T类型对象
ToDoubleBiFunction<T,U>double applyAsDouble(T t, U u)接收一个T类型和一个U类型对象，返回一个double值
ToIntBiFunction<T,U>int applyAsInt(T t, U u)接收一个T类型和一个U类型对象，返回一个int值
ToLongBiFunction<T,U>long applyAsLong(T t, U u)接收一个T类型和一个U类型对象，返回一个long值
DoubleBinaryOperatordouble applyAsDouble(double left, double right)接收两个double值，返回一个double值
IntBinaryOperatorint applyAsInt(int left, int right)接收两个int值，返回一个int值
LongBinaryOperatorlong applyAsLong(long left, long right)接收两个long值，返回一个long值

典型代表—Function接口

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据

接口定义：

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

抽象方法：R apply(T t)

Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。

类似于数学中的函数：
y = f ( x ) y = f(x) y=f(x)
代码演示：将String类型转换为Integer类型。

public class FuntionTest {
    public static void main(String[] args) {
        parse(s -> Integer.parseInt(s), "10");
    }

    static void parse(Function<String, Integer> func , String str) {
        int num =  func.apply(str);
        System.out.println(num);
    }
}

默认方法：compose，源码：

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

compose方法接收一个Function类型的参数，先用传入的Function对象执行对应的apply方法，然后使用当前的Function对象的执行对应的apply方法

代码演示：先将字符串与字符’0’拼接，再转为整数

public class FuntionTest {
    public static void main(String[] args) {
        parse(s1 -> Integer.parseInt(s1), s2 -> s2 + '0', "10");
    }

    static void parse(Function<String, Integer> func1, Function<String, String> func2 , String str) {
        //先用传入的 func2 = s2 -> s2 + '0'; 执行apply
        //然后用当前的 func1 = s1 -> Integer.parseInt(s1); 执行apply
        int num = func1.compose(func2).apply(str);
        System.out.println(num);
    }
}

默认方法：andThen，源码：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

andThen方法接收一个Function类型的参数，先用当前的Function对象的执行对应的apply方法，然后使用传入的Function对象执行对应的apply方法

代码演示：先将字符串转为整数，然后将此整数乘以10

public class FuntionTest {

    public static void main(String[] args) {
        parse(s -> Integer.parseInt(s), i -> i * 12, "10");
    }

    static void parse(Function<String, Integer> func1, Function<Integer, Integer> func2 , String str) {
        //先用当前的 func1 = s1 -> Integer.parseInt(s1); 执行apply
        //然后用传入的 func2 = i -> i * 12; 执行apply
        int num = func1.andThen(func2).apply(str);
        System.out.println(num);
    }
}
Java 8新特性 内建函数式接口详解
09-01
在本文中，我们将深入探讨Java 8中的四个基本内建函数式接口：Function、Consumer、Supplier和Predicate。 首先，让我们来看看`Function`接口。它代表了一个将一个类型`T`转换成另一个类型`R`的函数。`apply()`方法...
【JAVA8新特性】Supplier接口、Consumer接口、Function接口、Predicate接口
weixin_45325628的博客
12-28 953
Supplier接口、Consumer接口、Function接口、Predicate接口
Java8中的函数式接口详解（Supplier、Consumer、Predicate、Function）
write less , do more
05-01 5737
@FunctionalInterface 代码案例@FunctionalInterface 生产型接口Supplier 代码案例Supplier 消费型接口Consumer 代码案例Consumer 代码案例Consumer_andThen 判断型接口Predicate 代码案例Predicate 代码案例Predicate_and 代码案例Predicate_or 代码案例Predicate_negate 类型转换接口Function 代码案例Function 代码案例Function_andThen
Java Supplier和Consumer接口
最新发布
超级博客
10-05 952
Consumer 接口为函数式编程提供了重要的支持。通过使用 Consumer 接口，我们可以轻松地定义并执行一个接受一个参数并且不返回结果的操作。Consumer 接口特别适用于遍历集合或执行消费型操作。Supplier接口提供了一种灵活而强大的机制来获取或生成数据，使用Supplier接口可以使代码更加灵活和易于维护，特别是在需要生成值或进行惰性计算的情况里。
【JAVA8】快速理解Consumer、Supplier、Predicate与Function
热门推荐
阳阳的博客
11-07 1万+
快速理解Consumer、Supplier、Predicate与Function 一、前言 这几个接口都处在java.util.function包下，Consumer（消费型），Supplier（供给型）、Predicate（判断型）与Function（转换型），暂时不理解他们的类型没关系。 如果对Lambda不怎么理解的同学，可以先移步到...
函数式接口 Consumer、Function、Supplier、Predicate的理解与应用
qq_14962815的博客
12-29 3984
函数式接口（Functional Interface）是只有一个抽象方法的接口，但是可以有多个非抽象方法。函数式接口可以被隐式的转换为Lambda表达式，基于这个特性就可以实现直接将函数作为数据进行传递。通过检查该接口是否有@FunctionalInterface注解，判断该接口是否是一个函数式接口，如果是，编译通过；如果不是，则编译失败。
Java8中的函数式接口Supplier、Consumer、BiConsumer详解
Dream_it_possible！的博客
05-19 8489
函数式编程是JDK1.8的新特性，函数式接口是函数式编程主要的体现，我们可以借助函数接口在函数调用时使用lambda表达式。 一、什么是函数式接口? 函数式接口是java8中新加入的一批接口，他们由@FutionalInterface注解标记的接口，我们可以在rt.jar包下的java.util.function包里找到有很多函数式接口，比如常用的函数式接口有Function、Supplier、consumer和Prdicate等。 我们可以发现，函...
详解JAVA8 函数式接口
08-18
JAVA8 函数式接口详解 JAVA8 函数式接口是JAVA8中的一种重要特性，它提供了一些常用的函数式接口，极大的提高了我们的开发效率。在本文中，我们将详细介绍JAVA8 函数式接口的相关知识点，包括四大核心函数式接口和...
Java 8 新特性终极版指南详解
09-02
Java 8中引入了一个新的包java.util.function，其中定义了大量的函数接口，如Function、Predicate、Consumer、Supplier等，方便我们使用Lambda表达式。2.2 方法引用和构造器引用方法引用是Lambda表达式的补充，它...
浅谈Java 8 新增函数式接口到底是什么
08-26
Java 8 中引入的函数式接口主要有四个：Function、Predicate、Supplier 和 Consumer。 1. Consumer<T>：消费型接口。它接受一个参数，不返回结果。它包含一个抽象方法 void accept(T t)。例如： ```java public ...
JAVA8新特性各种用法详解
05-27
本文将详细解析Java 8新特性中的几个关键点，包括Lambda表达式的使用、内置函数式接口的介绍以及如何利用这些接口进行高效编程。 #### 二、Lambda表达式与访问接口的默认方法 **Lambda表达式**是一种简洁的方法来...
Java8函数式编程接口:Consumer、Supplier、Function、Predicate
青玉白露的博客
06-02 1907
开宗明义 java8的一个新特性就是在java.util.function中提供了四个函数式编程接口，分别是Consumer、Supplier、Function、Predicate。 其中， consumer即消费接口，传入一个参数，并对其进行相应的操作（有点类似于lambda表达式）； supplier即供给接口，可以传入数据，作为一个容器； function即方法接口，主要是用作数据类型之间的转换； predicate即判断接口，传入参数，而后返回判断的结果true/false； 接
Java四大函数式接口（Function、Consumer、Supplier、Predicate）
m0_51666430的博客
06-19 6997
Java四大函数式接口（Function、Consumer、Supplier、Predicate）function 包 函数类型，有传入的参数，也有返回值，点进源码可以看出： 其中T为参数，R为返回值代码示例： 消费类型，即只支出没有收入（有传入参数，没有返回值），点进源码查看： 只有传入的参数T，并没有返回值代码示例： 供给类型，即只有返回值，没有参数，点进源码：只有一个返回值T代码示例： 有输入也有返回值，但返回值类型为boolean，点进源码： T为参数，返回值为boolean代码示例： 搜索复制..
JAVA基础之函数式接口
qq_64377514的博客
05-04 414
比较功能，对一些对象的集合施加了一个整体排序。没有要求每次调用供应商时都会返回新的或不同的结果。表示接受单个输入参数并且不返回结果的操作。表示一个参数的谓词（布尔值函数）。表示接受一个参数并产生结果的函数。以上内容属于自学，可能不是很全面，但为了方便日后的观看和复习，在此发文，如发现有错误请联系博主，欢迎指正。
JAVA8函数之Supplier和Consumer接口使用理解
qq_35946055的博客
03-24 2762
一.Supplier接口 顾名思义,这是一个供应商,提供者.就如一个工厂一样.该类的源码如下: package java.util.function; @FunctionalInterface public interface Supplier<T> { T get(); } 该接口就一个抽象方法get方法,该接口在 JAVA8之函数式接口返回实例篇中第一个示例就是利用的该接口.不用传入任何参数,直接返回一个泛型T的实例.就如同无参构造一样.示例...
判断谓词公式 java_Java8-Consumer、Supplier、Predicate和Function方法总结
weixin_28950543的博客
02-28 949
这几个接口都在 java.util.function 包下的，分别是Consumer(消费型)、supplier(供给型)、predicate(谓词型)、function(功能性)；那么，下面，我们从具体的应用场景来讲讲这个接口的用法！1 Consumer接口从字面意思上我们就可以看得出啦，consumer接口就是一个消费型的接口，通过传入参数，然后输出值，就是这么简单，Java8 的一些方法看起...
Java8新特性之——函数式接口（Function、Consumer、Supplier、Predicate）
dongdong199033的博客
04-08 904
Java 8中的Consumer、Supplier、Predicate和Function都是函数式接口，它们的主要区别在于它们的输入参数和返回值的类型不同。可以看到，这四个接口的主要区别在于它们的输入和输出类型不同，因此它们在不同的场景下具有不同的用途。如果你需要对一个集合中的每个元素执行某个操作，那么可以使用Consumer接口；如果你需要从一个方法中获取一个结果，可以使用Supplier接口；：接受一个输入参数，并返回一个布尔值。：接受一个输入参数，并返回一个结果。：接受一个输入参数，但没有返回值。
简单上手四大函数型接口
qq_57205114的博客
04-05 505
四大函数型接口 1.功能型函数接口（Function<T,R>）：T为参数类型，R为返回值类型 2.消费型函数接口（Consumer<T>）：T为参数类型，没有返回值 3.供给型函数式接口（Supplier<T>）：T为返回值类型，没有参数 4.断言型函数式接口（Predicate<T>）：T为参数类型，返回值为Boolean类型 public class Test9 { public static void main(String[]
4K字超详细讲解！教你如何封装自定义函数式接口
wdj_yyds的博客
08-02 682
我们在实际的开发工作中，经常可以看到类似的业务，比如：如果结果为false则抛出异常。我们可能会以这种形式来完成这样的业务：java复制代码但是我们可以通过Lambda表达式的方式来完成这样的业务，首先我们去编写一个工具类。我们在封装函数式接口时总共需要用到FunctionConsumerSupplier和Runnable四种方式进行调用，而这四种方式各有各的特点，我们也可以根据自己的业务场景来选择不同的接口去封装。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值