JavaSE-Lambda表达式

6.1 Lambda表达式的标准格式

匿名内部类中重写run()方法的代码分析

方法形式参数为空
方法返回值类型为void, 说明方法执行没有结果返回
方法体中的内容,是我们具体要做的事情

Lambda表达式的代码分析

():里面没有内容,可以看成是方法形式参数为空
->:用箭头指向后面要做的事
{}:包含一段代码,我们称之为代码块,可以堪称是方法体中的内容

组成Lambda表达式的三要素:形式参数,箭头,代码块

// 匿名内部类
new Thread(new Runnable(){
	public void run(){
		System.out.println("多线程程序启动了");
	}
}).start();

new Thread(()->{
	System.out.println("多线程程序启动了");
}).start();

6.2 Lambda表达式的省略规则

省略规则

参数类型可以省略.但是有多个参数的情况下,不能只省略一个
如果参数有且只有一个,那么下括号也可以省略
如果代码块的语句只有一条,可以省略大括号,有return也要省略return

6.3 Lambda表达式的注意事项

注意事项:

使用Lambda必须要有接口,并且要求接口中有且仅有一个抽象方法
必须有上下文环境,才能推导出lambda对应的接口

根据局部变量的赋值得到Lambda对应的接口:

Runnable = ()->System.out.println("Lambda表达式");

根据调用方法的参数得知Lambda对应的接口:

new Thread(()-> System.out.println("Lambda表达式")).start();

6.4 Lambda表达式和匿名内部类的区别

所需类型不同

匿名内部类:可以是接口，也可以是抽象类，还可以是具体类0
Lambda表达式:只能是接口

使用限制不同

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

匿名内部类: 编译之后，产生一个单独的.class字节码文件
Lambda表达式:编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

6.5 方法引用符

方法引用符:

::该符号为引用运算符,而他所在的表达式被称为方法引用

推导与省略:

如果使用Lambda,那么根据"可推到就是可省略"的原则,无需指定参数类型,也无需指定重载形式,他们都将被自动推导
如果使用方法引用,也同样可以根据上下文进行推导

方法引用是LAmbda的孪生兄弟

public interface Printable {
    void printInt(int i);
}

public class PrintableDemo {
    public static void main(String[] args) {
        // Lambda
        userPrintable(i -> System.out.println(i));
        // 方法引用
        userPrintable(System.out::println);
    }

    private static void userPrintable(Printable p){
        p.printInt(114514);
    }
}

6.6 Lambda表达式支持的方法引用

常见的引用方式

引用类方法

public interface Converter {
    // 抽象方法
    int convert (String s);
}

public class ConverterDemo {
    public static void main(String[] args) {
        // Lambda
        userConverter(s -> Integer.parseInt(s));
        // 引用类方法
        userConverter(Integer::parseInt);
        /*
         * Lambda表达式被类方法代替的时候,他的形式参数全部传递给静态方法作为参数
         */
    }

    private static void userConverter(Converter c){
        int number = c.convert("111");
        System.out.println(number);
    }

}

引用对象的实例方法

public interface Printer {
    void printUpperCase(String s);
}

public class PrintString {
    public void printUpper(String s){
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

public class PrinterDemo {
    public static void main(String[] args) {
        // Lambda
//        usePrinter((String s) -> {
//            String result = s.toUpperCase();
//            System.out.println(result);
//        });
        usePrinter(s -> System.out.println(s.toUpperCase()));

        // 引用对象的实例方法
//        PrintString ps = new PrintString();
//        usePrinter(ps::printUpper);
        usePrinter(new PrintString()::printUpper);
        /*
         * Lambda表达式被对象的实例方法替代的时候,他的形式参数全部传递给该方法作为参数
         */
    }
    private static void usePrinter(Printer p){
        p.printUpperCase("HelloWorld");
    }
}

引用类的实例方法

public interface MyString {
    String mySubString(String s,int x,int y);
}

public class MyStringDemo {
    public static void main(String[] args) {
        // Lambda
//        useMyString((String s,int x,int y)->{
//            return s.substring(x,y);
//        });
        useMyString((s, x, y) -> s.substring(x,y));

        // 引用类的实例方法
        useMyString(String::substring);

        /*
         * Lambda表达式被类的实例方法代替的时候
         * 第一个参数作为调用者
         * 后面的其他参数全部传递给该方法作为形式参数
         */
    }

    private static void useMyString(MyString my){
        String s = my.mySubString("helloworld",6,8);
        System.out.println(s);
    }
}

引用构造器

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public interface StudentBuilder {
    Student build(String name,int age);
}

public class StudentDemo {
    public static void main(String[] args) {
        // Lambda
//        useStudentBuild((String name,int age)->{
//            Student s = new Student(name,age);
//            return s;
//        });
        useStudentBuild((name, age) -> new Student(name,age));

        // 引用构造器
        useStudentBuild(Student::new);

        /*
         * Lambda表达式被构造器土袋的时候,他的形式参数全部传递给构造器作为参数
         */
    }
    private static void useStudentBuild(StudentBuilder sb){
        Student s = sb.build("林青霞",30);
        System.out.println(s.getName() +", "+s.getAge());
    }
}