Java开发分享

Java 函数式接口

标签： #Java #函数式

概念

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

函数式接口可以被隐式转换为 Lambda 表达式。

FunctionalInterface

JAVA

@

FunctionalInterface // 标明为函数式接口

public interface MyFunctionInterface {

void mrthod(); //抽象方法

}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅

有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只

要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

(该接口是一个标记接口)

常用的函数式接口

Supplier 接口

JAVA

@

FunctionalInterface

public interface Supplier<T> {

T get();

}

用来返回一个值，即供应器

Consumer 接口

JAVA

@

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); };

}

用来消费一个值，即消费器

默认方法

andThen ：组合多个 consumer，可以实现消费数据的时候，首先做

一个操作，然后再做一个操作

JAVA

Consumer<Integer> consumer = ((Consumer<Integer>) i -> Sy

.andThen(i -> System.out.println("b" + i));

Stream.of(1, 2, 3, 4).forEach(consumer);

/ 输出：a1 b1 a2 b2 a3 b3 a4 b4

/

Predicate 接口

JAVA

@

FunctionalInterface

public interface Predicate<T> {

boolean test(T t);

default Predicate<T> negate() {

return (t) -> !test(t);

}

default Predicate<T> and(Predicate<? super T> other)

Objects.requireNonNull(other);

return (t) -> test(t) && other.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);

}

用来判断一个值是否符合条件，即判断器

默认方法

negate ：取反

and ：类似于 &&

or ：类似于 ||

静态方法

isEqual ：返回一个输入值是否等于目标值的 Predicate 接口

Function 接口

JAVA

@

FunctionalInterface

