在前面一篇文章中简单介绍了Lambda表达式，我们知道使用Lambda表达式是需要使用函数式接口的，那么岂不是在开发过程中需要定义许多函数式接口？当时我就有这个疑问，每次还需要自定义一个纯函数式接口，也挺烦的。
后来了解到其实不然，Java8 其实已经为我们定义好了4类内置函数式接口，这4类接口已经可以解决我们开发过程中绝大部分的问题，只有一小部分比较特殊的情况需要我们自己去定义函数式接口，本文就简单来学习一下Java8内置的4大核心函数式接口。
一、Consumer<T>：消费型接口（void accept(T t)）
@FunctionalInterface public interface Consumer<T> { /** * Performs this operation on the given argument. * @param t the input argument */ void accept(T t); }
// 消费型接口Consumer<T>
@Test
public void test1 () {
consumo(500, (x) -> System.out.println(x));
}
public void consumo (double money, Consumer<Double> c) {
c.accept(money);
}
这是一个简单的例子，我们需要了解的就是我们把 lambda 表达式 (x) -> System.out.println(x) 当做一个参数（参数为函数），传递给了 方法 consumo，方法 consumo 里是用 消费型接口 Consumer 接参的，然后就可以直接调用 消费型接口 的 accept 方法。
以上为消费型接口，有参数，无返回值类型的接口。
二、Supplier<T>：供给型接口（T get（））
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
* @return a result
*/
T get();
}
// 供给型接口，Supplier<T>
@Test
public void test2 () {
Random ran = new Random();
List<Integer> list = supplier(10, () -> ran.nextInt(10));
for (Integer i : list) {
System.out.println(i);
}
}
/**
* 随机产生sum个数量得集合
* @param sum 集合内元素个数
* @param sup
* @return
*/
public List<Integer> supplier(int sum, Supplier<Integer> sup){
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < sum; i++) {
list.add(sup.get());
}
return list;
}
具体同上面分析咯，这就是一个供给类型的接口，只有产出，没有输入，就是只有返回值，没有入参。
三、Function<T, R>：函数型接口（R apply（T t））
@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);
}
import java.util.function.Function;
public class Test2 {
// 函数型接口：Function<R, T>
public static void main(String[] args) {
String newStr = strHandler("abc",(str)->str.toUpperCase());
System.out.println(newStr);
newStr = strHandler(" abc ",(str)->str.trim());
System.out.println(newStr);
}
/**
* 字符串操作
* @param str 需要处理得字符串
* @param fun Function接口
* @return 处理之后得字符传
*/
public static String strHandler(String str, Function<String,String> fun){
return fun.apply(str);
}
}
我们可以看到第一个输出：ABC，第二个输出：abc。这就是一个函数型接口，输入一个类型得参数，输出一个类型得参数，当然两种类型可以一致。
四、Predicate<T>：断言型接口（boolean test（T t））
@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);
}
import java.util.function.Predicate;
public class Test2 {
// 断言型接口：Predicate<T>
public static void main(String[] args) {
List<String> list = Arrays.asList("hello","jiangshuying","lambda","www","ok","q");
List<String> ret = filterStr(list,(str)->str.length()>2);
System.out.println(ret);
}
/**
* 过滤集合
* @param list
* @param pre
* @return
*/
public static List<String> filterStr(List<String> list, Predicate<String> pre){
ArrayList<String> arrayList = new ArrayList<>();
for(String str:list){
if(pre.test(str)) {
arrayList.add(str);
}
}
return arrayList;
}
}
上面例子判断一些字符串数组判断长度>2的字符串，这就是一个断言型接口，输入一个参数，输出一个boolean类型得返回值。
五、其他类型的一些函数式接口
除了上述得4种类型得接口外还有其他的一些接口供我们使用：
1、.BiFunction<T, U, R> ：参数类型有2个，为T，U，返回值为R，其中方法为R apply(T t, U u)
2、.UnaryOperator<T>(Function子接口)：参数为T，对参数为T的对象进行一元操作，并返回T类型结果，其中方法为T apply(T t)
3、.BinaryOperator<T>(BiFunction子接口)：参数为T，对参数为T得对象进行二元操作，并返回T类型得结果，其中方法为T apply（T t1， T t2）
4、.BiConsumcr(T, U) ：参数为T，U无返回值，其中方法为 void accept(T t, U u)
5、.ToIntFunction<T>、ToLongFunction<T>、ToDoubleFunction<T>：参数类型为T，返回值分别为int，long，double，分别计算int，long，double得函数。
6、.IntFunction<R>、LongFunction<R>、DoubleFunction<R>：参数分别为int，long，double，返回值为R。
以上就是Java8内置得核心函数式接口，其中包括了大部分得方法类型，所以可以在使用得时候根据不同得使用场景去选择不同得接口使用。