java8(四) Lambda表达式

什么是函数式编程和什么是lambda表达式

• 在JDK8之前，Java是不⽀持函数式编程的，所谓的函数编程，即可理解是将⼀个函数（也称为“⾏为”）作为⼀个参数进⾏传递， ⾯向对象编程是对数据的抽象（各种各样的POJO类），⽽函数式编程则是对⾏为的抽象（将⾏为作为⼀个参数进⾏传递）

• jdk8之前创建线程

new Thread(new Runnable() {
   @Override
   public void run() {
   System.out.println("⼩滴课堂学习Java架构教程");
 }
 });

• jdk8之后Lambda表达式则只需要使⽤⼀句话

 new Thread(() -> System.out.println("⼩滴课堂学习Java架构教程"));

• 集合容器⾥⾯的字符串排序 使⽤前

 List<String> list =Arrays.asList("aaa","ggg","ffff","ccc");
   Collections.sort(list, new Comparator<String>() {
     @Override
     public int compare(String a, String b) {
       return b.compareTo(a);
     }
   }
 );
   for (String string : list) {
   System.out.println(string);
   }

• 使用后

   List<String> list =Arrays.asList("aaa","ggg","ffff","ccc");
   Collections.sort(list, (a,b)->b.compareTo(a) );
   for (String string : list) {
     System.out.println(string);
   }

• lambda表达式 使⽤场景(前提)：⼀个接⼝中只包含⼀个⽅法，则可以使⽤Lambda表达式，这样的接⼝称之为“函数接⼝” 语法： (params) -> expression

第⼀部分为括号内⽤逗号分隔的形式参数，参数是函数式接⼝⾥⾯⽅法的参数；第⼆部分为⼀个箭
头符号：->；第三部分为⽅法体，可以是表达式和代码块
参数列表 ：
 括号中参数列表的数据类型可以省略不写
 括号中的参数只有⼀个，那么参数类型和()都可以省略不写
⽅法体：
 如果{}中的代码只有⼀⾏，⽆论有返回值，可以省略{}，return，分号，要⼀起省略，其他
则需要加上

好处： Lambda 表达式的实现⽅式在本质是以匿名内部类的⽅式进⾏实现，简化代码

⾃定义lambda接⼝流程

• 定义⼀个函数式接⼝ 需要标注此接⼝ @FunctionalInterface，否则万⼀团队成员在接⼝上加了其他⽅法则容易出故障
  编写⼀个⽅法，输⼊需要操做的数据和接⼝
  在调⽤⽅法时传⼊数据 和 lambda 表达式，⽤来操作数据
  需求，定义⼀个可以使⽤加减乘除的接⼝ 以前需要定义4个⽅法
  使⽤Lambda表达式后

@FunctionalInterface
public interface OperFunction<R,T> {
 R operator(T t1, T t2);
}

 public static void main(String[] args) throws Exception {
 System.out.println(operator(20, 5, (Integer x, Integer y) -> {
 return x * y;
 }));
 System.out.println(operator(20, 5, (x, y) -> x + y));
 System.out.println(operator(20, 5, (x, y) -> x - y));
 System.out.println(operator(20, 5, (x, y) -> x / y));
 }
 public static Integer operator(Integer x, Integer y,
OperFunction<Integer, Integer> of) {
 return of.operator(x, y);
 }

Java8内置接口

• Lambda表达式必须先定义接⼝，创建相关⽅法之后才可使⽤，这样做⼗分不便，其实java8已经内置了许多接⼝, 例如下⾯四个功能型接⼝，所以⼀般很少会由⽤户去定义新的函数式接⼝
• Java8的最⼤特性就是函数式接⼝，所有标注了@FunctionalInterface注解的接⼝都是函数式接⼝

Java8 内置的四⼤核⼼函数式接⼝
Consumer<T> : 消费型接⼝：有⼊参，⽆返回值
 void accept(T t);
Supplier<T> : 供给型接⼝：⽆⼊参，有返回值
 T get();
Function<T, R> : 函数型接⼝：有⼊参，有返回值
 R apply(T t);
Predicate<T> : 断⾔型接⼝：有⼊参，有返回值，返回值类型确定是boolean
 boolean test(T t);

Function

• 传⼊⼀个值经过函数的计算返回另⼀个值
  T：⼊参类型，R：出参类型
  调⽤⽅法：R apply(T t)
