1.lambda表达式:
加入lambda之后，很多写法都变得简单起来，如创建一个线程对象
new Thread(new Runnable() {
@Override
public void run() {
System.out.print("Hello");
}
});
lambda写法:
new Thread(() -> System.out.print("Hello"));
单独将lambda拎出来：
Runnable runnable = () -> System.out.print("Hello");
其实lambda代表的就是一个接口的实现而已（匿名内部类）。
而这种接口也叫函数式接口，会有@FunctionalInterface注解进行编译时检查。
或者直接把lambda看成一个方法，上述的 () -> System.out.print("Hello") 就是代表一个无入参、无返回值的一个方法（等同于public void run() {System.out.print("Hello")}），而Runnable runnable则是指向这个方法（类似函数指针），需要调用这个方法时，调用runnable.run()即可.
当有一个参数、无返回值则是Consumer<T>
// 对printStream对象的void print(String s)方法的引用
PrintStream printStream = System.out;
Consumer<String> consumer = printStream::print;
consumer.accept("Hello");
// 输出
Hello
以上为java.util.function包下的部分接口，剩余的基本上就是指定泛型类型的函数接口了，例如LongConsumer，无泛型，其实就是指定入参只能是Long。
上述已经代表了大部分的函数可以表示的形式了（值得注意的是，三个及以上的入参的函数式接口JDK并没有提供，需要时要自定义实现，实际上也很少用到）。
方法有静态方法(static)和非静态方法，但函数式接口关注的仅是入参、出参类型和个数而已：
public Class Test {
public Long noStaticFoo(String str) {...}
public static Long staticFoo(String str) {...}
public static void main() {
// 静态方法，类::
Function<String, Long> staticFoo = Test::staticFoo;
Long apply = staticFoo.apply("100");
// 非静态方法，实例对象::
Test test = new Test();
Function<String, Long> noStaticFoo = test::noStaticFoo;
Long apply2 = noStaticFoo.apply("100");
/* 这种可以理解成两个入参、除了原来方法的入参外，还要指明实例对象（因为这是一个实例方法）*/
BiFunction<Test, String, Long> noStaticFooTest = Test::noStaticFoo;
Long apply3 = noStaticFooTest.apply(test, "100");
}
}
java8异步方法调用写法
public class UserHttpService {
public User getById(Long id) {
...
return user;
}
}
public class AsyncExecutor {
// 线程池，建议恰当配置（拒绝策略建议CallerRunsPolicy）和使用框架注入
private ExecutorService executorService = Executors.newFixedThreadPool(10);
/**
* 单个入参，有返回值的异步执行方法 , public User getById(Long id)
*
* @param method 要执行的方法，如 , userHttpService::getById
* @param param 入参值，如 100
* @param <P> 入参类型，如 Long
* @param <R> 返回值类型,如 User
* @return Future对象，用以判断是否执行结束、获取返回结果
*/
public <P, R> Future<R> async(Function<P, R> method, P param) {
return executorService.submit(() -> method.apply(param));
}
}
public class A {
private AsyncExecutor asyncExecutor;
private UserHttpService userHttpService;
public void foo() {
...
// 异步调用
Future<User> userFuture = asyncExecutor.async(userHttpService::getById, id);
... 其他操作（如再发起http请求）
// 获取结果
User user = userFuture.get();
...
}
}
public class AsyncExecutor {
// 线程池，建议恰当配置（拒绝策略建议CallerRunsPolicy）和使用框架注入
private ExecutorService executorService = Executors.newFixedThreadPool(10);
/**
* 无入参，无返回值的异步执行方法 , void noStaticFoo()
*
* @param method 要执行的方法，如 user::noStaticFoo;
* @return Future对象，用以判断是否执行结束
*/
public Future async(Runnable method) {
return executorService.submit(method);
}
/**
* 有单个入参，无返回值的异步执行方法，如 void noStaticFoo(Long id)
*
* @param method 要执行的方法，如, user::noStaticFoo
* @param param 方法执行的入参，如id
* @param <P> 入参类型，如Long
* @return Future对象，用以判断是否执行结束
*/
public <P> Future async(Consumer<P> method, P param) {
return executorService.submit(() -> method.accept(param));
}
/**
* 有两个参数但是无返回值的异步执行方法, 如void noStaticFoo(Long id,Entity entity)
*
* @param method 要执行的方法，如 , user::noStaticFoo
* @param param1 第一个入参值，如id
* @param param2 二个入参值，如entity
* @param <P1> 第一个入参类型
* @param <P2> 第二个入参类型
* @return Future对象，用以判断是否执行结束
*/
public <P1, P2> Future async(BiConsumer<P1, P2> method, P1 param1, P2 param2) {
return executorService.submit(() -> method.accept(param1, param2));
}
/**
* 无参数有返回值的异步执行方法 , Entity noStaticFoo()
*
* @param method 要执行的方法，如 , user::noStaticFoo
* @param <R> 返回值类型,如 Entity
* @return Future对象，用以判断是否执行结束、获取返回结果
*/
public <R> Future<R> async(Supplier<R> method) {
return executorService.submit(method::get);
}
/**
* 单个入参，有返回值的异步执行方法 , Entity noStaticFoo(Long id)
*
* @param method 要执行的方法，如 , user::noStaticFoo
* @param param 入参值，如 id
* @param <P> 入参类型，如Long
* @param <R> 返回值类型,如 Entity
* @return Future对象，用以判断是否执行结束、获取返回结果
*/
public <P, R> Future<R> async(Function<P, R> method, P param) {
return executorService.submit(() -> method.apply(param));
}
/**
* 两个入参，有返回值的异步执行方法 , Entity noStaticFoo(Long id)
*
* @param method 要执行的方法，如 , user::noStaticFoo
* @param param1 第一个入参值，如id
* @param param2 二个入参值，如entity
* @param <P1> 第一个入参类型
* @param <P2> 第二个入参类型
* @param <R> 返回值类型,如 Entity
* @return Future对象，用以判断是否执行结束、获取返回结果
*/
public <P1, P2, R> Future<R> async(BiFunction<P1, P2, R> method, P1 param1, P2 param2) {
return executorService.submit(() -> method.apply(param1, param2));
}
}
JDK1.8 有提供CompletableFuture，也是类似异步处理的方法，默认线程池为ForkJoinPool（默认最大工作线程数=CPU总核心数-1），该线程池擅长于计算密集型任务，IO密集型任务请尽量使用自己合理配置的线程池。
函数式接口
函数式接口就是只定义一个抽象方法的接口.例如:Comparator和Runnable 和 Predicate 和 FileFilter
接口现在还可以拥有默认方法（即在类没有对方法进行实现时， 其主体为方法提供默认实现的方法）。
哪怕有很多默认方法，只要接口只定义了一个抽象 方法，它就仍然是一个函数式接口。
注意(函数式接口):
函数式接口中可以额外定义多个抽象方法，但这些抽象方法签名必须和Object的public方法一样
接口最终有确定的类实现， 而类的最终父类是Object。Comparator有两个抽象方法（compare和equals方法） ,Comparator类的equals方法名和Object的equals方法一样.
所有类默认继承Object，所以该类已有了Object的equals方法，相当于重写了equals方法。
用函数式接口可以干什么呢?
Lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例（具体说来，是函数式接口一个具体实现 的实例）。
你用匿名内部类也可以完成同样的事情，只不过比较笨拙：需要提供一个实现，然后 再直接内联将它实例化。
下面的代码是有效的，因为Runnable是一个只定义了一个抽象方法run 的函数式接口：
函数描述符:
函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。我们将这种抽象方法叫作 函数描述符。
例如，Runnable接口可以看作一个什么也不接受什么也不返回（void）的函数的 签名，因为它只有一个叫作run的抽象方法，
这个方法什么也不接受，什么也不返回（void）。
Java重用了函数式接口提 供的标准类型，并将其映射成一种形式的函数类型。
Java 8的库设计师帮你在java.util.function包中引入了几个新的函数式接:Predicate、Consumer 、Function
https://blog.csdn.net/a879611951/article/details/80104014 四大核心函数接口
Function<T, R>
T：入参类型，R：出参类型
调用方法：R apply(T t);
定义函数示例：Function<Integer, Integer> func = p -> p * 10; // 输出入参的10倍
调用函数示例：func.apply(10); // 结果100
例如:
Function<Integer, Integer> fun1 = n->n*2 ;
fun1.apply(3);
public static void main(String[] args) {
List<Integer> weights = Arrays.asList(7, 3, 4, 10);
Function<Integer, Apple> intConsumer = Apple::new;
List<Apple> apples = map(weights,Apple::new);
System.out.println(JSON.toJSONString(apples));
}
public static List<Apple> map(List<Integer> list, Function<Integer, Apple> f) {
List<Apple> result = new ArrayList<>();
for (Integer e : list) {
Apple apply = f.apply(e);
result.add(f.apply(e));
}
return result;
}
运行结果:[{"weight":7},{"weight":3},{"weight":4},{"weight":10}]
Supplier<T>
T：出参类型；没有入参
调用方法：T get();
定义函数示例：Supplier<Integer> supplier= () -> 100; // 常用于业务“有条件运行”时，符合条件再调用获取结果的应用场景；运行结果须提前定义，但不运行。
调用函数示例：supplier.get();
例如:
Supplier<String> supplier = String::new;
System.out.println(supplier.get());//""
Supplier<Emp> supplierEmp = Emp::new;
Emp emp = supplierEmp.get();
emp.setName("dd");
System.out.println(emp.getName());//dd
Consumer<T>
T：入参类型；没有出参
调用方法：void accept(T t);
定义函数示例：Consumer<String> consumer= p -> System.out.println(p); // 因为没有出参，常用于打印、发送短信等消费动作
调用函数示例：consumer.accept("18800008888");
Predicate<T>
用于判断, 定义的函数只会返回true或false
例如: Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isEmpty1 = (String str) ->str.isEmpty();
T：入参类型；出参类型是Boolean
调用方法：boolean test(T t);
定义函数示例：Predicate<Integer> predicate = p -> p % 2 == 0; // 判断是否、是不是偶数
调用函数示例：predicate.test(100); // 运行结果true
Consumer<String> aa= a-> System.out.println(a);
Consumer<String> aa1= System.out::println;
getLowCaloricDishesNamesInJava8(Dish.menu).forEach(aa);
public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes){
//Dish类 calories变量 getCalories 是calories变量的get方法
Comparator<Dish> comparing = comparing(Dish::getCalories);
Function<Dish, String> getName = Dish::getName;
List<String> collect = dishes.stream()
.filter(d -> d.getCalories() < 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());
return collect;
}
https://www.cnblogs.com/lijingran/p/8708037.html java编程Consumer和Predicate案例
//修改属性的值
@Test
public void test(){
UserT userT = new UserT("zm");
//接受一个参数
Consumer<UserT> userTConsumer = userT1 -> userT1.setName("zmChange");};
userTConsumer.accept(userT);
logger.info(userT.getName());//输出zmChange
}
public class PredicateConsumerDemo {
public static Student updateStudentFee(Student student, Predicate<Student> predicate, Consumer<Student>
){
if (predicate.test(student)){
consumer.accept(student);
}
return student;
}
}
public class Test {
public static void main(String[] args) {
Student student1 = new Student("Ashok","Kumar", 9.5);
student1 = updateStudentFee(student1, student -> student.grade > 8.5, student -> student.feeDiscount = 30.0);
student1.printFee();
Student student2 = new Student("Rajat","Verma", 8.0);
student2 = updateStudentFee(student2, student -> student.grade >= 8, student -> student.feeDiscount = 20.0);
student2.printFee();
}
}
