本篇文章先介绍下java 8之前的回调方式。之后分析下函数接口中几个最常用的接口——Predicate, Consumer, Function，以及他们实际的应用
java 8之前的回调主要使用例如，新建一个监听器接口
[java] view plain copy /** * */ package com.smartchemical.redis_sample.api; /** * @author chenshijue * */ public interface Listener { void onMessage(); } 新建一个监听器，并作为参数传递给发送函数
[java] view plain copy /** * */ package com.smartchemical.redis_sample.serivce; import com.smartchemical.redis_sample.api.ISampleDefault; import com.smartchemical.redis_sample.api.Listener; /** * @author chenshijue * */ public class ListenerSampleImpl implements ISampleDefault { protected void sendMessage(Listener listener){ String newMsg = "new message"; listener.onMessage(newMsg); } @Override public void run() { Listener listener = new MsgListener(); sendMessage(listener); } } 现在来分析函数接口。
函数接口的定义（来自java.lang包FunctionalInterface注解里面的解释）：
[java] view plain copy Conceptually, a functional interface has exactly one abstract method. 函数接口概念上来说，就是只有一个抽象方法的接口。而这个抽象方法，可以被之后的lambda表达式、方法引用、构造函数引用覆盖。
理论上来说，java会将所有符合要求的接口看做函数接口。但通常我们会加上@FunctionalInterface注解，这是良好的编程习惯。
下面开始分析几个常用函数接口，Predicate, Consumer, Function。
1. Predicate
[java] view plain copy package java.util.function; import java.util.Objects; @FunctionalInterface public 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接口只包含一个抽象方法，boolean test(T t)，接受一个参数，返回一个boolean值。从这个抽象方法可以看出，Predicate接口主要作用是判断，例如在collection的removeIf的方法中，Predicate用来接收判断的表达式或者方法，来判断对元素的操作。
[java] view plain copy public void run() { List<Order> orderList1 = new ArrayList<Order>(); for (int i = 0; i < 6; i++){ Order temp = new Order(String.valueOf(i), "man", 100); orderList1.add(temp); } Predicate<Order> filter = o -> o.getAmount() > 99; orderList1.removeIf(filter); } 上例中，Predicate接受一个lambda表达式，o -> o.getAmount() > 99，判断o的金额是否超过99。之后在list的removeIf中传入Predicate，list中的超过99的金额就会被删除。
and()方法，此方法返回一个Predicate<T>类型，意味着and方法可以像nodejs的then一样进行链式判断。例如：
[java] view plain copy public void run() { List<Order> orderList1 = new ArrayList<Order>(); for (int i = 0; i < 6; i++){ Order temp = new Order(String.valueOf(i), "man", 98 + i); orderList1.add(temp); } Predicate<Order> filter = o -> o.getAmount() > 99; Predicate<Order> filter1 = o -> o.getCreatedBy().equals("man"); orderList1.removeIf(filter.and(filter1)); System.out.println(orderList1.size());<span style="white-space:pre"> </span>//结果2 } negate()方法，此方法很简答，就是将test方法的值取非。
or()方法，接受另一个Predicate方法作为参数，将参数方法和本身的test方法取或。or()方法和and()方法一样，可以进行链式判断。
isEqual()方法，这个方法就很有趣了。我们看看它的实现：
[java] view plain copy /** * 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类型的方法，如果参数targetRef为null，则直接返回Objects:null方法。
这个方法有趣的地方在，它接受一个目标对象，返回的不是boolean值，而是一个方法（object -> targetRef.equals(object)），此方法接受另一个对象为参数，判断两个对象是否相等。下面有一个例子便于理解。
[java] view plain copy public void run() { List<Order> orderList1 = new ArrayList<Order>(); for (int i = 0; i < 6; i++){ Order temp = new Order(String.valueOf(i), "man", 98 + i); orderList1.add(temp); } Predicate<Order> filter1 = Predicate.isEqual(orderList1.get(2)); Predicate<Order> filter2 = o -> o.getAmount() > 99; Predicate<Order> filter3 = o -> o.getCreatedBy().equals("man"); orderList1.removeIf(filter1.and(filter2).and(filter3)); System.out.println(orderList1.size()); //结果为5 } 以上代码，filter1为判断元素是否和orderList1.get(2)元素相等的方法，filter2是判断金额是否超过99的方法，filter3是判断创建人是否是man的方法。三个filter满足的元素只有一个，因此orderList1中只有一个元素被删除。 2. Consumer
[java] view plain copy package java.util.function; import java.util.Objects; /** * Represents an operation that accepts a single input argument and returns no * result. Unlike most other functional interfaces, {@code Consumer} is expected * to operate via side-effects. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is {@link #accept(Object)}. * * @param <T> the type of the input to the operation * * @since 1.8 */ @FunctionalInterface public 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接口用来表示处理元素的方法。和Predicate方法不同，Predicate只是判断元素是否满足某种条件的函数接口，而Consumer是要对某元素进行操作的函数接口。
accept()方法接受一个参数，不返回结果。我们可以对参数进行处理，当然也可以不处理。
andThen()方法为此接口添加链式处理。
举个简单的例子：
[java] view plain copy public void run() { List<Order> orderList1 = new ArrayList<Order>(); for (int i = 0; i < 6; i++){ Order temp = new Order(String.valueOf(i), "man", 98 + i); orderList1.add(temp); } Consumer<Order> con = o -> o.setAmount(200); orderList1.forEach(con.andThen(o -> o.setCreatedBy("women"))); for (Order order :orderList1){ System.out.println(order); } } 结果：
[java] view plain copy Order Id:0 Created by:women Amount:200.0 Order Id:1 Created by:women Amount:200.0 Order Id:2 Created by:women Amount:200.0 Order Id:3 Created by:women Amount:200.0 Order Id:4 Created by:women Amount:200.0 Order Id:5 Created by:women Amount:200.0
3. Function
[java] view plain copy package java.util.function; import java.util.Objects; @FunctionalInterface public 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; } } predicate 仅仅是判断，consumer是修改，那么function就可以理解为映射（或者说可以用来做映射），即将T映射为R。
我们还是来看一个函数接口唯一的抽象方法apply()，接受一个T参数，返回R参数。意思就是可以将T参数做相应的处理，之后返回R参数。
Function函数接口典型应用可以在Stream中找到。Stream中的<R> Stream<R> map(Function<? super T, ? extends R> mapper)方法，接受一个Function接口。在之前的博客可以找到，List可以返回Stream对象，可以用map方法做很多事。例如，转换大小写：
[java] view plain copy List<String> output = wordList.stream().map(String::toUpperCase).collect(Collectors.toList()); 例如，计算平方根：
[java] view plain copy List<Integer> nums = Arrays.asList(1, 2, 3, 4); List<Integer> squareNums = nums.stream().map(n -> n * n).collect(Collectors.toList());
再看看Function的其他方法：
compose()方法，用于在当前方法前添加一个方法，并合并两个方法，两个方法之间的参数是必须有因果关系的。例如<V, T>到 <T, R>混合之后，变成<V, R>。
andThen()方法，和compose相反，用于在当前方法后添加一个方法，并合并两个方法，两个方法之间的参数是必须有因果关系的。例如<T, R>到 <R, V>混合之后，变成<T, V>。
identity()方法，返回一个始终返回输入参数的方法。