Java基础(二十七)------Lambda表达式优化之方法引用

方法引用

　　在使用Lambda表达式的时候，实际上我们传递的是一段解决问题的代码，给什么参数做什么操作。

Lambda冗余的场景

比如我们想要打印一个文本内容

//准备一个函数式接口
@FunctionalInterface
public interface Printable {
    //定义唯一的抽象方法
    void print(String str);
} 

准备一个测试类

public class Demo01Method { 
    //定义一个静态的方法，方法的参数传递一个函数式接口
    public static void printString(Printable p){
        p.print("Hello World");
    } 
    public static void main(String[] args) { 
        //printString(str->System.out.println(str.toUpperCase()));//Hello World--->HELLO WORLD
        //传统的Lambda表达式
        printString((String str)->{
            Demo02Method method = new Demo02Method();
            method. printUpperCaseString(str);
        }); 
        //打印流对象已经确定
        PrintStream printStream = System.out; 
        //通过对象来引用对应的成员方法
        printString( printStream::println);
        /*
            使用方法引用优化Lambda
            1. 对象已经是存在的method
            2.成员方法也是已经存在的 printUpperCaseString
            所以我们就可以使用对象名来引用成员方法
        */
        //首先必须是对象已经存在
        Demo02Method method = new Demo02Method();
        printString(method::printUpperCaseString);
    } 
}

　　在测试类中，定义一个静态方法，静态方法传递一个函数式接口Printable，函数式接口当中定义了唯一一个抽象方法print，这个print方法接收一个字符串参数。，目的就是为了打印接收的字符串参数，通常我们可以使用Lambda表达式来实现以上需求。

　　但是经过我们观察，对字符串进行控制台打印输出的操作方案，明明已经有了线程的执行方案，System.out对象中有一个方法println(String str)，所以我们可以直接通过对象名来引用该方法println来实现在控制台打印输出字符串内容

//打印流对象已经确定
PrintStream printStream = System.out; 
//通过对象来引用对应的成员方法
printString( printStream::println);

注意：其中的双冒号::写法，被称之为方法引用，两个冒号是一种新语法。

方法引用符号

双冒号::也被归置为引用运算符。

使用方法引用的使用场景

通过对象名引用成员方法

//先准备一个类，类中需要定义一个成员方法
public class Demo02Method {
    // 定义一个成员方法，传递一个字符串，把字符串转换为大写输出
    public void printUpperCaseString(String str) {
        System.out.println(str.toUpperCase());
    }
}
//准备一个函数式接口
@FunctionalInterface
public interface Printable {
    //定义唯一的抽象方法
    void print(String str);
}
public class Demo01Method {

    // 定义一个静态的方法，方法的参数传递一个函数式接口
    public static void printString(Printable p) {
        p.print("Hello World");
    } 
    public static void main(String[] args) {  
        /*
         * 使用方法引用优化Lambda 1. 对象已经是存在的method 2.成员方法也是已经存在的 printUpperCaseString
         * 所以我们就可以使用对象名来引用成员方法
         */
        // 首先必须是对象已经存在
        Demo02Method method = new Demo02Method();
        printString(method::printUpperCaseString);
    } 
}

通过类名引用静态方法

比如：java.lang.Math类中存放的都是静态方法

//首先定义一个函数式接口
@FunctionalInterface
public interface Demo01MathStaticMethod {
    //定义抽象方法
    double calculateAbs(double d);
}
//定义一个测试类
public class Demo02MethodStatic {
    // 定义一个静态方法，该方法中传递一个函数式接口
    public static double calc(double d, Demo01MathStaticMethod math) {
        return math.calculateAbs(d);
    }
    public static void main(String[] args) {
        // 传统的Lambda表达式写法
        double calc = calc(-3.14, (d) -> {
            return Math.abs(d);
        });
        System.out.println(calc);
        /*
         * 使用方法引用进行优化Lambda 
         首先类名已经确定的
         类中定义的静态方法式已经确定的 
         使用类名引用类中的静态方法
         */
        double d = calc(-3.14, Math::abs);
        System.out.println(d);// 3.14
    }
}

备注：

Lambda表达式写法：d->Math.abds(d)

方法引用写法：Math::abs

这两种写法是等价的。

通过super来引用成员方法

如果存在继承关系，当Lambda中需要使用super调用时也可以使用方法引用来优化Lambda表达式。

