java8 API 函数式接口
简介
14年，Oracle公司如期发布了Java 8正式版，Java8提供了强大的流式处理及函数式接口编程
函数式接口编程，相信很多人在javascript中都使用过，比如回调函数，如今Java8也吸收了诸多的其它语言优点。
线程创建（8以前的写法）
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.printf(Thread.currentThread().getName());
}
});
thread.start();
Java8的函数式接口写法
//1Java8 lambda表达式写法
Thread thread = new Thread(() -> {
System.out.printf(Thread.currentThread().getName());
});
//对于{}里面只有一条语句的写法
Thread thread1 = new Thread(() -> System.out.println(Thread.currentThread().getName()));
//这种写法，不知道各位看官看着是什么感想
Student student = new Student("yang", 2);
new Thread(student::getName);
对比一下
List<Student> list = new ArrayList<>();
list.add(new Student("yang", 20));
list.add(new Student("hehe", 25));
list.add(new Student("jiana", 18));
//对集合进行排序，以前的写法
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge() - o2.getAge(); }
});
//Java8 lambda表达式的写法
Collections.sort(list, (o1, o2) -> o1.getAge()-o2.getAge());
Java8函数式编程可以使用lambda表达式，让代码更加简洁高效，当然对于许多如果刚接触的小伙伴来说，如果没有经过学习lambda式的写法，看起来也会云里雾里的，毕竟写法是高效了，但可读性确实要差一些了，对于改bug的同鞋来讲，难度是否又增加许多？
JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。
标注为FunctionalInterface的接口被称为函数式接口，该接口只能有一个自定义方法，但是可以包括从object类继承而来的方法。如果一个接口只有一个方法，则编译器会认为这就是一个函数式接口。是否是一个函数式接口，需要注意的有以下几点：
1.该注解只能标记在”有且仅有一个抽象方法”的接口上。
2.JDK8接口中的静态方法和默认方法，都不算是抽象方法。
3.接口默认继承java.lang.Object，所以如果接口显示声明覆盖了Object中方法，那么也不算抽象方法。
4.该注解不是必须的，如果一个接口符合”函数式接口”定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错。
5.在一个接口中定义两个自定义的方法，就会产生Invalid ‘@FunctionalInterface’ annotation; FunctionalInterfaceTest is not a functional interface错误.
现如今，我们则从Function常用函数入口，真正了解一下。
1.Function：接受一个对象，返回一个对象
/**
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
* @since 1.8
*/
@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);
}
Function 内部有一个有一个apply（待子类实现）的方法,调用apply，回传R结果，通过泛型保证apply函数的入参入及返回值的类型。
基本使用：
对数据进行处理将String类型转换成double类型，代码如下：
//先定义好这个函数功能
Function<String, Double> stringToDouble = ((string) -> Double.parseDouble(string));
//再使用函数功能
System.out.println(stringToDouble.apply("20.25"));
异步回调处理
//将student的名字，通过回调的方式放入name变量中,name变量必须是Atomica类型的，因为交给别人，别人可以用线程来做
public class MainTest {
public static void main(String[] args) {
Student student2 = new Student("yanchuanbin", 25);
AtomicReference<String> name = new AtomicReference<>("");
String otherParams = "";
new Operator(student2).handler(otherParams, (student) -> {
System.out.println("here1 = " + Thread.currentThread().getName());
name.set(student.getName());
return null;
});
}
}
class Operator {
Student student;
public Operator(Student student) {
this.student = student;
}
public void handler(String otherParams, Function<Student, Void> callback) {
System.out.println("here2 = " + Thread.currentThread().getName());
ThreadFactory threadFactory;
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(() -> callback.apply(student));
}
}
输出
here2 = main
here1 = pool-1-thread-1
2.Supplier：生产者，无参数，只有返回值
Supplier生产者，提前定义好生产方法，通过get()获取返回值，源码如下
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
作为生产者，基本使用
// Supplier<Student> supplier2 = new Supplier() {
// @Override
// public Student get() {
// return new Student("aa",new Random().nextInt(20);
// }
// };
Supplier<Student> supplier = () -> new Student("yanchuanbin", 2);
Student student = supplier.get();
3.Consumer：消费者，有入参，但无返回值
Consumer消费者，传入一个参数，消费后无返回值，源码如下
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
基本使用
Student student = new Student("yanchuanbin", 25);
//旧写法
// Consumer<Student> consumer = new Consumer<Student>() {
// @Override
// public void accept(Student student) {
// System.out.println(student.getAge());
// }
// };
//lambad写法
Consumer<Student> consumer = (student1 -> System.out.println(student1.getAge()));
consumer.accept(student);
4.Predicate：断言，有参数T，返回固定类型boolean
断言式接口其参数是<T,boolean>，源码如下
@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);
基本使用
Predicate<Student> studentEqualsPredicate = (student) -> student.getAge() > 10;
Student student = new Student("yanchuanbin", 25);
System.out.println(studentEqualsPredicate.test(student));
输出
true
5.UnaryOperator：接收T对象，返回T对象
对对象进行处理，处理后，将原来的对象返回，入参和返回值都是T，源码如下：
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
/**
* Returns a unary operator that always returns its input argument.
* @param <T> the type of the input and output of the operator
* @return a unary operator that always returns its input argument
*/
static <T> UnaryOperator<T> identity() {
return t -> t;
}
}
基本使用
UnaryOperator<Student> identity = (x -> {
return new Student(x.getName(), x.getAge()+1);
});
//生产一个大一岁的哥出来，名字是一样的
Student student1 = identity.apply(student);
6.BinaryOperator：传入两个T对象，返回T对象
继承自BiFunction，传入两个T类型的对象，返回一个T类型的对象，源码如下
* @param <T> the type of the operands and result of the operator
*
* @see BiFunction
* @see UnaryOperator
* @since 1.8
*/
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
BiFunction源码如下
@FunctionalInterface
public interface BiFunction<T, U, R> {
/**
* @param t the first function argument
* @param u the second function argument
* @return the function result
*/
R apply(T t, U u);
基本使用
//传入两个学生，返回两个学生中年龄较大的学生对象
BinaryOperator<Student> getMaxAgeStudentHandler =
(student1, student2) -> student1.getAge() > student2.getAge() ? student1 : student2;
Student student1 = new Student("ya",20);
Student student2 = new Student("wa",25);
Student maxAgeStudent = getMaxAgeStudentHandler.apply(student1,student2);
