1､Lambda 表达式是使用内部类来实现的？
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
Lambda表达式不是简单的匿名内部类，因为使用匿名内部类，编译器会为每一个匿名内部类创建一个类文件，而类在使用前需要加载类文件并进行验证，这个过程会影响应用的启动性能。类文件加载很可能是一个耗时的操作，若Lambda采用匿名内部类实现，会使应用内存占用增加，同时也会使Lambda表达式与匿名内部类的字节码生成机制绑定。所以Lambda表达式不是采用匿名内部类来实现。
我们通过分析下面代码：
public class Lambda {
Function<String, Integer> f = s -> Integer.parseInt(s);
}
查看上面的类经过编译之后生成的字节码，可以看到Lambda使用了java中的动态指令，所以Lambda内部并不是使用内部类来实现的。：
aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: invokedynamic #2, 0 // InvokeDynamic
#0:apply:()Ljava/util/function/Function;
10: putfield #3 // Field f:Ljava/util/function/Function;
13: return
2､Lambda表达式是怎么运行的？
Lambda表达式将翻译策略推迟到运行时，主要是将表达式转成字节码invoked dynamic指令，如上面编译成的字节码，主要有以下两步：
1)生成一个invoked dynamic调用点（dynamic工厂），当Lambda表达式被调用时，会返回一个Lambda表达式转化成的函数式接口实例；
2)将lambda表达式的方法体转换成方法供invoked dynamic指令调用。
对于大多数情况下，Lambda表达式要比匿名内部类性能更优。
3､ Lambda表达式是怎么翻译成机器识别的代码？
对于Lambda表达式翻译成实际运行代码，分为对变量捕获和不对变量捕获方法，即是否需要访问外部变量。
对于下面的表达式：
public class Lambda {
Function<String, Integer> f = s -> Integer.parseInt(s);
}
1)对于不进行变量捕获的Lambda表达式，其方法实现会被提取到一个与之具有相同签名的静态方法中，这个静态方法和Lambda表达式位同一个类上。
上面的表达式会变成：
static Integer lambda$1(String s) {
return Integer.parseInt(s);
}
4､lambda表达式相对于匿名内部来说有什么优点？
1)连接方面，上面提到的Lambda工厂，这一步相当于匿名内部类的类加载过程，虽然预加热会消耗时间，但随着调用点连接的增加，代码被频繁调用后，性能会提升，另一方面，如果连接不频繁，Lambda工厂方法也会比匿名内部类加载快，最高可达100倍；
2)如果lambda不用捕获变量，会自动进行优化，避免基于Lambda工厂实现下额外创建对象，而匿名内部类，这一步对应的是创建外部类的实例，需要更多的内存；
5、Lambda表达式语法
Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为->， 该操作符被称为Lambda操作符或剪头操作符。它将Lambda分为两个部分：左侧：指定了
Lambda表达式需要的所有参数右侧：指定了
Lambda体，即Lambda表达式要执行的功能。
6､在android studio中使用Lambda
android {
compileSdkVersion 29
buildToolsVersion "29.0.0"
defaultConfig {
applicationId "com.lambda"
minSdkVersion 15
targetSdkVersion 29
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
.....
compileOptions {
sourceCompatibility = '1.8'
targetCompatibility = '1.8'
}
}
7､ Lambda的一些常用替换写法
/**
* 1.无参数+语句(代码块)：适用于匿名内部类中方法无参数的情况
* 第一种方式,无参数+语句(代码块)：适用于匿名内部类中方法无参数的情况
* () -> 语句
* 或
* () -> {代码块}
*/
private void lambdaNoParams() {
new Thread(new Runnable() {
@Override
public void run() {
Toast.makeText(activitContext, "匿名内部类中 》方法无参数", Toast.LENGTH_SHORT).show();
Toast.makeText(activitContext, "匿名内部类中 》方法无参数", Toast.LENGTH_SHORT).show();
}
}).start();
new Thread(() -> Toast.makeText(activitContext, "匿名内部类中 》方法无参数() -> 语句", Toast.LENGTH_SHORT).show());
new Thread(() -> {
Toast.makeText(activitContext, "匿名内部类中 》方法无参数 () -> {代码块}", Toast.LENGTH_SHORT).show();
Toast.makeText(activitContext, "匿名内部类中 》方法无参数 () -> {代码块}", Toast.LENGTH_SHORT).show();
}).start();
}
/**
* 第二种方式，有参数+语句：适用于匿名内部类中方法只有一个参数的情况
* 方法参数 -> 语句
* 或
* 方法参数 -> {代码块}
* Lambda 只需要一个参数时，参数的小括号可以省略
*/
private void lambdaWithParams1() {
mTextView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(activitContext, "匿名内部类中 》方法只有一个参数", Toast.LENGTH_SHORT).show();
}
});
View.OnClickListener onClickListener=view->{
Toast.makeText(activitContext, "匿名内部类中 》方法只有一个参数方法参数 -> {代码块}", Toast.LENGTH_SHORT).show();
Log.i(TAG, "匿名内部类中 》方法只有一个参数方法参数 -> {代码块}");
};
mTextView.setOnClickListener(onClickListener);
mTextView.setOnClickListener((view) -> {
Toast.makeText(activitContext, "匿名内部类中 》方法只有一个参数方法参数 -> {代码块}", Toast.LENGTH_SHORT).show();
Log.i(TAG, "匿名内部类中 》方法只有一个参数方法参数 -> {代码块}");
});
}
/**
* 第三种方式，有参数+代码块：适用于匿名内部类中方法不止一个参数的情况
* (参数1, 参数2) -> 语句
* 或
* (参数1, 参数2) -> {代码块}
* 当 Lambda 体只有一条语句时，return 与大括号可以省略
*/
private void lambdaWithParams2() {
mCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
Toast.makeText(activitContext, "匿名内部类中 》方法只有一个参数", Toast.LENGTH_SHORT).show();
Log.i(TAG, "匿名内部类中 》方法只有一个参数");
}
});
mCheckBox.setOnCheckedChangeListener((compoundButton,b)->{ Toast.makeText(activitContext, "匿名内部类中 》方法2个参数(参数1, 参数2) -> {代码块}", Toast.LENGTH_SHORT).show();
Log.i(TAG, "匿名内部类中 》方法2个参数(参数1, 参数2) -> {代码块}");});
}
什么是函数式接口
- 只包含
一个抽象方法的接口，称为函数式接口。 - 你可以通过
Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。 - 我们可以在任意
函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。 -
自定义函数式接口
@FunctionalInterface
public interface StudentListener {
public void getStudent();
}
//函数式接口中使用泛型
@FunctionalInterface
public interface StudentsListner<T> {
public T getStudent(T t);
}
-
作为参数传递 Lambda 表达式
作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。
public Student studentInterface(StudentsListner<Student> sl, Student student) {
return sl.getStudent(student);
}
public void sss() {
Student student = studentInterface(st -> {
return st;
},new Student());
}
8、方法引用与构造器引用
-
方法引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 :: 将方法名和对象或类的名字分隔开来。
如下三种主要使用情况
- 对象 ：：实例方法
- 类 ：：静态方法
- 类 ：：实例方法
(x) -> System.out.println(x);
// 等同于
System.out::println;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
//三者等同
BinaryOperator<Double> bo=new BinaryOperator<Double>() {
@Override
public Double apply(Double aDouble, Double aDouble2) {
return Math.pow(aDouble,aDouble2);
}
};
BinaryOperator<Double> bo2=(x,y)->Math.pow(x,y);
BinaryOperator<Double> bo3=Math::pow;
}
注意：当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引用方法的第二个参数(或无参数)时：ClassName::methodName
-
构造器引用
格式： ClassName::new
与函数式接口相结合，自动与函数式接口中方法兼容。
可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！
Function<Integer, Student> function = new Function<Integer, Student>() {
@Override
public Student apply(Integer integer) throws Throwable {
return new Student(integer);
}
};
Function<Integer, Student> function1 = (integer) -> new Student(integer);
Function<Integer,Student> function2= Student::new;
-
数组引用
Function<Integer, Integer[]> fun = new Function<Integer, Integer[]>() {
@Override
public Integer[] apply(Integer integer) throws Throwable {
return new Integer[integer];
}
};
fun=integer -> {return new Integer[integer];
fun=Integer[]::new;