//定义一个父类
public class Animal {
    //定义一个成员方法 交流的方法
    public void talk() {
        System.out.println("hello 我是一只动物！");
    } 
}
//定义一个函数式接口
@FunctionalInterface
public interface Meet { 
    //定义一个抽象方法见面的方法
    void meet(); 
}
//定义一个子类
public class Cat extends Animal { 
     @Override
    public void talk() { 
        System.out.println("hello 我是一只猫！");
    } 
     //定义一个方法 方法的参数传递一个函数式接口
     public void meet(Meet m) {
         m.meet();
     } 
     //定义一个成员方法 沟通的方法
     public void commun() {
         //传统的Lambda表达式写法
        meet( ()->{
            //创建父类的对象
            //调用父类的方法
            Animal animal = new Animal();
            animal.talk();
        });
        
        //使用父类当中的方法 直接用super来调用
        meet( ()->super.talk()); 
        /*
            使用super关键字来引用成员方法
            super已经存在的
            父类当中的成员方法talk已经存在的
            可以使用super引用父类当中的成员方法 
        */
        meet(super::talk);
    }
     public static void main(String[] args) {
          new Cat().commun(); 
    }
} 

通过this来引用本类当中的成员方法

this指代当前对象，如果需要引用的方法就是本类当中的成员方法，那么可以使用this::成员方法格式来优化Lambda表达式

//定义一个学生类
public class Student {

    // 定义一个成员方法，方法的参数传递一个函数式接口Study
    public void study(Study s) {
        s.study();
    }

    // 定义一个work方法
    public void work() {
        System.out.println("我学习我快乐！");
    }

    // 定义一个成员方法 快乐的方法
    public void toHappy() { 
        // 传统的Lambda表达式
        study(() -> {
            // 创建对象
            Student student = new Student();
            student.work();
        }); 
        // 使用this关键字优化Lambda
        //Student student = new Student();
        //study(student::work);
        study(this::work);
    }

    public static void main(String[] args) {
        new Student().toHappy();
    }
}

类的构造器引用

由于构造器的名称与类名完全一样，所以构造器的类名称使用类名称::new的格式来表示

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

    public Person(String name) { 
        this.name = name;
    }

    public Person() { 
    }

    @Override
    public String toString() {
        return "Person [name=" + name + "]";
    } 
}

@FunctionalInterface
public interface PersonCreate {
    Person createPerson(String name);
}

public class TestConstructorMethod {
    public static void printPersonName(String name,PersonCreate create) {
        System.out.println(create.createPerson(name).getName());
    }
    public static void main(String[] args) {
        //使用传统的Lambda表达式
        //printPersonName("小孙", name->new Person(name));
        
        //使用构造器来优化Lambda表达式
        printPersonName("小孙", Person::new); 
        /*
            Lambda表达式
            name -> new Person(name)
            方法引用:Person::new 
        */ 
    }
}

数组的构造器引用

数组也是Object的子类对象，所以同样具有构造器，只不过语法稍微不同

//定义一个函数式接口
@FunctionalInterface
public interface BuildArrays { 
    //定义唯一的抽象方法
    public abstract int[]  buildArrays(int length);
}

//定义
public class Demo01ArraysConstructorMethod {
    
    //定义一个方法方法中传递一个函数式接口，还有传递一个数组的长度
    public static int[]  buildArrays(int length,BuildArrays buildArrays) {
        return buildArrays.buildArrays(length);
    }
    public static void main(String[] args) {
         //先用Lambda表达式来操作
        int[] arr01 = buildArrays(10, length-> new int[length]);
        System.out.println(arr01.length);//10
        
        //数组的构造器引用来优化Lambda表达式
        int[] arr02 = buildArrays(10,int[]::new);
        System.out.println(arr02.length);//10
        /*
        *Lambda表达式: length -> new int[length]
        *方法引用: int[]::new
        *这两种写法是等价的
        */
    } 
}

为什么可以使用这样的方式优化Lambda表达式？

推导与省略

如果使用Lambda，那么根据可推导就可以省略原则，无需指定参数类型，也无需指定的重写的形式—>它们都可以被推导出来，所以就可以省略掉。能够使用方法引用，同样也是可以根据上下文进行推导。

函数式接口是Lambda表达式的基础，而方法引用是Lambda的优化品。