函数式接口
序言
Jdk8已经发布8年，目前公司一直在使用Java8语法，所以花点时间写一篇关于函数式接口的文章，以便新手学习和老手回顾。
什么是函数式接口
函数是接口（Functional Interface）的定义非常容易理解：只有一个抽象方法的接口，就是函数式接口（可以有多个default修饰的普通方法）。可以通过Lambda表达式来创建函数式接口的对象。
基本函数式接口
Jdk8定义了四个基本函数式接口，分别是：Consumer、Predicate、Supplier、Function，以下是它们的代码
Consumer（消费）：
// Consumer代码片段
@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); };
}
}
Predicate（预测）:
// 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);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Supplier（提供）：
// Supplier代码片段
@FunctionalInterface
public interface Supplier<T> {
//抽象方法
T get();
}
Function（函数）:
// Function代码片段
@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;
}
}
扩展函数式接口
以上定义的4种函数式接口能解决我们开发的一部分需求，但仔细思考一下，发现Consumer、Function、Predicate只有一个参数，如果我们开发项目过程中，怎么解决多个参数的情况呢？如果需要Supplier指定的数据类型，或者是返回某个指定类的子类呢？明显这种情况下无法满足我们的需求，在此情况下，Jdk8给我们提供了额外的函数式接口
比如：
// An highlighted block
Consumer -> BiConsumer、DoubleConsumer、IntConsumer...（java.util.function）
Function -> BiFunction、IntFunction、LongFunction...（java.util.function）
Predicate -> IntPredicate、IntPredicate、DoublePredicate...（java.util.function）
Supplier -> BooleanSupplier、IntSupplier、LongSupplier...（java.util.function）
还有很多扩展的函数式接口没列出来，如果有兴趣可以在java.utils.function包里查看
自定义函数式接口
这里才是我想说的，嘻嘻，如果你觉得Jdk8给你提供的函数式接口还不能满足你的胃口，或者说你想自己定义函数式接口。那么请看这里，我定义了四个函数式接口，分别是
| 基本函数式接口 | 自定义函数式接口 | 调用 |
|---|---|---|
| Consumer | ConsumerUtils | ConsumerInstance |
| Function | FunctionUtils | FunctionInstance |
| Predicate | PredicateUtils | PredicateInstance |
| Supplier | SupplierUtils | SupplierInstance |
ConsumerUtils：
// An highlighted block
package com.cherry.blog.util.func.instance.utils;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* 自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class ConsumerUtils {
@FunctionalInterface
public interface ConsumerInterface1<A> {
void consumer1(A a);
default void preCheckConsumer1(A a) {
if (a != null) {
consumer1(a);
}
}
}
@FunctionalInterface
public interface ConsumerInterface2<A, B> {
void consumer2(A a, B b);
default void preCheckConsumer2(A a, B b) {
if (a != null && b != null) {
consumer2(a, b);
}
}
}
@FunctionalInterface
public interface ConsumerInterface3<A, B, C> {
void consumer3(A a, B b, C c);
default void preCheckConsumer3(A a, B b, C c) {
if (a != null && b != null && c != null) {
consumer3(a, b, c);
}
}
}
@FunctionalInterface
public interface ConsumerInterface4<A, B, C, D> {
void consumer4(A a, B b, C c, D d);
default void preCheckConsumer4(A a, B b, C c, D d) {
if (a != null && b != null && c != null && d != null) {
consumer4(a, b, c, d);
}
}
}
@FunctionalInterface
public interface ConsumerInterface5<A, B, C, D, E> {
void consumer5(A a, B b, C c, D d, E e);
default void preCheckConsumer5(A a, B b, C c, D d, E e) {
if (a != null && b != null && c != null && d != null && e != null) {
consumer5(a, b, c, d, e);
}
}
}
@FunctionalInterface
public interface ConsumerInterface6<A, B, C, D, E, F> {
void consumer6(A a, B b, C c, D d, E e, F f);
default void preCheckConsumer5(A a, B b, C c, D d, E e, F f) {
if (a != null && b != null && c != null && d != null && e != null && f != null) {
consumer6(a, b, c, d, e, f);
}
}
}
}
FunctionUtils
// An highlighted block
package com.cherry.blog.util.func.instance.utils;
/**
* 自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class FunctionUtils {
@FunctionalInterface
public interface FunctionInterface1<A, R> {
R function1(A a);
default R preCheckFunction1(A a) {
return a != null ? function1(a) : null;
}
}
@FunctionalInterface
public interface FunctionInterface2<A, B, R> {
R function2(A a, B b);
default R preCheckFunction2(A a, B b) {
return (a != null && b != null) ? function2(a, b) : null;
}
}
@FunctionalInterface
public interface FunctionInterface3<A, B, C, R> {
R function3(A a, B b, C c);
default R preCheckFunction3(A a, B b, C c) {
return (a != null && b != null && c != null) ? function3(a, b, c) : null;
}
}
@FunctionalInterface
public interface FunctionInterface4<A, B, C, D, R> {
R function4(A a, B b, C c, D d);
default R preCheckFunction4(A a, B b, C c, D d) {
return (a != null && b != null && c != null && d != null) ? function4(a, b, c, d) : null;
}
}
@FunctionalInterface
public interface FunctionInterface5<A, B, C, D, E, R> {
R function5(A a, B b, C c, D d, E e);
default R preCheckFunction5(A a, B b, C c, D d, E e) {
return (a != null && b != null && c != null && d != null && e != null) ? function5(a, b, c, d, e) : null;
}
}
@FunctionalInterface
public interface FunctionInterface6<A, B, C, D, E, F, R> {
R function6(A a, B b, C c, D d, E e, F f);
default R preCheckFunction6(A a, B b, C c, D d, E e, F f) {
return (a != null && b != null && c != null && d != null && e != null && f != null) ? function6(a, b, c, d, e, f) : null;
}
}
}
PredicateUtils:
// An highlighted block
package com.cherry.blog.util.func.instance.utils;
/**
* 自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class PredicateUtils {
@FunctionalInterface
public interface PredicateInterface1<A> {
boolean predicate1(A a);
default boolean preCheckPredicate1(A a) {
return a != null && predicate1(a);
}
}
@FunctionalInterface
public interface PredicateInterface2<A, B> {
boolean predicate2(A a, B b);
default boolean preCheckPredicate2(A a, B b) {
return a != null && b != null && predicate2(a, b);
}
}
@FunctionalInterface
public interface PredicateInterface3<A, B, C> {
boolean predicate3(A a, B b, C c);
default boolean preCheckPredicate3(A a, B b, C c) {
return a != null && b != null && c != null && predicate3(a, b, c);
}
}
@FunctionalInterface
public interface PredicateInterface4<A, B, C, D> {
boolean predicate4(A a, B b, C c, D d);
default boolean preCheckPredicate4(A a, B b, C c, D d) {
return a != null && b != null && c != null && d != null && predicate4(a, b, c, d);
}
}
@FunctionalInterface
public interface PredicateInterface5<A, B, C, D, E> {
boolean predicate5(A a, B b, C c, D d, E e);
default boolean preCheckPredicate5(A a, B b, C c, D d, E e) {
return a != null && b != null && c != null && d != null && e != null && predicate5(a, b, c, d, e);
}
}
@FunctionalInterface
public interface PredicateInterface6<A, B, C, D, E, F> {
boolean predicate6(A a, B b, C c, D d, E e, F f);
default boolean preCheckPredicate6(A a, B b, C c, D d, E e, F f) {
return a != null && b != null && c != null && d != null && e != null && f != null && predicate6(a, b, c, d, e, f);
}
}
}
SupplierUtils:
// An highlighted block
package com.cherry.blog.util.func.instance.utils;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class SupplierUtils {
public interface SupplierInterface<R> {
R supplier();
}
public interface SupplierIntegerInterface<R extends Integer> {
R supplier();
}
public interface SupplierStrInterface<R extends String> {
R supplierStr();
}
public interface SupplierListInterface<R extends List> {
R supplierList();
}
public interface SupplierSetInterface<R extends Set> {
R supplierSet();
}
public interface SupplierMapInterface<R extends Map> {
R supplierMap();
}
}
ConsumerInstance:
// An highlighted block
package com.cherry.blog.util.func.instance;
import com.cherry.blog.util.func.instance.utils.ConsumerUtils;
/**
* consumer自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class ConsumerInstance {
public static <A> void consumer1(A a, ConsumerUtils.ConsumerInterface1<A> consumerInterface1) {
consumerInterface1.preCheckConsumer1(a);
}
public static <A, B> void consumer2(A a, B b, ConsumerUtils.ConsumerInterface2<A, B> consumerInterface2) {
consumerInterface2.preCheckConsumer2(a, b);
}
public static <A, B, C> void consumer3(A a, B b, C c, ConsumerUtils.ConsumerInterface3<A, B, C> consumerInterface3) {
consumerInterface3.preCheckConsumer3(a, b, c);
}
public static <A, B, C, D> void consumer4(A a, B b, C c, D d, ConsumerUtils.ConsumerInterface4<A, B, C, D> consumerInterface4) {
consumerInterface4.preCheckConsumer4(a, b, c, d);
}
public static <A, B, C, D, E> void consumer5(A a, B b, C c, D d, E e, ConsumerUtils.ConsumerInterface5<A, B, C, D, E> consumerInterface5) {
consumerInterface5.preCheckConsumer5(a, b, c, d, e);
}
public static <A, B, C, D, E, F> void consumer6(A a, B b, C c, D d, E e, F f, ConsumerUtils.ConsumerInterface6<A, B, C, D, E, F> consumerInterface6) {
consumerInterface6.preCheckConsumer5(a, b, c, d, e, f);
}
}
FunctionInstance:
// An highlighted block
package com.cherry.blog.util.func.instance;
import com.cherry.blog.util.func.instance.utils.FunctionUtils;
/**
* function自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class FunctionInstance {
public static <A, R> R function1(A a, FunctionUtils.FunctionInterface1<A, R> functionInterface1) {
return functionInterface1.preCheckFunction1(a);
}
public static <A, B, R> R function2(A a, B b, FunctionUtils.FunctionInterface2<A, B, R> functionInterface2) {
return functionInterface2.preCheckFunction2(a, b);
}
public static <A, B, C, R> R function3(A a, B b, C c, FunctionUtils.FunctionInterface3<A, B, C, R> functionInterface3) {
return functionInterface3.preCheckFunction3(a, b, c);
}
public static <A, B, C, D, R> R function4(A a, B b, C c, D d, FunctionUtils.FunctionInterface4<A, B, C, D, R> functionInterface4) {
return functionInterface4.preCheckFunction4(a, b, c, d);
}
public static <A, B, C, D, E, R> R function5(A a, B b, C c, D d, E e, FunctionUtils.FunctionInterface5<A, B, C, D, E, R> functionInterface5) {
return functionInterface5.preCheckFunction5(a, b, c, d, e);
}
public static <A, B, C, D, E, F, R> R function6(A a, B b, C c, D d, E e, F f, FunctionUtils.FunctionInterface6<A, B, C, D, E, F, R> functionInterface6) {
return functionInterface6.preCheckFunction6(a, b, c, d, e, f);
}
}
PredicateInstance:
// An highlighted block
package com.cherry.blog.util.func.instance;
import com.cherry.blog.util.func.instance.utils.PredicateUtils;
/**
* Predicate自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class PredicateInstance {
public static <A> boolean predicate1(A a, PredicateUtils.PredicateInterface1<A> predicateInterface1) {
return predicateInterface1.preCheckPredicate1(a);
}
public static <A, B> boolean predicate2(A a, B b, PredicateUtils.PredicateInterface2<A, B> predicateInterface2) {
return predicateInterface2.preCheckPredicate2(a, b);
}
public static <A, B, C> boolean predicate3(A a, B b, C c, PredicateUtils.PredicateInterface3<A, B, C> predicateInterface3) {
return predicateInterface3.preCheckPredicate3(a, b, c);
}
public static <A, B, C, D> boolean predicate4(A a, B b, C c, D d, PredicateUtils.PredicateInterface4<A, B, C, D> predicateInterface4) {
return predicateInterface4.preCheckPredicate4(a, b, c, d);
}
public static <A, B, C, D, E> boolean predicate5(A a, B b, C c, D d, E e, PredicateUtils.PredicateInterface5<A, B, C, D, E> predicateInterface5) {
return predicateInterface5.preCheckPredicate5(a, b, c, d, e);
}
public static <A, B, C, D, E, F> boolean predicate6(A a, B b, C c, D d, E e, F f, PredicateUtils.PredicateInterface6<A, B, C, D, E, F> predicateInterface6) {
return predicateInterface6.preCheckPredicate6(a, b, c, d, e, f);
}
}
SupplierInstance:
// An highlighted block
package com.cherry.blog.util.func.instance;
import com.cherry.blog.util.func.instance.utils.SupplierUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* supplier自定义函数式接口
*
* @author weiliwang
* @date 2023-6-18
*/
public class SupplierInstance {
public static <R> R supplier(SupplierUtils.SupplierInterface<R> supplierInterface) {
return supplierInterface.supplier();
}
public static <R extends Integer> R supplierInteger(SupplierUtils.SupplierIntegerInterface<R> supplierIntegerInterface) {
return supplierIntegerInterface.supplier();
}
public static <R extends String> R supplierStr(SupplierUtils.SupplierStrInterface<R> supplierStrInterface) {
return supplierStrInterface.supplierStr();
}
public static <R extends List> R supplierList(SupplierUtils.SupplierListInterface<R> supplierListInterface) {
return supplierListInterface.supplierList();
}
public static <R extends Set> R supplierSet(SupplierUtils.SupplierSetInterface<R> supplierSetInterface) {
return supplierSetInterface.supplierSet();
}
public static <R extends Map> R supplierMap(SupplierUtils.SupplierMapInterface<R> supplierMapInterface) {
return supplierMapInterface.supplierMap();
}
}
自定义函数式调用方式
TestDemo（配合lambda使用）：
// TestDemo
public class TestDemo {
public static void main(String[] args) {
Student student1 = Student.builder()
.studentId(1L)
.name("junwu")
.age(27)
.className("computer")
.build();
Student student2 = Student.builder()
.studentId(2L)
.name("taoyang")
.age(29)
.className("math")
.build();
Teacher teacher = Teacher.builder()
.teacherId(1L)
.teacherName("weiliwang")
.age(28)
.className("computer")
.studentList(Arrays.asList(student1, student2))
.build();
consumerTest(teacher);
functionTest(teacher);
predicateTest(teacher);
SupplierTest(teacher);
}
//查找junwu学生的信息
public static void consumerTest(Teacher teacher) {
ConsumerInstance.consumer1(teacher, t -> {
System.out.println(t.getStudentList().stream()
.filter(stu -> StringUtils.equalsIgnoreCase(stu.getName(), "junwu"))
.findFirst().get());
});
}
//查找junwu学生所在的学科
public static void functionTest(Teacher teacher) {
Optional<String> classNameOptional = FunctionInstance.function1(teacher, t -> {
return t.getStudentList().stream()
.filter(stu -> StringUtils.equalsIgnoreCase(stu.getName(), "junwu"))
.findFirst()
.map(Student::getClassName);
});
classNameOptional.ifPresent(System.out::println);
}
//查找是否存在taoyang学生
public static void predicateTest(Teacher teacher) {
System.out.println(PredicateInstance.predicate1(teacher, t -> t.getStudentList().stream()
.anyMatch(stu -> StringUtils.equalsIgnoreCase(stu.getName(), "taoyang"))));
}
//新增chengyang学生信息
public static void SupplierTest(Teacher teacher) {
System.out.println(SupplierInstance.supplier(() -> Student.builder()
.studentId(3L)
.name("chengyang")
.age(27)
.className("math")
.build()));
}
}
4371
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
