通过方法引用简化Lambda表达式

文章目录

• ​​方法引用的新特性​​
• ​​方法引用的常用方式​​

• ​​通过对象名引用成员方法​​
• ​​通过类名的静态成员方法​​
• ​​构造器引用​​

方法引用的新特性

• 在上篇文章​​《深入理解Java Stream流》​​结尾处，我们通过一个具体的例子展现了Stream流的应用，其中有这样一段代码：

public static void main(String[] args) {
        // 创建两个班级的学生集合
        ...
        // 通过流的方式得出两个班级的超过90分的前三名学生
        ...
      // 合并两个流对象，并进行排序输出
        Stream.concat(stream1, stream2).sorted((s1,s2)->s1.compareTo(s2)).forEach(student -> System.out.println(student));
       
    }
   // 学生类 
   class Student implements Comparable {
    ...
    @Override
    public int compareTo(Object o) {
        if (o instanceof Student){
            return ((Student) o).score-this.score;
        }
        return -1;
    }
}      

• 在JDK8中引入了“方法引用“的新特性”，可以对Lambda表达式进行简化：

Stream.concat(stream1, stream2).sorted(Student::compareTo).limit(3).forEach(student -> System.out.println(student));      

即sorted((s1,s2)->s1.compareTo(s2))简写成了sorted(Student::compareTo)（双冒号::为引用运算符）。

方法引用的常用方式

使用方式	描述
对象名引用	object :: instanceMethodName
静态方法引用	ClassName :: staticMethodName
构造器引用	ClassName :: new

通过对象名引用成员方法

• 对象名已经存在，成员方法已经存在，则可以使用对象名来引用成员方法

/**
 * 通过对象名引用成员方法
 *
 * @author zhuhuix
 * @date 20200802
 */
public class FunctionReference01 {
    // 方法
    public static void printString(Printable printable,String s) {
        printable.print(s);
    }

    public static void main(String[] args) {
        String string = "abcdefg";
        //传统语法
//        printString(s -> {
//            UpperCase upperCase = new UpperCase();
//            upperCase.stringUpperCase(s);
//        },string);

        // 创建字母大定转换的对象
        UpperCase upperCase = new UpperCase();
        // 通过对象名引用成员方法实现字母大写转换
        printString(upperCase::stringUpperCase,string);

    }
}

// 函数式接口
@FunctionalInterface
interface Printable{
   void print(String s);
}

// 定义一个字母大写转换的类和大写转换的成员方法
class UpperCase {
    public void stringUpperCase(String s) {
        System.out.println(s.toUpperCase());
    }
}      

通过类名的静态成员方法

• 类名已经存在，静态成员方法已经存在，则可以使用类名来引用静态成员方法

/**
 * 通过类名引用静态成员方法
 *
 * @author zhuhuix
 * @date 20200802
 */
public class FunctionReference02 {
    // 方法
    public static void printString(Printable printable,String s) {
        printable.print(s);
    }

    public static void main(String[] args) {
        String string = "abcdefg";

        // 通过类名引用静态成员方法实现字母大写转换
        printString(UpperCase::stringUpperCase,string);

    }
}

// 函数式接口
@FunctionalInterface
interface Printable{
    void print(String s);
}

// 定义一个字母大写转换的类和大写转换的成员方法
class UpperCase {
    public static void stringUpperCase(String s) {
        System.out.println(s.toUpperCase());
    }
}      

构造器引用

/**
 * 构造器引用
 *
 * @author zhuhuix
 * @date 20200802
 */
public class FunctionReference03  {
    // 方法
    public static void build(PersonBuilder personBuilder,String name,int age) {
        Person person= personBuilder.builerPerson(name,age);
        System.out.println(person.toString());
    }
    public static void main(String[] args) {
       // 构造器方法引用
       build(Person::new,"Jack",16);
       build(Person::new,"Mike",17);
       build(Person::new,"Rose",18);
    }
}

// 通过姓名与年龄创建person对象
@FunctionalInterface
interface PersonBuilder{
   Person builerPerson(String name,int age);
}

class Person{
    String name;
    int age;

    Person(){}

    Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}