赞
踩
分享一些系统的面试题,大家可以拿去刷一刷,准备面试涨薪。
这些面试题相对应的技术点:
大类就是:
大致形式就是 (param1, param2, param3, param4…) -> { doing…… };
首先要从 FunctionalInterface 注解讲起,详情见 Annotation Type FunctionalInterface 。
An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification. Conceptually, a functional interface has exactly one abstract method. Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface’s abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.
简单总结一下函数式接口的特征:
FunctionalInterface 注解标注一个函数式接口,不能标注类,方法,枚举,属性这些。
如果接口被标注了 @FunctionalInterface,这个类就必须符合函数式接口的规范。
即使一个接口没有标注 @FunctionalInterface,如果这个接口满足函数式接口规则,依旧可以被当作函数式接口。
注意:interface 中重写 Object 类中的抽象方法,不会增加接口的方法数,因为接口的实现类都是 Object 的子类。
我们可以看到 Runnable 接口,里面只有一个抽象方法 run() ,则这个接口就是一个函数式接口。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
所谓方法引用,是指如果某个方法签名和接口恰好一致,就可以直接传入方法引用。文章开头的示例中,下面这块代码就是方法引用。
ToIntBiFunction<Integer, Integer> function2 = Integer::sum;
java.lang.Integer#sum 的实现如下:
public static int sum(int a, int b) {
return a + b;
}
比如我们计算一个 Stream 的和,可以直接传入 Integer::sum 这个方法引用。
@Test
public void test1() {
Integer sum = IntStream.range(0, 10).boxed().reduce(Integer::sum).get();
System.out.println(sum);
}
上面的代码中,为什么可以直接在 reduce 方法中传入 Integer::sum 这个方法引用呢?这是因为 reduce 方法的入参就是 BinaryOperator 的函数式接口。
Optional reduce(BinaryOperator accumulator);
BinaryOperator
是继承自 BiFunction
,定义如下:
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u);
default BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));
}
}
可以看到,只要是符合R apply(T t, U u)
; 的方法引用,都可以传入 reduce 中。可以是上面代码中的 Integer::sum
,也可以是 Integer::max
。
首先写 2 个 Lambda 方法:
public class LambdaMain {
public static void main(String[] args) {
new Thread(() -> System.out.println(“1”)).start();
IntStream.range(0, 5).boxed().filter(i -> i < 3).map(i -> i + “”).collect(Collectors.toList());
}
}
之后 javac LambdaMain.java
编译成字节码文件,再通过javap -p LambdaMain
输出 class 文件的所有类和成员,得到输出结果:
Compiled from “LambdaMain.java”
public class test.jdk.LambdaMain {
public test.jdk.LambdaMain();
public static void main(java.lang.String[]);
private static java.lang.String lambda$main$2(java.lang.Integer);
private static boolean lambda$main$1(java.lang.Integer);
private static void lambda$main$0();
}
输出的 void lambda$main$0()
对应的是() -> System.out.println("1")
输出的 boolean lambda$main$1(java.lang.Integer)
对应的是i -> i < 3
输出的 java.lang.String lambda$main$2(java.lang.Integer)
对应的是 i -> i + ""
我们可以看出 Lambda 表达式在 Java 8 中首先会生成一个 私有的静态函数
。
为什么不使用匿名内部类?
如果要在 Java 语言中实现 lambda 表达式,生成匿名内部类就可以轻松实现。但是 JDK 为什么没有这么实现呢?这是因为匿名内部类有一些缺点。
每个匿名内部类都会在 编译时 创建一个对应的 class 文件 ,在 运行时 不可避免的会有加载、验证、准备、解析、初始化等 类加载 过程。
每次调用都会创建一个这个 匿名内部类 class 的实例对象 ,无论是有状态的(使用到了外部的变量)还是无状态(没有使用外部变量)的内部类。
invokedynamic
本来要写文字的,但是俺发现俺总结的思维导图还挺清晰的,直接提出来吧,囧。
详情见 Class LambdaMetafactory 官方文档 ,java.lang.invoke.LambdaMetafactory#metafactory 的实现。
public static CallSite metafactory(MethodHandles.Lookup caller,
String invokedName,
MethodType invokedType,
MethodType samMethodType,
MethodHandle implMethod,
为了这次面试,也收集了很多的面试题!
以下是部分面试题截图
nvokedType,
MethodType samMethodType,
MethodHandle implMethod,
为了这次面试,也收集了很多的面试题!
以下是部分面试题截图
[外链图片转存中…(img-9b8x9pch-1714838856617)]
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。