• 作⽤：将转换逻辑提取出来，解耦合
  不要看过于复杂，就是⼀个接⼝,下⾯是⾃定义实现

public class FunctionObj implements Function {
 @Override
 public Object apply(Object o) {
 return o+"经过apply处理拼接上了";
 }
}

常规使用

// 输出⼊参的10倍
Function<Integer, Integer> func = p -> p * 100;
func.apply(100);

BiFunction

• 作用同Function 一样，参数为两个

public static void main(String[] args) {
 System.out.println(operator(10,21,(a,b)->a+b));
 System.out.println(operator(10,2,(a,b)->a-b));
 System.out.println(operator(8,4,(a,b)->a*b));
 System.out.println(operator(10,2,(a,b)->a/b));
 }
 public static Integer operator(Integer a, Integer b, BiFunction<Integer,
Integer, Integer> bf) {
 return bf.apply(a, b);
 }

Consumer

• Consumer 消费型接⼝：有⼊参，⽆返回值
  将 T 作为输⼊，不返回任何内容
  调⽤⽅法：void accept(T t);
• ⽤途： 因为没有出参，常⽤于打印、发送短信等消费动作
• 典型应⽤，集合的foreach

List<String> list = Arrays.asList("aaa","bbb");
list.forEach(obj->{
//TODO
});

Supplier

• Supplier: 供给型接⼝：⽆⼊参，有返回值
• T：出参类型；没有⼊参
  调⽤⽅法：T get();
• ⽤途： 泛型⼀定和⽅法的返回值类型是⼀种类型，如果需要获得⼀个数据,并且不需要传⼊参数,可以使⽤Supplier接⼝，例如 ⽆参的⼯⼚⽅法，即⼯⼚设计模式创建对象，简单来说就是 提供者

Predicate

• Predicate: 断⾔型接⼝：有⼊参，有返回值，返回值类型确定是boolean
• T：⼊参类型；出参类型是Boolean
  调⽤⽅法：boolean test(T t);
• ⽤途： 接收⼀个参数，⽤于判断是否满⾜⼀定的条件，过滤数据

JDK8新特性中 ⽅法引⽤与构造函数引⽤

• 以前⽅法调⽤ 对象.⽅法名 或者 类名.⽅法名
  jdk1.8提供了另外⼀种调⽤⽅式 ::

说明:⽅法引⽤是⼀种更简洁易懂的lambda表达式，操作符是双冒号::，⽤来直接访问类或者实例
已经存在的⽅法或构造⽅法
通过⽅法引⽤，可以将⽅法的引⽤赋值给⼀个变量
语法：左边是容器（可以是类名，实例名），中间是" :: "，右边是相应的⽅法名
静态⽅法，则是ClassName::methodName。如 Object ::equals
实例⽅法，则是Instance::methodName
构造函数，则是 类名::new;
单个参数
Function<⼊参1, 返回类型> func = ⽅法引⽤
应⽤ func.apply(⼊参);
2个参数
BiFunction<⼊参1,⼊参2, 返回类型> func = ⽅法引⽤
应⽤ func.apply(⼊参1,⼊参2);

• 案例

public class TestJdk8 {
public static void main(String[] args) {
 // 使⽤双冒号::来构造静态函数引⽤
 Function<String, Integer> fun = Integer::parseInt;
 Integer value = fun.apply("1024");
 System.out.println(value);
 // 使⽤双冒号::来构造⾮静态函数引⽤
 String content = "hello";
 Function<Integer, String> func = content::substring;
 String result = func.apply(1);
 System.out.println(result);
 // 构造函数引⽤，多个参数
 BiFunction<String, Integer, User> biFunction = User::new;
 User user1 = biFunction.apply("⼩A ", 28);
 System.out.println(user1.toString());
 //构造函数引⽤，单个参数
 Function<String, User> function = User::new;
 User user2 = function.apply("⼩D");
 System.out.println(user2.toString());
 // 函数引⽤也是⼀种函数式接⼝，可以将函数引⽤作为⽅法的参数
 sayHello(String::toUpperCase, "hello");
}
/**
 *
 * @param func 函数引⽤
 * @param param 对应的参数
 */
 private static void sayHello(Function<String, String> func, String
param) {
 String result = func.apply(param);
 System.out.println(result);
 }
}