Lambda表达式和方法引用

简介

Lambda是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以 传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更 灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了 提升。

在Java 8 语言中引入的一种新的语法元素和操 作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符 或箭头操作符。它将 Lambda 分为两个部分：

• 左侧：指定了 Lambda 表达式需要的参数列表
• 右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

lambda语法格式

格式一 ： 无参，无返回值

Runnable r1 = () -> System.out.println("Hello Lambda!");

格式二：需要一个参数，没有返回值

Consumer<String> con = (String s) -> System.out.println(s);

格式三：数据类型可以省略，应为可由编译器推断得出，成为“类型推断”

Consumer<String> con = s -> System.out.println(s);

格式四：Lambda需要两个或以上的参数，有多条执行语句，并且有返回值

Comparator<Integer> com = (x,y) ->{
    System.out.println("实现函数式接口的方法！");
    return Integer.compare(x,y);
}

格式五：当lambda体只有一条语句时，return 和大括号可以同时省略

Comparator<Integer> com = (x,y) -> Integer.compare(x,y);

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序 的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于 上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

函数式（Functional）接口

什么是函数式接口

• 只包含一个抽象方法的接口，成为函数式接口。
• 可以通过lambda表达式来创建该接口的对象。
• 接口的使用上有@FunctionalInterface注解，表示这是个函数式接口
• 在java.util.function包下定义了Java8丰富的函数式接口

理解函数式接口

• Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP) 编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不 得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还 可以支持OOF（面向函数编程）
• 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的 编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在 Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的 对象类型——函数式接口。
• 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口 的实例，那么该对象就可以用Lambda表达式来表示。
• 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

@FunctionalInterface  //表示这是一个函数式接口
public interface Runnable{
   /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();  //只有一个实现方法
}

Java 内置四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer<T> 消费型接口	T	void	对类型为T的对象应用操作， 包含方法: void accept(T t)
Supplier<T> 共给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象，包含方法：R apply(T t)
Predicate<T>	T	Boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)

其他接口

函数式接口	参数类型	返回类型	用途
Bifunction<T,U,R>	T,U	R	对类型为T,U 参数应用操作，返回R类型的结果。包含方法： R apply(T t,U u)
UnaryOperator<T>(Function子接口)	T	T	对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为：T apply(T t)
BinaryOperator<T>(BiFunction子接口)	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为：T apply(T t1,T t2)
BiConsumer<T,U>	T,U	void	对类型为T,U参数应用操作。包含方法为：void accept(T t,U u)
BiPredicate<T,U>	T,U	boolean	包含方法为： boolean test(T t,U u)
ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>	T	int long double	分别计算int,long,double值的函数
IntFunction<R> LongFunction<R> DoubleFunction<R>	int long double	R	参数分别为int long double类型的函数

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就 是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向 一个方法，可以认为是Lambda表达式的一个语法糖。
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的 方法的参数列表和返回值类型保持一致！
• 格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
• 如下三种主要使用情况：
  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名

//lambda表达式
Consumer<String> con = x -> System.out.pringln(x);
//方法引用
Consumer<String> con2 = System.out::println;

//lambda表达式
Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
//方法引用
Comparator<Integer> com1 = Integer::compare;
int value = com.compare(12,32);

//lambda表达式
BiPredicate<String,String> bp = (x,y) -> x.equals(y);
//方法引用
BiPredicate<String,String> bp1 = String::equals;
boolean flag = bp1.test("hello","hi");

注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二 个参数是需要引用方法的参数(或无参数)时：ClassName::methodName

构造器引用

格式： ClassName::new

//lambda表达式
Function<Integer,MyClass> fun = n -> new MyClass(n)
//构造器引用
Function<Integer,MyClass> fun = MyClass::new ;

数组引用

格式： type[] ::new

//lambda表达式
Function<Integer,Integer[]> fun = n -> new Integer[n];
//数组引用
Function<Integer,Integer[]> fun = Integer[]::new ;

参考尚硅谷java基础ppt