Java笔记之 Lambda表达式、方法引用

Lambda表达式

函数式编程思想概述：

体验Lambda表达式

需求：启动一个线程，在控制台上输出一句话：多线程程序启动了

方式一：

1.定义一个类MyRunnable接口，重写run()方法

2.创建MyRunnable类的对象

3.创建Thread类的对象，把Runnable的对象作为构造参数传递

4.启动线程

 方式二：

匿名内部类的方式改进

方式三：

Lambda表达式的方式改进

MyRunnable.java
package com.Lambda;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}

//LambdaDemo.java
package com.Lambda;

public class LambdaDemo {
    //需求：启动一个线程，在控制台上输出一句话：多线程程序启动了

    public static void main(String[] args) {

        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

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

        //Lambda表达式的方式改进
        new Thread(()->{
            System.out.println("多线程程序启动了");
        }).start();
    }
}

方法引用

方法引用符

 

//Printable.java
package com.Lambda;

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

//PrintableDemo.java
package com.Lambda;

public class PrintableDemo {
    public static void main(String[] args) {

        //在主方法中调用usePrintable方法
        usePrintable(i->System.out.println(i));

        //方法引用
        usePrintable(System.out::println);
    }

    private static void usePrintable(Printable p) {
        p.printInt(666);
    }
}

Lambda表达式支持的方法引用

常见的引用方式：

1.引用类方法

2.引用对象的实例方法

3.引用类的实例方法

4.引用构造器

引用类的方法

其实就是引用类的静态方法

格式： 类名::静态方法

范例：Integer::parseInt

       Integer类的方法：public static int parseInt(String s)将此String转换为int类型数据

练习：

定义一个接口（Converter）,里面定义一个抽象方法

int convert(String s);

定义一个测试类（ConvertDemo),在测试类中提供两个方法

       一个方法是：useConvert（Convert c）

       一个方法是主方法，在主方法中调用useConvert方法

//Convert.java
package com.Lambda;

public interface Convert {
    int convert(String s);
}

//ConvertDemo.java
package com.Lambda;

import java.io.InputStream;

public class ConvertDemo {
    public static void main(String[] args) {
        useConvert((String s)->{
            return Integer.parseInt(s);
        });
        //Lambda表达式被类方法替代的时候，他的形式参数全部传递给静态方法做参数
        useConvert(Integer::parseInt);
    }

    private static void useConvert(Convert c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

引用对象的实例方法

就是引用对象中的成员方法

格式：对象::成员方法

范例："HelloWorld"::toUpperCase

       String 类中的方法：public String toUpperCase()将此String所有字符转换为大写

//Printer.java
package com.Lambda;

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


//PrintString.java
package com.Lambda;

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


//PrintDemo.java
package com.Lambda;

public class PrintDemo {
    public static void main(String[] args) {
        usePrinter((String s)-> {
            System.out.println(s.toUpperCase());
        });
        usePrinter(s-> System.out.println(s.toLowerCase()));
        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
    }

    private static void usePrinter(Printer p) {
        p.printUpperCase("Helloworld");
    }
}

引用类的实例方法

就是引用类的成员方法

格式：类名::成员方法

范例：String::subdtring

        String类中的方法：public String substring(int beginIndex,int endIndex)

        从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex。

练习：略

引用构造器

就是引用构造方法：

格式：类名::new 

范例： Student::new

//Student.java
package com.Lambda;

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 int getAge() {
        return age;
    }

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

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

//StudentBuilder.java
package com.Lambda;

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

//StudentDemo.java
package com.Lambda;

public class StudentDemo {
    public static void main(String[] args) {
        useStudentBuilder((String name,int age)->{
            return new Student(name,age);
        });
        useStudentBuilder((name,age)->new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
    }

    private static void useStudentBuilder(StudentBuilder sb ){
        Student s = new Student("zayn",23);
        System.out.println(s.getName()+":"+s.getAge());
    }
}