文章内容整顿自 博学谷狂野架构师
概述
什么是函数式接口？简略来说就是只有一个形象函数的接口。为了使得函数式接口的定义更加标准，java8 提供了@FunctionalInterface 注解通知编译器在编译器去查看函数式接口的合法性，以便在编译器在编译出错时给出提醒。为了更加标准定义函数接口，给出如下函数式接口定义规定：
- 有且仅有一个形象函数
- 必须要有@FunctionalInterface 注解
- 能够有默认办法
能够看出函数式接口的编写定义非常简单，不晓得大家有没有留神到，其实咱们常常会用到函数式接口，如Runnable 接口，它就是一个函数式接口：
COPY@FunctionalInterfacepublic interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run();}过来咱们会应用匿名外部类来实现线程的执行体：
COPYnew Thread(new Runnable() { @Override public void run() { System.out.println("Hello FunctionalInterface"); } }).start();当初咱们应用Lambda 表达式，这里函数式接口的应用没有体现函数式编程思维，这里输入字符到规范输入流中，产生了副作用，起到了简化代码的作用，当然还有装B。
COPYnew Thread(()->{ System.out.println("Hello FunctionalInterface"); }).start();Java8 util.function 包下自带了43个函数式接口，大体分为以下几类：
- Consumer 生产接口
- Function 性能接口
- Operator 操作接口
- Predicate 断言接口
- Supplier 生产接口
其余接口都是在此基础上变形定制化罢了。
函数式接口具体介绍
这里只介绍最根底的函数式接口，至于它的变体只有明确了根底天然就可能明确
Consumer
消费者接口，就是用来生产数据的。
COPY@FunctionalInterfacepublic interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t); /** * Returns a composed {@code Consumer} that performs, in sequence, this * operation followed by the {@code after} operation. If performing either * operation throws an exception, it is relayed to the caller of the * composed operation. If performing this operation throws an exception, * the {@code after} operation will not be performed. * * @param after the operation to perform after this operation * @return a composed {@code Consumer} that performs in sequence this * operation followed by the {@code after} operation * @throws NullPointerException if {@code after} is null */ default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; }}Consumer 接口中有accept 形象办法，accept承受一个变量，也就是说你在应用这个函数式接口的时候，给你提供了数据，你只有接管应用就能够了；andThen 是一个默认办法，承受一个Consumer 类型，当你对一个数据应用一次还不够爽的时候，你还能再应用一次，当然你其实能够爽无数次，只有始终应用andThan办法。
Function
何为Function呢？比方电视机，给你带来精力上的愉悦，然而它须要用电啊，电视它把电转换成了你荷尔蒙，这就是Function，简略电说，Function 提供一种转换性能。
COPY@FunctionalInterfacepublic interface Function<T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result */ R apply(T t); /** * Returns a composed function that first applies the {@code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of input to the {@code before} function, and to the * composed function * @param before the function to apply before this function is applied * @return a composed function that first applies the {@code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(Function) */ default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } /** * Returns a composed function that first applies this function to * its input, and then applies the {@code after} function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of output of the {@code after} function, and of the * composed function * @param after the function to apply after this function is applied * @return a composed function that first applies this function and then * applies the {@code after} function * @throws NullPointerException if after is null * * @see #compose(Function) */ default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } /** * Returns a function that always returns its input argument. * * @param <T> the type of the input and output objects to the function * @return a function that always returns its input argument */ static <T> Function<T, T> identity() { return t -> t; }}Function 接口 最次要的就是apply 函数，apply 承受T类型数据并返回R类型数据，就是将T类型的数据转换成R类型的数据，它还提供了compose、andThen、identity 三个默认办法，compose 承受一个Function，andThen也同样承受一个Function，这里的andThen 与Consumer 的andThen 相似，在apply之后在apply一遍，compose 则与之相同，在apply之前先apply（这两个apply具体解决内容个别是不同的），identity 起到了相似海关的作用，外国人想要运货进来，总得交点税吧，而后货物能力平安进入中国市场，当然了想不想收税还是你说了算的。
Operator
能够简略了解成算术中的各种运算操作，当然不仅仅是运算这么简略，因为它只定义了运算这个定义，但至于运算成什么样你说了算。因为没有最根底的Operator，这里将通过 BinaryOperator、IntBinaryOperator来了解Operator 函数式接口，先从简略的IntBinaryOperator开始。
IntBinaryOperator
从名字能够晓得，这是一个二元操作，并且是Int 类型的二元操作，那么这个接口能够做什么呢，除了加减乘除，还能够能够实现平方（两个雷同int 数操作起来不就是平方吗），还是先看看它的定义吧：
@FunctionalInterfacepublic interface IntBinaryOperator { /** * Applies this operator to the given operands. * * @param left the first operand * @param right the second operand * @return the operator result */ int applyAsInt(int left, int right);}IntBinaryOperator 接口内只有一个applyAsInt 办法，其接管两个int 类型的参数，并返回一个int 类型的后果，其实这个跟Function 接口的apply 有点像，然而这里限定了，只能是int类型。
BinaryOperator
BinaryOperator 二元操作，看起来它和IntBinaryOperator 是父子关系，实际上这两者没有半点关系，但他们在性能上还是有相似之处的：
COPY@FunctionalInterfacepublic interface BinaryOperator<T> extends BiFunction<T,T,T> { /** * Returns a {@link BinaryOperator} which returns the lesser of two elements * according to the specified {@code Comparator}. * * @param <T> the type of the input arguments of the comparator * @param comparator a {@code Comparator} for comparing the two values * @return a {@code BinaryOperator} which returns the lesser of its operands, * according to the supplied {@code Comparator} * @throws NullPointerException if the argument is null */ public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) <= 0 ? a : b; } /** * Returns a {@link BinaryOperator} which returns the greater of two elements * according to the specified {@code Comparator}. * * @param <T> the type of the input arguments of the comparator * @param comparator a {@code Comparator} for comparing the two values * @return a {@code BinaryOperator} which returns the greater of its operands, * according to the supplied {@code Comparator} * @throws NullPointerException if the argument is null */ public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) >= 0 ? a : b; }}BinaryOperator 是 BiFunction 生的，而IntBinaryOperator 是从石头里蹦出来的，BinaryOperator 本身定义了minBy、maxBy默认办法，并且参数都是Comparator，就是依据传入的比拟器的比拟规定找出最小最大的数据。
Predicate
断言、判断，对输出的数据依据某种规范进行评判，最终返回boolean值：
COPY@FunctionalInterfacepublic interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); /** * Returns a composed predicate that represents a short-circuiting logical * AND of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code false}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ANDed with this * predicate * @return a composed predicate that represents the short-circuiting logical * AND of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } /** * Returns a predicate that represents the logical negation of this * predicate. * * @return a predicate that represents the logical negation of this * predicate */ default Predicate<T> negate() { return (t) -> !test(t); } /** * Returns a composed predicate that represents a short-circuiting logical * OR of this predicate and another. When evaluating the composed * predicate, if this predicate is {@code true}, then the {@code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * {@code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ORed with this * predicate * @return a composed predicate that represents the short-circuiting logical * OR of this predicate and the {@code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } /** * Returns a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)}. * * @param <T> the type of arguments to the predicate * @param targetRef the object reference with which to compare for equality, * which may be {@code null} * @return a predicate that tests if two arguments are equal according * to {@link Objects#equals(Object, Object)} */ static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); }}Predicate的test 接管T类型的数据，返回 boolean 类型，即对数据进行某种规定的评判，如果合乎则返回true，否则返回false；Predicate接口还提供了 and、negate、or，与 取反 或等，isEqual 判断两个参数是否相等等默认函数。
Supplier
生产、提供数据：
COPY@FunctionalInterfacepublic interface Supplier<T> { /** * Gets a result. * * @return a result */ T get();}十分easy，get办法返回一个T类数据，能够提供反复的数据，或者随机种子都能够，就这么简略。
函数式接口实战
Consumer
Consumer 用的太多了，不想说太多，如下：
COPYpublic class Main { public static void main(String[] args) { Stream.of(1,2,3,4,5,6) .forEach(integer -> System.out.println(integer)); //输入1，2，3，4，5，6 }}这里应用规范输入，还是产生了副作用，然而这种水平是能够容许的
Function
转换，将字符串转成长度
COPYpublic class Main { public static void main(String[] args) { Stream.of("hello","FunctionalInterface") .map(e->e.length()) .forEach(System.out::println); }}运算
COPYpublic class FunctionTest { public static void main(String[] args) { public static void main(String[] args) { Function<Integer, Integer> square = integer -> integer * integer; //定义平方运算 List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); list.add(4); list.stream() .map(square.andThen(square)) //四次方 .forEach(System.out::println); System.out.println("------"); list.stream() .map(square.compose(e -> e - 1)) //减一再平方 .forEach(System.out::println); System.out.println("------"); list.stream().map(square.andThen(square.compose(e->e/2))) //先平方而后除2再平方 .forEach(System.out::println); }}后果如下
COPY11681256------0149------041664Operator
BinaryOperator
这里实现找最大值：
COPYpublic class BinaryOperatorTest { public static void main(String[] args) { Stream.of(2,4,5,6,7,1) .reduce(BinaryOperator.maxBy(Comparator.comparingInt(Integer::intValue))).ifPresent(System.out::println); }}IntOperator
这里实现累加性能：
COPYpublic class BinaryOperatorTest { public static void main(String[] args) { IntBinaryOperator intBinaryOperator = (e1, e2)->e1+e2; //定义求和二元操作 IntStream.of(2,4,5,6,7,1) .reduce(intBinaryOperator).ifPresent(System.out::println); }}Predicate
筛选出大于0最小的两个数
COPYpublic class Main { public static void main(String[] args) { IntStream.of(200,45,89,10,-200,78,94) .filter(e->e>0) //过滤小于0的数 .sorted() //天然程序排序 .limit(2) //取前两个 .forEach(System.out::println); }}Supplier
这里始终生产2这个数字，为了能停下来，应用limit
COPYpublic class Main { public static void main(String[] args) { Stream.generate(()->2) .limit(10) .forEach(System.out::println); }}输入后果
COPY2222222222总结
Java8的Stream 基本上都是应用util.function包下的函数式接口来实现函数式编程的，而函数式接口也就只分为 Function、Operator、Consumer、Predicate、Supplier 这五大类，只有能了解把握最根底的五大类用法，其余变种也能举一反三。
本文由
传智教育博学谷狂野架构师教研团队公布。如果本文对您有帮忙，欢送
关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。转载请注明出处！