java-方法引用

/**
 * 方法引用格式：
 *  双冒号::  引用运算符，它所在的表达式被称为方法引用。如果Lambda表达式
 *  的函数方案已经存在于某个地方的实现中，
 *  ===》那么可以通过双冒号来引用改方法作为Lambda表达式的代替者
 */

例子：

public class Demo01Print {
    private static void printString(Printable p){
      p.print("quan");
    }

    public static void main(String[] args) {
        printString((s)->{
            System.out.println(s);
        });
        /**
         * 表达式的目的：打印参数传递的字符串
         * 把参数s,传递给System.out对象，调用out对象的pringln方法进行输出
         *          System.out对象已经存在
         *          pringln方法已经存在
         *          =====》可以使用方法引用来优化表达式
         *          就是使用system.out方法直接引用（调用）pringln方法。
         */
        printString(System.out::println);
    }

结果输出：

quan
quan

通过对象名引用成员方法

最常见的一种用法，其实就是上面的做法：

/**
 * 通过对象名引用成员方法
 * 前提：
 *      对象名存在，方法名存在
 *  就可以使用对象名来引用成员方法
 */

例子：

1先创建对象类

public class MethodRefObject {
    public void pringUpperCaseString(String s){
        System.out.println(s.toUpperCase());
    }
}

2创建函数式接口

@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    void print(String s);
}

3测试方法：

public class Demo01MethodRefObject {
    private static void pringString(Printable p){
        p.print("quan");
    }

    public static void main(String[] args) {

        pringString((s)->{
            //创建MethodRefObject对象
            MethodRefObject obj = new MethodRefObject();
            //调用对象里面的成员方法pringUpperCaseString把字符
            //串按照大写输出
            obj.pringUpperCaseString(s);
        });

        //使用方法引用优化，先创建MethodObject对象
        MethodRefObject obj = new MethodRefObject();
        pringString(obj::pringUpperCaseString);
    }
}
/**
 * re:
 * QUAN
 * QUAN
 **/

通过类名称引用静态方法

/**
 * 通过类名引用静态承焰方法
 * 前提：
 *      类已经存在，静态成员方法存在
 *
 */

例子：

public class Demo01StaticMethodReference {
    //定义一个方法，方法的参数传递要计算的整数和函数式接口Calcable
    private static int method(int num,Calcable c){
       return c.calAbs(num);
    }

    public static void main(String[] args) {
        //调用method方法
        int i =method(-10,(n)->{
            //计算绝对值,使用的是Math类当中的静态方法abs
            return Math.abs(n);
        });
        System.out.println(i);

        /**
         *使用方法引用优化Lambda表达式
         *  Math类存在
         *  abs计算绝对值静态方法存在
         */
        int i1 = method(-10,Math::abs);
        System.out.println(i1);
    }

}

通过supper引用父类的成员方法

存在子父关系

创建一个父类

//父类
public class Human {
    public void sayHello(){
        System.out.println("say hello");
    }
}

创建一个函数式接口

@FunctionalInterface
public interface Greetable {
    void greet();
}

创建一个子类:

public class Man extends Human{
    @Override
    public void sayHello() {
        System.out.println("hello,I'm Man");
    }

    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        method(()->{
            //创建父类
            Human human =  new Human();
            human.sayHello();
        });
        /**
         * 存在子夫类关系，存在super关键字，代表父类
         * 直接通过super调用父类成员方法
         */
        method(()->{
            super.sayHello();
        });
        /**
         * 通过super引用类的成员方法
         */
        method(super::sayHello);

    }

    public static void main(String[] args) {
        new Man().show();
        new Man().sayHello();
    }
}

结果：

say hello
say hello
say hello
hello,I'm Man

通过this引用成员方法

this代表当前对象，如果需要引用的方法就是当前类中的成员方法。

可以使用this::成员方法来使用方法引用

定义一个接口

@FunctionalInterface
public interface Richable {
    void buy();
}

/**
 * 通过this引用奔雷成员方法
 */
public class Husbard {
    public void buyHome(){
        System.out.println("买房子");
    }

    public void marry(Richable r){
        r.buy();
    }

    public void soHappy(){
        marry(()->{
            //使用this成员方法
            this.buyHome();
        });
        /**
         * 使用方法引用优化Lambda表达式
         */
        marry(this::buyHome);
    }

    public static void main(String[] args) {
        new Husbard().soHappy();
    }

}

类的构造器引用

构造器和类名完全一致，所以使用方式为：类名称::new的格式表示。

定义一个函数式接口

/**
 * 定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    //根据姓名创建Person对象返回
    Person builderPerson(String name);
}

一个要被创建的类Person

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

/**
 * 类的构造器引用
 */
public class Demo {
    public static void printName(String name,PersonBuilder builder){
        Person person = builder.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        printName("quan",(name)->{
            return  new Person(name);
        });
        /**
         * 使用方法引用优化lambda表达
         */
        printName("quan2",Person::new);
    }
}
//re:quan
//   quan2

数组构造器的引用

数组是Object的子类对象，同样具有构造器，但是语法不太一样

/**
 * 数组的构造器引用
 * 数组::new
 * 例子：int[]::new
 */

创建一个接口

//创建数组的函数式接口
@FunctionalInterface
public interface ArrayBuilder {
    //返回一个给定长度的int类型数组
    int[] builderArray(int length);
}

public class Demo1 {
    public static int[] createArray(int length,ArrayBuilder ab){
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        //调用create方法，传递数组长度和表达式
        int[] lenint = createArray(12,(len)->{
            return new int[len];
        });

        System.out.println(lenint.length);

        //优化,int[]就是数组的构造函数名字
        int[] lenint2 = createArray(15,int[]::new);
        System.out.println(lenint2.length);
    }
}
//re:12
//   15