public interface Function<T, R> {

R apply(T t);

default <V> Function<T, V> andThen(Function<? super R

Objects.requireNonNull(after);

return (T t) -> after.apply(apply(t));

}

default <V> Function<V, R> compose(Function<? super V

Objects.requireNonNull(before);

return (V v) -> apply(before.apply(v));

}

static <T> Function<T, T> identity() {

return t -> t;

}

用来将一个值转换成其它类型的值，即转换器

默认方法

andThen ：组合多个 function，可以实现先做一个转换，再做一个转

换

JAVA

Function<Integer, Integer> mapper = ((Function<Integer, I

.andThen(i -> i - 1);

Stream.of(1, 2, 3, 4)

.map(mapper)

.forEach(System.out::println);

/

/ 输出：9 19 29 39

compose ：也是组合多个 function，不过组合顺序跟 andThen 相反

JAVA

Function<Integer, Integer> mapper = ((Function<Integer, I

.compose(i -> i - 1);

Stream.of(1, 2, 3, 4)

.map(mapper)

.forEach(System.out::println);

/

/ 输出：0 10 20 30

静态方法

identity ：不做转换，原样返回输入值

UnaryOperator 接口

JAVA

@

FunctionalInterface

public interface UnaryOperator<T> extends Function<T, T>

static <T> UnaryOperator<T> identity() {

return t -> t;

}

Function 接口的特例，转换前和转换后的类型不变

BiFunction 接口

JAVA

@

FunctionalInterface

public interface BiFunction<T, U, R> {

R apply(T t, U u);

default <V> BiFunction<T, U, V> andThen(Function<? su

Objects.requireNonNull(after);

return (T t, U u) -> after.apply(apply(t, u));

}

Function 接口的另一个版本，接收两个值并返回一个新值

BinaryOperator 接口

JAVA

@

FunctionalInterface

public interface BinaryOperator<T> extends BiFunction<T,T

public static <T> BinaryOperator<T> minBy(Comparator<

Objects.requireNonNull(comparator);

return (a, b) -> comparator.compare(a, b) <= 0 ?

}

public static <T> BinaryOperator<T> maxBy(Comparator<

Objects.requireNonNull(comparator);

return (a, b) -> comparator.compare(a, b) >= 0 ?

}

BiFunction 接口的特例，转换前和转换后的类型不变

Java8 新增的函数式接口

Supplier

接口

描述

Supplier<T>

无参数，返回一个结果

BooleanSupplier 代表了 boolean 值结果的提供方

IntSupplier

LongSupplier

无参数，返回一个 int 类型结果

无参数，返回一个结果 long 类型的值

接口

描述

DoubleSupplier

代表一个 double 值结构的提供方

Consumer

接口

Consumer<T>

IntConsumer

LongConsumer

描述

代表了接受一个输入参数并且无返回的操作

接受一个 int 类型的输入参数，无返回值

接受一个 long 类型的输入参数，无返回值

代表一个接受 double 值参数的操作，并且

不返回结果

DoubleConsumer

接受一个 object 类型和一个 int 类型的输

入参数，无返回值

ObjIntConsumer<T>

BiConsumer<T,U>

ObjLongConsumer<T>

代表了一个接受两个输入参数的操作，并且

不返回任何结果

接受一个 object 类型和一个 long 类型的输

入参数，无返回值

接受一个 object 类型和一个 double 类型的

输入参数，无返回值

ObjDoubleConsumer<T>

Predicate

接口

描述

Predicate<T>

IntPredicate

接受一个输入参数，返回一个布尔值结果

接受一个 int 输入参数，返回一个布尔值的结果

接受一个 long 输入参数，返回一个布尔值类型

结果

LongPredicate

接口

描述

DoublePredicate

代表一个拥有 double 值参数的 boolean 值方法

BiPredicate<T,U> 代表了一个两个参数的 boolean 值方法

Function

接口

Function<T,R>

IntFunction<R>

描述

接受一个输入参数，返回一个结果

接受一个 int 类型输入参数，返回一个结果

接受一个 int 类型输入，返回一个 long 类

型结果

IntToLongFunction

IntToDoubleFunction

LongFunction<R>

接受一个 int 类型输入，返回一个 double

类型结果

接受一个 long 类型输入参数，返回一个结

果

接受一个 long 类型输入，返回一个 int 类

型结果

LongToIntFunction

LongToDoubleFunction

DoubleFunction<R>

DoubleToIntFunction

接受一个 long 类型输入，返回一个

double 类型结果

代表接受一个 double 值参数的方法，并且

返回结果

接受一个 double 类型输入，返回一个 int

类型结果

接受一个 double 类型输入，返回一个

long 类型结果

DoubleToLongFunction

ToIntFunction<T>

接受一个输入参数，返回一个 int 类型结果

接口

描述

接受一个输入参数，返回一个 long 类型结

果

ToLongFunction<T>

接受一个输入参数，返回一个 double 类型

结果

ToDoubleFunction<T>

UnaryOperator

接口

描述

UnaryOperator<T>

接受一个参数为类型 T,返回值类型也为 T

接受一个参数同为类型 int,返回值类型也为

int

IntUnaryOperator

LongUnaryOperator

DoubleUnaryOperator

接受一个参数同为类型 long,返回值类型也

为 long

接受一个参数同为类型 double,返回值类型

也为 double

BiFunction

接口

描述

代表了一个接受两个输入参数的方法，

并且返回一个结果

BiFunction<T,U,R>

接受两个输入参数，返回一个 int 类型

结果

ToIntBiFunction<T,U>

ToLongBiFunction<T,U>

接受两个输入参数，返回一个 long 类

型结果

接受两个输入参数，返回一个 double

类型结果

ToDoubleBiFunction<T,U>

BinaryOperator

接口

描述

代表了一个作用于于两个同类型操作符的操

作，并且返回了操作符同类型的结果

BinaryOperator<T>

接受两个参数同为类型 int,返回值类型也为

int

IntBinaryOperator

LongBinaryOperator

DoubleBinaryOperator

接受两个参数同为类型 long,返回值类型也

为 long

代表了作用于两个 double 值操作符的操

作，并且返回了一个 double 值的结果

参考

详解 JAVA8 函数式接口 {全 } - ---dgw 博客 - 博客园 (cnblogs.com)

Java 8 函数式接口 | 菜鸟教程 (runoob.com)