Lambda的语法非常简洁，完全没有面向对象复杂的束缚（思想：做什么，而不是怎么做）
- 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法,允许多个default方法和静态方法实现。
- 无论是JDK内置的Runnable 、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
- 使用Lambda必须具有上下文推断。
- 方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
Lambda标准格式
Lambda省去面向对象的条条框框，格式由3个部分组成：
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为：
- (参数类型 参数名称) ‐> { 代码语句 }
格式说明：
- 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
- -> 是新引入的语法格式，代表指向动作。
- 大括号内的语法与传统方法体要求基本一致。
public interface Cook {
void makeFood();
}
public class Demo2InvokeCoke {
public static void main(String[] args) {
invokeCoke(()->{
System.out.println("吃饭啦！");});
invokeCoke(()-> System.out.println("吃饭啦！"));
}
private static void invokeCoke(Cook cook) {
cook.makeFood();
}
}
//==============================================================
public class Demo3Comparator {
public static void main(String[] args) {
Person[] array = {
new Person("张三2", 18),
new Person("张三1", 20),
new Person("张三3", 19)
};
/*Arrays.sort(array, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});*/
Arrays.sort(array,(Person p1, Person p2)->{
return p1.getAge() - p2.getAge();});
for (Person person : array) {
System.out.println(person);
}
}
}
//=============================================================
public class Demo1LambdaRunnable {
public static void main(String[] args) {
new Thread(() -> System.out.println("多线程任务执行！")).start();
}
}
//================================================================
public interface Calculator {
int calc(int a, int b);
}
public class Demo4InvokeCalc {
public static void main(String[] args) {
System.out.println(invokeCalc(120,130,(int a,int b)->{
return a + b;}));
}
public static int invokeCalc(int a, int b, Calculator calculator) {
return calculator.calc(a, b);
}
}
@FunctionalInterface
interface Foo{
// public void sayHello() ;
// public void say886() ;
public int add(int x,int y);
default int div(int x,int y) {
return x/y;
}
public static int sub(int x,int y) {
return x-y;
}
}
/**
*
* @Description: Lambda Express-----> 函数式编程
* 1 拷贝小括号(形参列表)，写死右箭头 ->，落地大括号 {方法实现}
* 2 有且只有一个public方法@FunctionalInterface注解增强定义
* 3 default方法默认实现
* 4 静态方法实现
*/
public class LambdaDemo {
public static void main(String[] args){
// Foo foo = new Foo() {
// @Override
// public void sayHello() {
// System.out.println("Hello!!");
// }
//
// @Override
// public void say886() {
// // TODO Auto-generated method stub
//
// }
// };
// foo.sayHello();
// System.out.println("============");
// foo = ()->{System.out.println("Hello!! lambda !!");};
// foo.sayHello();
Foo foo = (x,y)->{
System.out.println("Hello!! lambda !!");
return x+y;
};
int result = foo.add(3,5);
System.out.println("******result="+result);
System.out.println("******result div="+foo.div(10, 2));
System.out.println("******result sub="+Foo.sub(10, 2));
}
}
省略规则
在Lambda标准格式的基础上，使用省略写法的规则为：
小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
演变
public class TestLambda {
static class Foo2 implements Foo {
@Override
public void foo() {
System.out.println("静态内部类实现~~~");
}
}
public static void main(String[] args) {
Foo foo = null;
//1.外部实现类
foo = new Foo1();
foo.foo();
//2.静态内部类
foo = new Foo2();
foo.foo();
//3.局部内部类
class Foo3 implements Foo {
@Override
public void foo() {
System.out.println("局部内部类实现~~~");
}
}
foo = new Foo3();
foo.foo();
//4.匿名内部类
foo = new Foo() {
@Override
public void foo() {
System.out.println("匿名内部类实现~~~");
}
};
foo.foo();
//5.Lambda表达式
foo = () -> System.out.println("Lambda表达式实现~~~");
foo.foo();
}
}
interface Foo {
void foo();
}
class Foo1 implements Foo {
@Override
public void foo() {
System.out.println("外部类实现~~~");
}
}
