java for底层原理是啥_Java8新特性 Lambda底层实现原理

最新推荐文章于 2023-05-12 09:11:10 发布

萬重

最新推荐文章于 2023-05-12 09:11:10 发布

阅读量124

点赞数

文章标签： java for底层原理是啥

本文链接：https://blog.csdn.net/weixin_42425947/article/details/114518168

版权

前言

经常会在写业务代码的时候，有这样的需求：

筛选出条件为XX的实体类ID ListList waitTaskList = wflInsTaskList.stream().filter(wflInsTask -> {

return wflInsTask.getArrivalStatus().equals(WflInsTask.ARRIVAL_STATUS_NOT_ARRIVED);

}).map(WflInsTask::getTaskId).distinct().collect(Collectors.toList());

Java8之Lambda

下文内容默认以JDK8为前提

什么是Lambda

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

Lambda 表达式描述了一个代码块(或者叫匿名方法)，可以将其作为参数传递给构造方法或者普通方法以便后续执行。如：() -> System.out.println("hello");

() 为 Lambda 表达式的参数列表(允许没有参数)，-> 标识这串代码为 Lambda 表达式(也就是说，看到 -> 就知道这是 Lambda，Groovy的闭包语法也类似)，System.out.println("hello") 就是执行的代码，将“hello”打印到标准输出流。

以Runnable接口为例，原来我们创建一个线程并启动它是这样的：public class Test {

public static void main(String[] args) {

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("hello");

}

}).start();

}

