3. lambda 方法引用

lambda 方法引用分为4类，方法引用也受到访问控制权限的限制，可以通过在引用位置是否能够调用被引用方法来判断。具体分类信息如下：

类型	使用方式
静态方法	ContainingClass::staticMethodName
指定实例的方法	containingObject::instanceMethodName
特定类实例的任意方法	ContainingType::methodName
构造方法	ClassName::new

• • 引用静态方法 ContainingClass::staticMethodName 例子: String::valueOf，对应的Lambda：(s) -> String.valueOf(s) 比较容易理解，和静态方法调用相比，只是把.换为::
  • 引用特定对象的实例方法 containingObject::instanceMethodName 例子: x::toString，对应的Lambda：() -> this.toString() 与引用静态方法相比，都换为实例的而已
  • 引用特定类型的任意对象的实例方法 ContainingType::methodName 例子: String::toString，对应的Lambda：(s) -> s.toString() 太难以理解了。难以理解的东西，也难以维护。建议还是不要用该种方法引用。 实例方法要通过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。
  • 引用构造函数 ClassName::new 例子: String::new，对应的Lambda：() -> new String() 构造函数本质上是静态方法，只是方法名字比较特殊。

1.引用静态方法

map 遍历

public static void domel4(){

    Map<String,String> mp=new HashMap<>();
    mp.put("1","1");
    mp.put("2","1");
    mp.put("3","1");

   //引用静态方法
    mp.forEach(LambdaTest::domel5);
    //静态方法的同效写法
    mp.forEach((k,v)-> domel5(k,v));
    //匿名函数写法
    mp.forEach((k,v)-> {
        System.out.println("key:"+k+";v:"+v);
    });
}
public static void domel5(String k,String v){
    System.out.println("key:"+k+";v:"+v);
}

排序案例

//创建实体
public class Person {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    
    //实例对象内部排序实现
    public int compare(Person p1, Person p2){
        return p1.getAge().compareTo(p2.getAge());
    }
    
     public int compareTo(Person p){
     return this.getName().compareTo(p.getName());
     }

}


// 实例工厂
public class PersonFactory {
    private Supplier<Person> supplier;
    public PersonFactory(Supplier<Person> supplier){
        this.supplier=supplier;
    }

    public Person getSupplierPerson() {
        return supplier.get();
    }
}


// 排序案例
public class LambdaTestYY {

    public static void main(String[] arg){
        domel1();
    }

    static void domel1(){
        // 引用构造函数
        PersonFactory personFactory=new PersonFactory(Person::new);
        List<Person> personList = new ArrayList<>();
        Person p1 = personFactory.getSupplierPerson();
        p1.setName("Kobe");
        p1.setAge(18);
        personList.add(p1);

        Person p2 = personFactory.getSupplierPerson();
        p2.setName("James");
        p2.setAge(19);
        personList.add(p2);

        Person p3 = personFactory.getSupplierPerson();
        p3.setName("Paul");
        p3.setAge(15);
        personList.add(p3);

        Person[] persons1 = personList.toArray(new Person[personList.size()]);
        System.out.println("排序前");
        printArray(persons1);
        Arrays.sort(persons1,LambdaTestYY::myCompare);
        System.out.println("排序后");
        printArray(persons1);
    }

    private static void printArray(Person[] persons){
        for (Person person : persons) {
            System.out.println(String.format("name:%s;age:%d",person.getName(),person.getAge()));
        }
    }

    static int myCompare(Person p1, Person p2){
       return p1.getAge().compareTo(p2.getAge());
    }


}

2.引用特定对象的实例方法

Person[] persons2 = personList.toArray(new Person[personList.size()]);
System.out.println("排序前");
printArray(persons2);
//引用特定对象的实例方法
Arrays.sort(persons2,p1::compare);
System.out.println("排序后");
printArray(persons2);

3.引用特定类型的任意对象的实例方法

System.out.println("**********************");
Person[] persons3 = personList.toArray(new Person[personList.size()]);
System.out.println("排序前");
printArray(persons3);
//引用特定类型的任意对象的实例方法
Arrays.sort(persons3,Person::compareTo);
System.out.println("排序后");
printArray(persons3);

4.引用构造方法

// 或者Supplier<Person> supplier=Person::new;
PersonFactory personFactory=new PersonFactory(Person::new);

List<Person> personList = new ArrayList<>();
Person p1 = personFactory.getSupplierPerson();
p1.setName("Kobe");
p1.setAge(18);
personList.add(p1);