上篇博客Java 8 Lambda学习笔记（一）主要记录了Lambda表达式的相关知识点，这篇博客将重点介绍函数式接口。
前面也说了，函数式接口其实本质上还是一个接口，但是它是一种特殊的接口：SAM类型的接口（Single Abstract Method）。
函数式接口有三个特性：
1. 该接口只有一个抽象方法，多了不行，少了也不行。
2. 可以有静态方法和默认方法，因为这两种方法都是已经实现的了。
3. 抽象方法一定不能跟Object类中的方法同名。
@FunctionalInterface
interface Fun{
//只设置一个抽象方法 ------可以正常运行
abstract int spend(int remaining,int money);
//加入静态方法和默认方法 ----可以正常运行
static void staticMethod() {
System.out.println("There is a static method!");
}
default void defaultMethod() {
System.out.println("There is a default method!");
}
//设置Object中可以重写的抽象方法 ----编译报错
// abstract boolean equals(Object obj);
}Java 8 新特性提供了函数式接口，是为了更好的支持函数式编程。Java也提供了注解@FunctionalInterface，标注了该注解的接口，编译器就会自动帮我们检查该接口是否符合函数式接口的格式。
配合Lambda表达式的具体使用
函数式接口就是用来配套Lambda表示使用的。也就是说，一个自定义的函数接口，与之对应的Lambda表达式的参数就是这个默认抽象方法的参数，返回值就是这个默认抽象方法的返回值。
package com.wjb.lambda;
/**
* 函数式接口：
* 1.只能有一个抽象方法
2.可以有静态方法和默认方法，因为这两种方法都是已经实现的了
3.这个抽象方法一定不能跟Object类中的方法同名。
* @author Administrator
*
*/
@FunctionalInterface
interface Fun{
//只设置一个抽象方法 ------可以正常运行
abstract int spend(int remaining,int money);
//加入静态方法和默认方法 ----可以正常运行
static void staticMethod() {
System.out.println("There is a static method!");
}
default void defaultMethod() {
System.out.println("There is a default method!");
}
//设置Object中可以重写的抽象方法 ----编译报错
// abstract boolean equals(Object obj);
}
public class FunInterface{
public static void main(String[] args) {
Fun fun = (a,b) -> (a-b); //参数就是spend()方法的参数，返回值a-b就是spend()方法的返回值
System.out.println(fun.spend(100, 5));
}
}五个常用的函数接口
java提供的函数接口在java.util.function包中，其中比较重要的是以下5个接口。我认为jdk8给我们提供的这些接口是提供了一些模式(帮助我们抽象出来了一些行为)，在使用的时候根据官方抽象的接口进行实现也更加方便。
1.Consumer (消费模式)
功能: 顾名思义，就是消费掉传入的一个泛型对象，不返回任何值。那这个接口有什么实际使用场景呢？其实如果查看foreach方法的底层代码的话，这个方法所需要的参数就必须是一个Consumer接口类型的参数。
查看Consumer接口的源码可以知道，其唯一的抽象方法是
void accept(T t);下面写一个实例来跑一下：
/**
* consumer接口测试
*/
@Test
public void test_Consumer() {
//1. 使用consumer接口实现方法
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
stream.forEach(consumer);
System.out.println("********************");
//2.使用lambda表达式，forEach方法需要的就是一个Consumer接口
stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
stream.forEach(consumer1);
//更直接的方式
//stream.forEach((s) -> System.out.println(s));
System.out.println("********************");
//3.使用方法引用，方法引用也是一个consumer
stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
Consumer consumer2 = System.out::println;
stream.forEach(consumer);
//更直接的方式
//stream.forEach(System.out::println);
}分析代码可知：
在代码1中，我们直接创建 Consumer 接口，并且实现了一个名为 accept 的方法，当我们发现 forEach 需要一个 Consumer类型的参数的时候，传入之后，就可以输出对应的值了。代码2中，我们使用lambda表达式作为Consumer。仔细的看一下你会发现，lambda 表达式返回值就是一个 Consumer；所以，你也就能够理解为什么 forEach 方法可以使用 lamdda 表达式作为参数了吧。
代码3中，我们用了一个方法引用的方式作为一个 Consumer ，同时也可以传给 forEach 方法。
当然，除了上面使用的 Consumer 接口，还可以使用下面这些 Consumer 接口。IntConsumer、DoubleConsumer、LongConsumer、BiConsumer，使用方法和上面一样。
看完上面的实例我们可以总结为两点。
① Consumer是一个接口，并且只要实现一个 accept 方法，就可以作为一个“消费者”输出信息。
② forEach 方法的参数必须是Consumer 类型，所以只要lambda 表达式、方法引用的返回值符合Consumer类型 ，他们就能够作为 forEach 方法的参数，并且输出一个值。
2.Supplier (生产模式)
功能:与Consumer接口相反，Supplier接口是不传递参数，只返回一个值。我们来看一下源码
T get();可以理解为，不接受任何参数，返回一个值，究竟返回什么值由调用者决定----Lambda表达式的制造者。其实，说白了就是一个容器，可以用来存储数据，然后可以供其他方法使用的这么一个接口。
下面具体实现一下：
**
* Supplier接口测试，supplier相当一个容器或者变量，可以存储值
*/
@Test
public void test_Supplier() {
//① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
//返回一个随机值
return new Random().nextInt();
}
};
System.out.println(supplier.get());
System.out.println("********************");
//② 使用lambda表达式，
supplier = () -> new Random().nextInt();
System.out.println(supplier.get());
System.out.println("********************");
//③ 使用方法引用
Supplier<Double> supplier2 = Math::random;
System.out.println(supplier2.get());
}我们通过创建一个 Supplier 对象，实现了一个 get 方法，这个方法无参数，返回一个值；所以，每次使用这个接口的时候都会返回一个值，并且保存在这个接口中，所以说是一个容器。
下面我们再来看看Supplier具体的使用场景：
/**
* Supplier接口测试2，使用需要Supplier的接口方法
*/
@Test
public void test_Supplier2() {
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
//返回一个optional对象
Optional<Integer> first = stream.filter(i -> i > 4)
.findFirst();
//optional对象有需要Supplier接口的方法
//orElse，如果first中存在数，就返回这个数，如果不存在，就放回传入的数
System.out.println(first.orElse(1));
System.out.println(first.orElse(7));
System.out.println("********************");
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
//返回一个随机值
return new Random().nextInt();
}
};
//orElseGet，如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值
System.out.println(first.orElseGet(supplier));
} 使用方法获取到一个 Optional 对象，然后，在 Optional 对象中有 orElse 方法 和 orElseGet 是需要一个 Supplier 接口的。
-
orElse：如果first中存在数，就返回这个数，如果不存在，就放回传入的数
-
orElseGet：如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值
除了上面使用的 Supplier 接口，还可以使用下面这些 Supplier 接口。IntSupplier 、DoubleSupplier 、LongSupplier 、BooleanSupplier，使用方法和上面一样。
Supplier 总结
① Supplier 接口可以理解为一个容器，用于装数据的。
② Supplier 接口有一个 get 方法，可以返回值。
3.Predicate （判断模式--谓词）
功能：传递一个参数，返回一个Boolean值。其实，这个就是一个类似于 bool 类型的判断的接口。
还是来看一个实例
/**
* Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用
*/
@Test
public void test_Predicate() {
//① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
Predicate<Integer> predicate = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if(integer > 5){
return true;
}
return false;
}
};
System.out.println(predicate.test(6));
System.out.println("********************");
//② 使用lambda表达式，
predicate = (t) -> t > 5;
System.out.println(predicate.test(1));
System.out.println("********************");
}这段代码中，创建了一个 Predicate 接口对象，其中，实现类 test 方法，需要传入一个参数，并且返回一个 bool 值，所以这个接口作用就是判断！然后，调用 test 方法，传入一个值，就会返回一个 bool 值。也可以使用lambda 表达式返回一个 Predicate 接口，然后调用 test 方法！
好，我们再看一个实例，看看Predicate具体的使用场景：
/**
* Predicate谓词测试，Predicate作为接口使用
*/
@Test
public void test_Predicate2() {
//① 将Predicate作为filter接口，Predicate起到一个判断的作用
Predicate<Integer> predicate = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if(integer > 5){
return true;
}
return false;
}
};
Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
list.forEach(System.out::println);
System.out.println("********************");
}这段代码，首先创建一个 Predicate 对象，然后实现 test 方法，在 test 方法中做一个判断：如果传入的参数大于 5 ，就返回 true，否则返回 false；然后调用 Stream 的 filter 方法，filter 方法需要的参数就是 Predicate 接口，所以在这里只要大于 5 的数据就会输出。
总结一下两点：
① Predicate 是一个谓词型接口，其实只是起到一个判断作用。
② Predicate 通过实现一个 test 方法做判断。
4. Function （功能模式）
功能:传递1个参数，返回1个参数。作用就是转换作用，将输入数据转换成另一种形式的输出数据。
第一个实例：
/**
* Function测试，function的作用是转换，将一个值转为另外一个值
*/
@Test
public void test_Function() {
//① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
Function<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length();//获取每个字符串的长度，并且返回
}
};
Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
Stream<Integer> stream1 = stream.map(function);
stream1.forEach(System.out::println);
System.out.println("********************");
}输出结果是：3 5 7
上面代码创建了一个 Function 接口对象，实现了一个 apply 方法，这个方法有一个输入参数和一个输出参数。其中，泛型的第一个参数是转换前的类型，第二个是转化后的类型。
在上面的代码中，就是获取字符串的长度，然后将每个字符串的长度作为返回值返回。
在 Function 接口的重要应用不得不说 Stream 类的 map 方法了，map 方法传入一个 Function 接口，返回一个转换后的 Stream类。
除了上面使用的 Function 接口，还可以使用下面这些 Function 接口。
IntFunction 、DoubleFunction 、LongFunction 、ToIntFunction 、ToDoubleFunction 、DoubleToIntFunction 等等，使用方法和上面一样。
总结一下：
① Function 接口是一个功能型接口，是一个转换数据的作用。
② Function 接口实现 apply 方法来做转换。
5.BiXXXX (BiFunction为例)
功能: 传递两个个参数，得到一个返回值。
唯一的抽象方法是apply。
R apply(T t, U u);下面看一个实例：
public class FunctionTest {
public static void main(String[] args) {
BiFunction<Integer,Integer,Integer> biFunction= (i1,i2) -> i1+i2;
System.out.println(biFunction.apply(1,2));
}
}BiFuntion中前两个Integer是输入参数类型，最后一个Integer是结果参数类型。
参考文献
