本文介绍了Java 8 Lambda表达式的基本语法、使用条件和原理，通过实例展示了其在Runnable、无参无返回值、有参无返回值等场景的应用。重点讲解了Lambda与匿名内部类的区别，以及如何在接口方法中进行类型推断。
序言
- 概述：
- Lambda是JDK8语法糖中函数式编程思想，让我们不用关注是什么对象，而关注的是对数据进行了什么操作【三更草堂】。
- Lambda可以对某些匿名内部类的写法进行简化。
-
基本格式【boge】：
(参数类型 参数名称) -> {代码体;}格式说明：(参数类型 参数名称)：参数列表{代码体;}：方法体->：箭头，分割参数列表和方法体 -
省略规则 【三更草堂】 ：
* 小括号内的参数类型可以省略。
* 如果方法只有一个参数，则小括号可以省略。
* 如果方法体有且仅有一句代码，则可以同时省略大括号、return关键字、唯一一句代码的语句分号。
* 以上这些规则都记不住也可以省略不记。 -
Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意：【boge】
1. 方法的参数或局部变量类型必须为接口才能使用Lambda2. 接口中有且仅有一个抽象方法(@FunctionalInterface) -
Lambda表达式的原理【boge】
匿名内部类在编译的时候会产生一个class文件。Lambda表达式在程序运行的时候会形成一个类。1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码2. 还会形成一个匿名内部类，实现接口，重写抽象方法3. 在接口中重写方法会调用新生成的方法 -
类型推断 【sgg】上述 Lambda 表达式中的参数类型都是由编译器推断 得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “ 类型推断”
-
Lambda和匿名内部类的对比【boge】
1. 所需类型不一样匿名内部类的类型可以是 类，抽象类，接口Lambda表达式需要的类型必须是接口2. 抽象方法的数量不一样匿名内部类所需的接口中的抽象方法的数量是随意的Lambda表达式所需的接口中只能有一个抽象方法3. 实现原理不一样匿名内部类是在编译后形成一个classLambda表达式是在程序运行的时候动态生成 class
一 生活中的需求：Runnable接口、run()方法
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Ex01 {
public static void main1(String[] args) {
// 我们在创建线程并启动时可以使用匿名内部类的写法：
new Thread(new Runnable() {
public void run() {
System.out.println("你知道吗 我比你想象的 更想在你身边01");
}
}).start();
}
}
class Ex11{
public static void main(String[] args) {
new Thread(()->{
System.out.println("你知道吗 我比你想象的 更想在你身边02");
}).start();
}
}二 生活中的需求：无参无返回值的Lambda
public class Ex6 {
public static void goShow(UserService userService){
userService.show();
}
public static void main(String[] args) {
// 非lambda，匿名内部类的写法调用该方法
goShow(
new UserService() {
@Override
public void show() {
System.out.println("show 方法执行了...");
}
});
// lambda
goShow(
()
->
{ System.out.println("Lambda show 方法执行了..."); }
);
}
}
interface UserService {
void show();
}三 生活中的需求：有参无返回值的Lambda
import java.sql.SQLOutput;
public class Ex05 {
public static void foreachArr(IntConsumer consumer){
int[] arr = {1,2,3,4,5,6,7,8,9,10};
for (int i : arr) {
consumer.accept(i);
}
}
public static void main(String[] args) {
// 非lambda，匿名内部类的写法调用该方法
foreachArr(new IntConsumer() {
public void accept(int value) {
System.out.println(value);
}
});
// lambda格式
foreachArr(
(int value)
->
{
System.out.println(value);
}
);
}
}
interface IntConsumer{
void accept(int value);
}
四 生活中的需求：有参有返回值的Lambda
public class Ex03 {
public static void printNum(IntPredicate predicate){
int[] arr = {1,2,3,4,5,6,7,8,9,10};
for (int i : arr) {
if(predicate.test(i)){
System.out.println(i);
}
}
}
public static void main1(String[] args) {
// 非lambda，匿名内部类的写法调用该方法
printNum(new IntPredicate() {
public boolean test(int value) {
return value%2==0;
}
});
// lambda格式
printNum(
(int value)
->
{
return value%2==0;
}
);
}
}
interface IntPredicate{
boolean test(int value);
}public class Ex04 {
public static <R> R typeConver(Function<String,R> function){
String str = "1235";
R result = function.apply(str);
return result;
}
public static void main(String[] args) {
// 非lambda，先使用匿名内部类的写法调用该方法
Integer result1 = typeConver(new Function<String, Integer>() {
public Integer apply(String s) {
return Integer.valueOf(s);
}
});
System.out.println(result1);
// lambda
Integer result2 = typeConver(
(String s)
->
{
return Integer.valueOf(s);
}
);
System.out.println("lambda结果 = "+result2);
}
}
interface Function<String,Integer>{
Integer apply(String s);
}public class Ex02 {
public static int calculateNum(IntBinaryOperator operator){
int a = 10;
int b = 20;
return operator.applyAsInt(a, b);
}
public static void main(String[] args) {
// 非lambda，先使用匿名内部类的写法调用该方法
int i1 = calculateNum(new IntBinaryOperator() {
public int applyAsInt(int left, int right) {
return left + right;
}
});
System.out.println(i1);
// lambda
int i2 = calculateNum(
(int left, int right)
->
{
return left + right;
}
);
System.out.println(i2);
}
}
interface IntBinaryOperator{
int applyAsInt(int a,int b);
}五 生活中的需求：forEach循环：普通、ArrayList、HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.stream.IntStream;
public class ExFor {
public static void main(String[] args) {
System.out.println("--------------------------普通的for循环-------------------------------------");
IntStream.range(0,4).forEach(
i
->
System.out.println("循环变量i:"+i)
);
System.out.println("--------------------------arrayList-------------------------------------");
int[] index = {0};
ArrayList list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.forEach(
e
->
{
index[0] = list.indexOf(e);
System.out.print("循环变量i："+index[0]+"\t");
System.out.println("list里面的值："+e);
}
);
System.out.println("--------------------------hashmap-------------------------------------");
HashMap<String, String> map = new HashMap();
map.put("1", "张三");
map.put("2", "李四");
map.put("3", "王五");
map.forEach(
(k,v)
->
System.out.println("键："+k+",值："+v)
);
}
}
六 生活中的需求：接口只能声明一个抽象方法：@FunctionalInterface注解【boge】
/**
* @FunctionalInterface
* 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
*/
@FunctionalInterface
public interface UserService {
void show();
}
扫一扫
116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
