新操作符 “->”

左侧：Lambda 表达式的参数列表

右侧：Lambda表达式中所需执行的功能，即Lamda体

// Lambda 表达式的参数的数据类型可以省略不写，因为JVM编译器可以通过上下文推断出，即“类型推断” jdk8新特性

(Integer o1, Integer o2) -> Integer.compare(o1, o2);

(o1, o2) -> Integer.compare(o1, o2);

语法一：无参数，无返回值

() -> System.out.println("hello");

语法二：有一个参数，无返回值

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

consumer.accept("hello");

// （）可以省略

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

consumer.accept("hello");

语法三：有两个及以上参数，有返回值，

// Lambda 体中只有一条语句

Comparator<Integer> comparator = (o1, o2) -> Integer.compare(o1, o2);

// Lambda 体中有多条语句

Comparator<Integer> comparator1= (o1, o2) -> {

System.out.println("hello");

return Integer.compare(o1, o2);

};

//

comparator1.compare(1, 2);

Lambda 表达式需要“函数式接口”的支持

函数式接口：接口中只有一个抽象方法的接口， 可以使用@FunctionalInterface 修饰，可以检查是否是函数式接口

λ表达式本质上是一个匿名方法。让我们来看下面这个例子：

public int add(int x, int y) {

return x + y;

}

转成λ表达式后是这个样子：

(int x, int y) -> x + y;

参数类型也可以省略，Java编译器会根据上下文推断出来：

(x, y) -> x + y; //返回两数之和

或者

(x, y) -> { return x + y; } //显式指明返回值

/**

* Java8 内置的四大核心函数式接口

*

* Consumer<T>: 消费型接口

* void accept（T t）；

*

* Supplier<T>: 供给型接口

* T get（）；

*

* Function <T,R>: 函数型接口

* R apply(T t);

*

* Predicate<T>: 断言型接口

* Boolean test(T t);

*/

/**

* 方法引用：若Lambda 体中的内容有方法已经实现了，我们可以使用“方法引用”

* （可以理解为方法引用是Lambda 表达式的另一种表现形式）

*

* 主要有三种语法格式：

*

* 对象：：实例方法名

*

* 类：：静态方法名

*

* 类：：实例方法名

*

* 注意：

* 1. Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致

* 2. 若Lambda 参数列表中的第一个参数是实例方法的调用者，第二个参数是实例方法的参数时，可以使用 ClassName::method

*

*

* 二、 构造器引用：

*

* 格式：

* ClassName：new

*

* 注意：需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致！

*

*

* 三、数组引用：

* 格式：

* Type：new；

*/

// 对象：：实例方法名

Consumer<String> consumera = System.out::println;

consumera.accept("aaaaaaaaaa");

User user= new User("1", "小明");

Supplier<String> stringSupplier = user::getName;

stringSupplier.get();

// 类：：静态方法名

Comparator<Integer> comparator = (o1, o2) -> Integer.compare(o1, o2);

Comparator<Integer> comparator1 = Integer::compare;

// 类：：实例方法名

BiPredicate<String,String> biPredicate = (s, s2) -> s.equals(s2);

BiPredicate<String,String> biPredicate1 = String::equals;

// 构造器

Supplier<User> supplier = () -> new User();

Supplier<User> supplier1 = User::new;

BiFunction<String,String,User> biFunction = User::new;

// 数组引用

Function<Integer,String[]> function = integer -> new String[integer];

Function<Integer,String[]> function = String[]::new;