编辑
一、概述
-
Lambda表达式是java对函数接口实现类对象的一种简化形式，本质是一个值（必须使用变量存储之后才能存在），在java中主要是体现在对特殊的匿名内部类对象的一种表示（就是对匿名内部类对函数式接口实现的简化），代表都是函数式接口的匿名内部类的对象。
-
简单理解：Lambda表达式是对接口匿名内部类格式的一种简化，但是本质不一样。都是匿名内部类对象，但是匿名内部类对象是一个进行单独编译，创建的对象，Lambda表达式不会单独编译，本质是值。值表示了匿名内部类的对象。
二、前提
-
有且只有一个抽象方法的接口，函数式接口
-
必须要有上下文推断，根据接口中抽象方法进行Lambda表达式的书写。
三、格式
（一）标准格式
三个一：一个小括号、一个箭头、一个花括号
（参数列表）—> {执行代码块}
（二）格式解释
(参数列表)： 里面写实现的函数式接口中的抽象方法的参数。【就是接口抽象方法的参数列表】 ->： 原封不动。 他是lambda表达式的标志，Lambda运算符，也可以叫"箭头运算符"。 {执行代码段}：lambda表达式对接口抽象方法的重写,，相当于之前重写抽象的方法体.。也称之为lambda体。
（三）语法格式
1、没有参数，没有返回值
（）——> System.out.println（“Hello Lambda”）；
注意：没有参数小括号不能省略。
2、有一个参数，没有返回值
X ——> System.out.println（"你好"+X）；
注意：如果只有一个参数，小括号可以省略，可以省略参数类型
3、有多个参数，没有返回值
（x，y）——> System.out.println（x+y）；
注意：不能省略小括号，但依然可以省略参数类型
4、无参数，有返回值
（）——> {return "HelloWorld"}
（）——> "HelloWorld"
注意：Lambda体只有一条语句，可以省略大括号同时也要省略return关键词
5、有参数，有返回值
（x，y）——> {return x > y?x:y}；
（x，y）——>x>y?x:y；
四、结论
Lambda表示式就是得到函数式接口实现类对象的另一种体现。
函数式接口实现方式有：
1、定义实现类创建对象
2、匿名内部类
3、Lambda表达式
五、代码示例
无参无返的Lambda表达式
public class UseLambda {
public static void main(String[] args) {
// 匿名内部类对Inter1函数式接口提供实现
Inter1 imp1 = new Inter1() {
@Override
public void eat() {
System.out.println("吃炸鸡喝啤酒");
}
};
imp1.eat();
// Lambda对Inter1函数式接口体统实现类对象
// Lambda对那种类型的函数式接口体现实现类,就定义那种接口类型的变量存储Lambda表达式
/*
(参数列表)：里面写实现的函数式接口中的抽象方法的参数.【就是接口抽象方法的参数列表】
->：原封不动 他是lambda表达式的标志,Lambda运算符,也可以叫"箭头运算符"
{执行代码段}：lambda表达式对接口抽象方法的重写, 相当于之前重写抽象的方法体. 也称
之为lambda体.
*/
// 无参数无返回值的Lambda表达式
Inter1 imp2 = () -> {
System.out.println("Lambda....吃炸鸡喝啤酒");
};
imp2.eat();
}
}
@FunctionalInterface
interface Inter1 {
// 无参数无返回值的抽象方法
public abstract void eat();
}
有一个参数无返回值的Lambda表达式
public class UseLambda2 {
public static void main(String[] args) {
// 匿名内部类对Inter2函数式接口提供实现类
Inter2 imp1 = new Inter2() {
@Override
public void show(String name) {
System.out.println("匿名内部类----"+name);
}
};
imp1.show("tom");
// Lambda表达式对Inter2函数式接口提供实现类
Inter2 imp2 = (String name) -> {
System.out.println("Lambda---"+name);
};
imp2.show("rose");
// Lambda表达式中参数列表可以省略数据类型
Inter2 imp3 = (name)->{
System.out.println("参数省略数据类型的Lambda表达式----"+name);
};
imp3.show("jack");
// Lambda表达式中有且只有一个参数的时候,可以省略小括号, 参数名可以不合抽象方法一样
Inter2 imp4 = a->{
System.out.println("省略小括号的Lambda表达式----"+a);
};
imp4.show("lucy");
// Lambda中如果Lambda体中有且只有一句java代码,省略大括号
Inter2 imp5 = name-> System.out.println("省略大括号的Lambda表达式---"+name);
imp5.show("lilei");
}
}
@FunctionalInterface
interface Inter2 {
// 有一个参数,无返回值的抽象方法
public abstract void show(String name);
}
多个参数无返回值Lambda表达式
public class UseLambda1 {
public static void main(String[] args) {
// 匿名内部类实现Inter1接口
Inter1 imp1 = new Inter1() {
@Override
public void printSum(int a, int b) {
System.out.println(a+b);
}
};
imp1.printSum(10, 20);
// Lambda实现Inter1接口 Lambda实现多个参数无返回值的方法
Inter1 imp2 = (int a, int b) -> {
System.out.println(a+b);
};
imp2.printSum(20, 30);
// 多个参数是不能省略小括号,但是依然可以省略参数类型
Inter1 imp3 = (a, b)-> System.out.println(a+b);
imp3.printSum(10, 100);
System.out.println("====================================");
// 匿名内部类可以对非函数式接口提供实现
Inter2 imp4 = new Inter2() {
@Override
public void eat() {
System.out.println("吃东西");
}
@Override
public void drink() {
System.out.println("喝东西");
}
};
imp4.eat();
imp4.drink();
// Lambda只能对函数式借口提供实现类对象
/* Inter2 imp5 = () -> {
};*/
}
}
@FunctionalInterface
interface Inter1 {
// 多个参数没有返回值的抽象方法
public abstract void printSum(int a, int b);
}
interface Inter2 {
public abstract void eat();
public abstract void drink();
}
无参数有返回值的Lambda表达式
public class UseLambda2 {
public static void main(String[] args) {
// 匿名内部类对Inter3提供实现
Inter3 imp1 = new Inter3() {
@Override
public int getRandomInt() {
Random r = new Random();
return r.nextInt(100);
}
};
int r = imp1.getRandomInt();
System.out.println(r);
// Lambda提供Inter3的实现对象
// Lambda实现接口中带有返回值的抽象法Lambda体中也要有return语句
Inter3 imp2 = () -> {
Random ran = new Random();
return ran.nextInt(200);
};
System.out.println(imp2.getRandomInt());
// 如果带有返回值的Lambda体(大括号)只有一条语句.可以省略大括号,但是同时也要把return关键字省掉.
Inter3 imp3 = ()-> new Random().nextInt(50);
int r2 = imp3.getRandomInt();
System.out.println(r2);
}
}
@FunctionalInterface
interface Inter3 {
public abstract int getRandomInt();
}
有参数有返回值的Lambda表达式
public class UseLambda3 {
public static void main(String[] args) {
// 匿名内部类提供Inter4的实现对象
Inter4 imp1 = new Inter4() {
@Override
public int useTwoNumber(int a, int b) {
return a > b ? a : b;
}
};
int r1 = imp1.useTwoNumber(10, 20);
System.out.println(r1);
// Lambda提供Inter4的实现对象
Inter4 imp2 = (int a, int b) -> {
return a > b ? a : b;
};
System.out.println(imp2.useTwoNumber(100, 200));
// 简化Lambda表达式
Inter4 imp3 = (a, b) -> a > b ? a : b;
System.out.println(imp3.useTwoNumber(10, 5));
}
}
@FunctionalInterface
interface Inter4 {
// 有参数有返回值的抽象方法
public abstract int useTwoNumber(int a, int b);
}
扫一扫
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