通过 Lambda 只需要这样：public class Test {

public static void main(String[] args) {

new Thread(() -> System.out.println("hello")).start();

}

我们看Runnable接口源码：@FunctionalInterface

public interface Runnable {

public abstract void run();

}

其中@FunctionalInterface注解中有这样一段描述：/*

Note that instances of functional interfaces can be created with

* lambda expressions, method references, or constructor references.

说明通过 @FunctionalInterface 标记的接口可以通过 Lambda 表达式创建实例。

@FunctionalInterface修饰函数式接口的，要求接口中的抽象方法只有一个。有多个抽象方法编译将报错

加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解知识提醒编译器去检查该接口是否仅包含一个抽象方法

例如：public interface Comparator {

int compare(T o1, T o2);

}

public interface Runnable {

void run();

}

public interface Callable {

V call() throws Exception;

}

上面三个接口都只有一个抽象方法，但是三个方法的签名都不一样，这要求Lambda表达式与实现接口的方法签名要一致。下面用函数描述符来表示上述三个方法的签名，箭头前面是方法的入参类型，后面是返回类型。compare：(T, T) -> int，两个泛型T类型的入参，返回int类型

Lambda表达式：(User u1, User u2) -> u1.getAge - u2.getAge

run：() -> void，无入参，无返回值

Lambda表达式：() -> { System.out.println("hello"); }

call：() -> V，无入参，返回一个泛型V类型的对象

Lambda表达式：() -> new User() //不需要用括号环绕返回值为void的单行方法调用。

语法

Lambda表达式由三部分组成：参数列表

箭头

主体

有两种风格，分别是：表达式-风格

(parameters) -> expression

块-风格

(parameters) -> { statements; }

其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符，读作(goes to)。

例：() -> {}

() -> "hello"

() -> { return "hello"; }Java 8中内部类或者Lambda表达式对外部类变量的引用条件放松了，不要求强制的加上final关键字了，但是Java 8中要求这个变量是effectively finalpublic class LambdaTest {

public static void main(String[] args) {

String str = "hello";

List list = new ArrayList<>();

list.forEach(s -> {

// 这行赋值报错 Variable used in lambda expression should be final or effectively final

// 注释掉，不赋值就是effectively final

str = "hi";

System.out.println(str);

});

}

常用函数式接口

随Lambda一同增加的还有一个java.util.function包，其中定义了一些常见的函数式接口的。比如：Function，接受一个输入参数，返回一个结果。参数与返回值的类型可以不同，我们之前的map方法内的lambda就是表示这个函数式接口的；

Consumer，接受一个输入参数并且无返回的操作。比如我们针对数据流的每一个元素进行打印，就可以用基于Consumer的lambda；

Supplier，无需输入参数，只返回结果。看接口名就知道是发挥了对象工厂的作用；

Predicate，接受一个输入参数，返回一个布尔值结果。比如我们在对数据流中的元素进行筛选的时候，就可以用基于Predicate的Lambda；

这里只解释其中一种，更多的自己去了解吧。public interface Predicate {

boolean test(T t);

}

test：T -> boolean，接收一个泛型T对象，返回一个boolean。

适用场景：表示一个涉及类型T的布尔表达式。// 判断空白字符串

Predicate isBlankPredicate = s -> s != null && s.trim().length() == 0;

isBlankPredicate.test(" "); // true

// 判断用户年龄是否大于20

Predicate agePredicate = u -> u.getAge() > 20;

agePredicate.test(new User(18)); // falseJava是一个强类型的语言，因此参数必须要有类型，如果编译器能够推测出Lambda表达式的参数类型，则不需要我们显示的进行指定。

上述代码中没有指定s参数类型Stirng，因为编译器会根据Lambda表达式对应的函数式接口Predicate进行自动推断。

复合Lambda表达式---以比较器复合(Comparator)为例

使用 Comparator 对用户年龄按从大到小进行排序：List users = Arrays.asList(new User("zhangsan", 30),

new User("lisi", 22),

new User("wangwu", 18));

users.sort(Comparator.comparing(User::getAge).reversed());

Comparator.comparing源码：@FunctionalInterface

public interface Comparator {

public static > Comparator comparing(

Function super T, ? extends U> keyExtractor)

{

Objects.requireNonNull(keyExtractor);

return (Comparator & Serializable)

(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));

}

default Comparator reversed() {

return Collections.reverseOrder(this);

}

}Java 8中在接口中增加了默认实现这种函数，其实在很大程序上违背了接口具有抽象这种特征的，增加default实现主要原因是因为考虑兼容及代码的更改成本，例如，在Java 8中向iterator这种接口增加一个方法，那么实现这个接口的所有类都要需实现一遍这个方法，那么Java 8需要更改的类就太多的，因此在Iterator接口里增加一个default实现，那么实现这个接口的所有类就都具有了这种实现

方法引用

当在Lambda表达式中直接调用了一个方法时可以使用，其写法为目标引用::方法名称指向静态方法的方法引用Function fun = s -> Integer.parseInt(s);

Function fun = Integer::parseInt;

指向任意类型实例方法的方法引用Function fun = s -> s.length();

Function fun = String::length;

指向现存外部对象实例方法的方法引用String s = "hello";

Supplier len = () -> s.length();

Supplier len = s::length;

实现原理

以下文代码为例：public class LambdaTest {

@FunctionalInterface

public interface LambdaDemo{

public void runLambda();

}

public static void doSomething(LambdaDemo demo){

demo.runLambda();

}

public static void main(String[] args) {

doSomething(()->System.out.println("hello world!"));

}

执行javac LambdaTest.java编译后生成两个class文件

javap -p LambdaTest 输出所有类和成员

由此可以看出Lambda 表达式在 Java 8 中首先会生成一个私有的静态函数，这个私有的静态函数干的就是 Lambda 表达式里面的内容。

javap -v LambdaTest输出行号、本地变量表信息、反编译汇编代码、当前类用到的常量池等信息。

其中main方法执行了一条invokedynamic指令。invokedynamic出现的位置代表一个动态调用点，invokedynamic指令后面会跟一个指向常量池的调用点限定符，这个限定符会被解析为一个动态调用点。依据这个可以找到对应的动态调用引导方法java.lang.invoke.CallSite。