在jdk8中什么是函数式接口：
1、被@FunctionalInterface注解修饰的。
2、接口里边只有一个非default的方法。
满足以上2个条件的即为函数式接口，ps：即使一个接口没有被@FunctionalInterface修饰，但是满足2，那么这样的接口也会是函数式接口。
Supplier
概要：不接受参数，返回一个值。
jdk源码：
*/
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}即：Supplier不接受参数，返回一个值。
example：
public class SupplierTest {
public static void main(String[] args) {
Supplier<Student> supplier = Student::new;//这里使用了方法引用（后续解释）生成了一个对象。
System.out.println(supplier.get().getName());
}
}Function
概要：接受一个参数返回一个值
jdk源码：
//类型T入参，类型R是返回值的类型
@FunctionalInterface
public interface Function<T, R> {
/**
接受一个参数，返回一个结果
*/
R apply(T t);
/**
* 默认方法是讲的课8新加入的一种类型，入参before是一个Function（接受参数V类型，输出T类型），从实现来看其首先调用before的行为得到输出T，
* 随后T作为当前Function的入参，最后当前Function输入R类型。即：compose函数传入的函数首先被调用，得到的结果作为当前Function的入参使用
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* andThen是和compose相反的操作，当前Function首先被调用，得到的结果作为参数after的入参，调用after。
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* 对接受的元素，不做处理
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}BiFunction
概要：接受2个参数，返回一个值。
jdk源码：
//T和U类型是参数，R类型是返回值。
@FunctionalInterface
public interface BiFunction<T, U, R> {
/**
* BiFunction的主方法，接受2个参数，返回一个结果
*/
R apply(T t, U u);
/**
* 先执行当前BiFunction的行为，得到结果R类型，R类型最后作为Function的实例after的入参（泛型“? super R”即“？”是R类型或者是R类型的
* 父级）返回V类型的结果。PS：考虑为什么andThen的入参是一个Function，而不是一个BiFunction？
*/
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));
}
}example:
/**
* Created by CeaserWang on 2017/1/8.
*/
public class FunctionATest {
public static void main(String[] args) {
FunctionATest functionTestA = new FunctionATest();
// functionTestA.testfunction1();
System.out.println(functionTestA.computeA(3,value -> value = value * 3,value -> value+1));
System.out.println(functionTestA.computeB(3,value -> value = value * 3,value -> value+1));
System.out.println(functionTestA.computeC(3,4,(value1,value2) -> {return value1+value2;},value -> value*value));
}
public void testfunction1(){
List<String> list = Arrays.asList("zhangsan","lisi","wangwu");
Collections.sort(list,(o1,o2) -> {return o1.compareTo(o2); });
Collections.sort(list,(o1,o2) -> o1.compareTo(o2));
list.forEach((item) -> System.out.println(item));
list.forEach(String::toUpperCase);
list.stream().map(String::toUpperCase).forEach(item -> System.out.println(item));
}
public int computeA(int a, Function<Integer,Integer> function,Function<Integer,Integer> befor ){
return function.compose(befor).apply(a);
}
public int computeB(int a, Function<Integer,Integer> function,Function<Integer,Integer> after ){
return function.andThen(after).apply(a);
}
public int computeC(int a,int b, BiFunction<Integer, Integer,Integer> bifunction, Function<Integer,Integer> function ){
return bifunction.andThen(function).apply(a,b);
}
}BinaryOperator
概要：继承了BiFunction新加了2个求最大值和最小值的方法。
jdk源码：
//继承了BiFunction，入参和返回值都是同一种类型T，因为2中相同类型的元素做大小比较，返回的是其中一个，即还是原来入参的类型。
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
/**
* 根据比较器comparator求最小值
*/
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
/**
* 根据比较器comparator求最大值
*/
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
}example:
/**
* Created by Administrator on 2017/1/8.
*/
public class BinaryOperatorTest {
public static void main(String[] args) {
BinaryOperatorTest BinaryOperatorTest = new BinaryOperatorTest();
Integer rnum = BinaryOperatorTest.compute(2,3,(num1,num2) -> {return num1 * num2;},value -> 2*value);
System.out.println(rnum);
System.out.println("-------------------------------------");
Integer rnum2 = BinaryOperatorTest.compute(2,3,(num1,num2) -> {return num1 * num2;});
System.out.println(rnum2);
System.out.println("-------------------------------------");
Integer rnum3 = BinaryOperatorTest.computeA(2,3,(num1,num2) -> num1.compareTo(num2));
System.out.println(rnum3);
}
public Integer compute(Integer a, Integer b, BinaryOperator<Integer> binaryoperator, Function<Integer,Integer> function) {
return binaryoperator.andThen(function).apply(a,b);
}
public Integer compute(Integer a, Integer b, BinaryOperator<Integer> binaryoperator) {
return binaryoperator.apply(a,b);
}
public Integer computeA(Integer a, Integer b, Comparator<Integer> comparator){
return BinaryOperator.minBy(comparator).apply(a,b);
}
}Predicate
概要：接受一个参数返回boolean类型，常用语filter过滤条件使用。
jdk源码：
@FunctionalInterface
public interface Predicate<T> {
/**
* 接受一个参数返回一个boolean值
*/
boolean test(T t);
/**
*与操作，支持短路与
*/
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
/**
* 取反操作
*/
default Predicate<T> negate() {
return (t) -> !test(t);
}
/**
* 或操作，支持短路或
*/
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
/**
* 比较2个对象是否相同
*/
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}example:
/**
* Created by CeaserWang on 2017/1/8.
*/
public class PredicateTest {
public static void main(String[] args) {
Predicate<String> mypredicate = value -> value.length()>5;
System.out.println(mypredicate.test("hello55s"));
List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8,9);
PredicateTest predicatetest = new PredicateTest();
predicatetest.condationA(nums,value -> value>5);
System.out.println("\n---------------------------");
predicatetest.condationA(nums,value -> value % 2 ==0);
System.out.println("\n---------------------------");
System.out.println(predicatetest.condationEqual("test").test("test"));
}
public void condationA(List<Integer> list, Predicate<Integer> predate){
for(Integer item : list){
if(predate.test(item)){
System.out.print(item);
}
}
}
public Predicate<String> condationEqual(Object obj){
return Predicate.isEqual(obj) ;
}
}Optional
概要：jdk8为了解决NPE问题提供的解决方案。
在jdk7中业务中很多代码都是这样：
if(null!=XXX){
doSomeThing();
}开发人员需要警惕NPE问题，给开发带来了一些不便，现在我们不想用这三行固定的语句，为此jdk8有了Optional。
Optional内部维护了一个value的成员变量，为此Optional提供了诸多针对于此成员变量的方法。
Optional中的其中一个方法：
//空对象
private static final Optional<?> EMPTY = new Optional<>();
//Optional维护的值
private final T value;
//是否是空值
public boolean isPresent() {
return value != null;
}
//如果不是空值，那么执行针对于value的行为。
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
//构造一个值为value的Optional对象，value不能为空，否则报错。
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
//返回一个空值
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
//创建一个允许空值的Optional对象
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}example：
/**
* Created by CeaserWang on 2017/1/8.
* optional 不要作为成员变量或者参数，optional只是为了应对null异常而来的
*/
public class OptionalTest {
public static void main(String[] args) {
OptionalTest OptionalTest = new OptionalTest();
OptionalTest.optionalA();
OptionalTest.optionalB();
}
public void optionalA(){
//Optional optional = Optional.of("hello");
Optional optional = Optional.ofNullable(null);//创建一个空的对象
optional.ifPresent(item -> System.out.println(item));//如果为空此行代码不会报错。
System.out.println(optional.orElse("world"));//如果为空输出word
System.out.println(optional.orElseGet(() -> "opop"));//如果为空，取Supplier提供的值
}
public void optionalB(){
Company company = new Company();
Employee e1 = new Employee();
Employee e2 = new Employee();
company.setEmployyee(Arrays.asList(e1,e2));
Optional<Company> optional = Optional.ofNullable(company);
System.out.println(optional.map(icompany -> icompany.getEmployyee()).orElse(Collections.emptyList()));
}
}函数式编程和以往的面向对象的方式有一定的区别，函数式编程方法的参数可以传递行为，这些行为包括但不限于以上介绍的这些，jdk8提供的函数式编程的辅助类在java.util.function包下边： 
这些针对于函数式编程的辅助类，对以后的收集器，流是基础，后续的jdk新加的框架都是使用这些基类展开的。