Lambda表达式

Lambda表达式

概述

Lambda表达式是java对数学函数表达式的一种体现形式，本质是一个值，在java中主要是体现在对特殊的匿名内部类对象的一种表示，代表匿名内部类的对象。

只有该接口是一个函数式接口，才可以使用Lambda表达式来代替匿名内部类。

也可以理解为Lambda表达式是匿名内部类格式的一种简化，但是本质不一样。

也可以理解为Lambda表达式就是一个函数式接口的对象，也可以理解为是对函数式接口的一个补充和完整。

函数式接口概述

有且只有一个抽象方法的接口就是函数式接口，函数式接口只有一个抽象方法，其他方法可以有任意多个。

格式

标准格式：【三个一：一个小括号 一个箭头 一个花括号】
(参数列表) -> {执行代码段}

格式解释：
(参数列表)：是匿名内部类中重写的抽象方法的方法参数列表，此参数列表不需要书写数据类型，只写变量名即可。
【就是接口抽象方法的参数列表】
->：原封不动 他是lambda表达式的标志
{执行代码段}：lambda表达式对接口抽象方法的重写

普通格式

public class D01入门 {
    public static void main(String[] args) {
//        这个匿名内部类所表达的信息  主要是对work方法的实现
        Usb u = new Usb(){
            @Override
            public void work() {
                System.out.println("鼠标点点点");
            }
        };
        u.work();
        Usb u1 = () -> {System.out.println("键盘敲敲敲");};
        u1.work();
    }
}
//函数式接口
interface Usb {
    void work();
}

当做参数传递和对象返回

public class D02 {
    public static void main(String[] args) {
        Usb usb = getUsb();
        usb.work();
//        使用一个usb设备
        useUsb(() -> {System.out.println("键盘敲敲敲");});
    }
//    此方法要求返回一个Usb对象
    public static Usb getUsb(){
        return () -> {System.out.println("鼠标点点点");};
    }
//    使用一个Usb的设备
    public static  void useUsb(Usb u ){
        u.work();
    }
}

Lambda表达式的省略原则

概述 在符合一定条件下Lambda表达式的格式可以进行简化的

具体原则

1、小括号参数的参数类型可以直接省略
2、小括号的参数有且只有一个的时候，小括号可以省略 【没有和多个都不能省略，只有一个参数能省略】
3、花括号中有且只有一个执行语句的时候，可以同时省略花括号 分号 和 return关键字
	【要省略三者同时省略，否则一个都不要省略】
4、小括号和花括号的省略原则互不干扰，各省略各的

代码示例

public class D03{
    public static void main(String[] args) {
//        省略参数的类型
        A a =  (x,y) -> {
            System.out.println(x + y);
        };
        a.show("哈哈", 33);
//        省略小括号
        B b = e -> {
            System.out.println(e.length());
        };
        b.methodB("哈哈你个嘚嘚");
//        省略return关键字和大括号
        C c = x ->  x.length();
        System.out.println(c.getLength("哈哈"));
    }
}
interface  A {
    void  show (String name ,int age );
}
interface B {
    void methodB (String x );
}
interface C {
    int getLength(String s );
}

方法引用

方法引用是对函数式接口的实现类对象体现的另一种方式

特殊条件

如果Lambda表达式表达的信息，在其他的类当中，已经被其他的方法所实现过了
该Lambda表达式就可以使用其他类的实现了该方法的引用去进行代替
如果符合条件，方法引用可以当做函数式接口的对象。

使用前提

1、有且只有一个抽象方法的接口【函数式接口】
2、必须有上下文推断

方法引用的格式

静态方法引用：
类名 :: 静态方法名

普通方法引用：
对象名 :: 普通方法名

构造方法的引用：
类名 :: new

代码示例

public class D04 {
    public static void main(String[] args) {
//        本次lambda表达式表达的信息是返回两个数字之间比较大的值
        N n = (x, y) -> x > y ? x : y;
        System.out.println(n.number(1.1, 1.2));

//        使用方法引用创建N的对象  静态方法  类名 :: 方法名
        N n1 = Math::max;
        System.out.println(n1.number(3, 2));

//        非静态的方法引用  对象名 :: 方法名
        N n2 = new D04方法引用() :: sum;
        System.out.println(n2.number(3, 10));
    }

//    非静态方法
    public double sum(double d1, double d2) {
        return d1 + d2;
    }
}

interface N {
    double number(double d1, double d2);
}

构造方法的方法引用

public class D05 {
    public static void main(String[] args) {
//        Lambda表达式形式
        FactoryCat fc = (x, y) -> new Cat(x, y);
        Cat hh = fc.getCat("花花", 3);

//        使用构造方法引用
        FactoryCat fc2 = Cat::new;
        Cat beibei = fc2.getCat("贝贝", 2);

    }
}

class Cat {
    String name;
    int age;

    public Cat() {
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

interface FactoryCat {
    Cat getCat(String name, int age);
}