Java JDK 1.8 新特性 lambda表达式与方法引用

Lambda表达式标准格式

(参数列表) -> {
	方法体
}

Lambda表达式省略格式

(int arg) -> {
 return new Object();
}

// 省略规则
// 规则 1 小括号内参数的类型可以省略
(arg) -> {
 return new Object();
}

// 规则 2 如果小括号内有且仅有一个参数，则小括号可以省略
arg -> {
 return new Object();
}

// 规则 3 如果大括号内有且仅有一个语句，可以同时省略大括号，return关键字，语句分号
arg -> new Object()

Lambda表达式前提条件

1. 方法的参数或变量的类型是接口
2. 接口中只能有一个抽象方法

Lambda代码冗余

当我们在表达式中调用外部的函数时，那我们的表达式就会显得非常多余，这时我们就可以通过方式二的写法，也就是方法引用，更进一步的优化lambda表达式

// 方式一
public class LambdaIntro {

    public static void getMaxNum(int[] arr) {
        System.out.println(Arrays.stream(arr).max().getAsInt());
    }

    public static void main(String[] args) {
        printMax((int[] arr) -> {
            getMaxNum(arr);
        });
    }

    public static void printMax(Consumer<int[]> consumer){
        int[] arr = {1, 3, 4, 5};
        consumer.accept(arr);
    }
}
// 方式二
public static void main(String[] args) {
    printMax(LambdaIntro::getMaxNum);
}

方法引用的语法

// 对象::实例方法 为了方便观看，以下lambda均未简化
// 注意事项: 被引用的方法，参数与返回值要和接口中抽象方法的参数一样
public class LambdaIntro {
    public static void main(String[] args) {
        // 冗余写法
        Date date = new Date();
        Supplier<Long> supplier = () -> {
            return date.getTime();
        };
        System.out.println(supplier.get());
        // 方法引用
        Supplier<Long> supplier1 = date::getTime;
        System.out.println(supplier1.get());
    }
}

// 类名::静态方法
public class LambdaIntro {
    public static void main(String[] args) {
        // 冗余写法
        Supplier<Long> supplier = () -> {
            return System.currentTimeMillis();
        };
        System.out.println(supplier.get());
        // 方法引用
        Supplier<Long> supplier1 = System::currentTimeMillis;
        System.out.println(supplier1.get());
    }
}

// 类名::实例方法
// 注意事项: 实例方法会将第一个参数作为方法的调用者
public class LambdaIntro {
    public static void main(String[] args) {
        // 冗余写法
        Function<String, Integer> function1 = (String str) -> {
          return str.length();
        };
        System.out.println(function1.apply("zhangdy"));
        // 方法引用
        Function<String, Integer> function2 = String::length;
        System.out.println(function2.apply("zhangdy"));
    }
}
// 类名::new调用的构造器
@Data
@NoArgsConstructor
@AllArgsConstructor
class Person {
    private String name;
    private Integer age;
}

public class LambdaIntro {
    public static void main(String[] args) {
        // 冗余写法
        Supplier<Person> supplier = () -> {
            return new Person();
        };
        BiFunction<String, Integer, Person> function = (String name, Integer age) -> {
            return new Person(name, age);
        };
        System.out.println(supplier.get());
        System.out.println(function.apply("zhangdy", 23));
        // 方法引用
        Supplier<Person> supplier2 = Person::new;
        BiFunction<String, Integer, Person> function2 = Person::new;
        System.out.println(supplier2.get());
        System.out.println(function2.apply("zhangdy", 23));
    }
}
// 常用数据类型[]::new 调用数组的构造器
public class LambdaIntro {
    public static void main(String[] args) {
        // 冗余写法
        Function<Integer, String[]> function = (Integer len) -> {
            return new String[len];
        };
        String[] apply = function.apply(10);
        System.out.println(apply.length);
        // 方法引用
        Function<Integer, String[]> function2 = String[]::new;
        String[] apply1 = function2.apply(10);
        System.out.println(apply1.length);
    }
}