6. 类型推断
Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，由编译器推断出来的。这就是所谓的“类型推断”。
说白了就是利用泛型类的特性，直接可以让我们省去类型。
代码示例：
接口
package com.example.springboot01hello.dao; @FunctionalInterface //表明我们这里是函数式接口，可设可不设。设置的话会提升性能 public interface interface1<String> { void show(java.lang.String str); }
测试
@Test public void test3() { // 匿名内部类创建 带有泛型参数的 interface1<String> interface0 = new interface1<String>() { @Override public void show(String str) { System.out.println(str); } }; interface0.show("hello"); // 使用lambda进行改造 interface1<String> stringinterface1 = (String str) -> { System.out.println(str); }; stringinterface1.show("world"); // 使用lambda进行再次优化， 去掉类型和()与{} interface1<String> stringinterface3 = str -> System.out.println(str); stringinterface3.show("jsxs"); }
7.参数传递
我们都知道lambda是一个实例，使用lambda的时候必须要有变量引用，除变量引用外，这样进行方法内的参数传递也是可以的
(1).代码实列一
@FunctionalInterface interface MyFunc<T> { T getValue(T t); } public class Test { public static void main(String[] args) { // str的小括号是可以去掉的 String abc = toUpperString((str) -> str.toUpperCase(), "abc"); // String abc = toUpperString(str -> str.toUpperCase(), "abc"); System.out.println(abc); } public static String toUpperString(MyFunc<String> consumer, String str) { return consumer.getValue(str); } }
将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型 必须是 与该 Lambda 表达式兼容的函数式接口的类型。
(2).代码示例二
Java当中很多都是基于参数传递来使用lambda的，就拿集合的forEach来说。
import java.util.Arrays; import java.util.List; public class jsxs1 { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.forEach(b-> System.out.println(b)); } }
8.引用
(1).方法引用
什么是方法引用？
方法引用也是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
什么时候使用方法引用？
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
如下三种主要使用情况：
- 对象::实例方法名
- 类::静态方法名
- 类::实例方法名
格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
ClassName::methodName
使用要求
实现接口的抽象方法的参数列表 和 返回值类型，必须与方法引用的方法的 参数列表 和 返回值类型 保持一致！
代码示例一：
Consumer消费型函数，也就是只有入参，没有返回值的。
import java.util.function.Consumer; public class jsxs1 { public static void main(String[] args) { // 消费者内部匿名类 Consumer consumer = new Consumer() { @Override public void accept(Object o) { System.out.println("消费者接口"); } }; // 创建lamda Consumer consumer1 = (x) -> System.out.println(x); consumer1.accept("hello"); // 方法引用 Consumer consumer2=System.out::print; consumer2.accept("world"); } }
代码示例二：
Comparator 比较器 函数，有两个入参，和一个返回值。
import java.util.Comparator; public class jsxs1 { public static void main(String[] args) { // 1.匿名内部类创建，<Integer>这个泛型一定要带，不然下面就只能是object new Comparator<Integer>(){ @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1,o2); } }; // lambda方式创建，<Integer>这个泛型一定要带,不然报错 Comparator<Integer> comparator1 = (a, b) -> Integer.compare(a, b); System.out.println(comparator1.compare(1, 2)); // 方法引用,<Integer>这个泛型一定要带,不然报错 Comparator<Integer> compare = Integer::compare; System.out.println(compare.compare(6, 4)); // 判断前面的值是否大于后面的值 } }
代码示例三：
BiPredicate是一个判定型的 函数，有两个入参，和一个Boolean返回值。
import java.util.Comparator; import java.util.function.BiPredicate; public class jsxs1 { public static void main(String[] args) { // 这里的<String, String>类型不能丢，因为下面用的是String,如果不声明类型就是Object BiPredicate biPredicate = new BiPredicate<String, String>() { @Override public boolean test(String o, String o2) { return o.equals(o2); } }; // 这里变量没有声明类型，那么就是Object，equals也是调用的Object的 BiPredicate biPredicate1 = (a, b) -> a.equals(b); // 这里类型必须要写，因为后面写明了调用String的equals BiPredicate<String, String> biPredicate2 = String::equals; } }
(2).构造器引用
格式： ClassName::new
与函数式接口相结合，自动与函数式接口中方法兼容。
要求构造器参数列表要与接口中抽象方法的 参数列表一致！且方法的返回值即为构造器对应类的对象。
import java.util.function.Function; class Teacher { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public Teacher(String name) { this.name = name; } } public class Test4 { public static void main(String[] args) { // 匿名内部类 Function function = new Function<String, Teacher>() { @Override public Teacher apply(String name) { return new Teacher(name); } }; // lambda Function<String, Teacher> function1 = (a) -> new Teacher(a); // 构造器引用 Function<String, Teacher> function2 = Teacher::new; } }
(3).数组引用
格式： type[] :: new
public static void main(String[] args) { // 匿名内部类 Function function = new Function<Integer, Integer[]>() { @Override public Integer[] apply(Integer x) { return new Integer[x]; } }; // lambda Function<Integer, Integer[]> function1 = a -> new Integer[a]; // 数组引用 Function<Integer, Integer[]> function2 = Integer[]::new; }
