Lambda表达式

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() {
            @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("外部类实现~~~");
    }
}