Lambda表达式(二)

方法的引用

直接访问类或者实例的已经存在的方法或者构造方法,方法的引用提供了一种引用提供了一种引用而不执行方法的方式,如果抽象方法的实现恰巧可以使用调用另外一个方法来实现,就有可能可以使用方法引用

方法引用分类

类型 语法 对应的lambda表达式 说明
静态方法引用 类名::staticMethod (args)->类名.staticMethod 如果函数式接口恰巧可以通过调用一个静态方法来实现,就可以使用调动静态方法来引用
实例方法引用 inst::instMethod (args)-> inst.instMethod 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现,就可以使用调动实例方法来引用
对象方法引用 类名::instMethod (inst,args)->inst.instMethod 抽象方法的第一个参数类型刚好是实例方法的类型,抽象方法剩余的参数恰巧可以当作实例方法的参数。如果函数式接口能有上面说的实例方法调用的话,那么就可以使用对象方法引用
构造方法引用 类名::new (args)->new 类名(args) 如果函数式接口恰巧可以通过调用一个类的构造方法来实现,就可以使用调动实例方法来引用

静态方法引用

package lambda1;

import java.util.function.Supplier;

/**
 * 静态方法引用
 * 如果函数式接口恰巧可以通过调用一个静态方法来实现,就可以使用调动静态方法来引用
 */
public class StaticMethod {
    /**
     * 静态方法
     * @return
     */
    private static String insert() {
        return "hello lambda";
    }

    public static void main(String[] args) {
        // 该函数式接口表示输出。
        // lambda表达式
        Supplier<String> s = () -> {
            return StaticMethod.insert();
        };
        System.out.println("lambda表达式:" + s.get());
        // 方法的引用
        Supplier<String> s1 = StaticMethod::insert;
        System.out.println("方法的引用:" + s1.get());
        
    }
}

实例方法引用

package lambda1;

import java.util.function.Supplier;
/**
 * 实例方法引用
 * 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现,就可以使用调动实例方法来引用
 */
public class InstanceMethod {
    /**
     * 实例方法
     * @return
     */
    private  String insert() {
        return "hello lambda";
    }
    
public static void main(String[] args) {
    Supplier<String> s = () -> {
        return new InstanceMethod().insert();
    };
    System.out.println("lambda表达式:" + s.get());
    // 方法的引用
    Supplier<String> s1 = new InstanceMethod()::insert;
    System.out.println("方法的引用:" + s1.get());
 
}
}

对象方法引用

package lambda1;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 
 * 对象方法引用(该函数式接口的抽象方法必须有输入参数)
 * 抽象方法的第一个参数类型刚好是实例方法的类型,抽象方法剩余的参数恰巧可以当作实例方法的参数。如果函数式接口能有上面说的实例方法调用的话,那么就可以使用对象方法引用
 */
public class ObjectMethod {

    
    public static void main(String[] args) {
        
        
        Supplier<String> s=()->null;//此函数式接口不能用对象方法引用
        
        /**
         * Consumer
         */
        Consumer<Too> c1=(Too too)->new Too().show();
        Consumer<Too> c2=Too::show;
        Consumer<Too> c3=(Too too)->new Too2().show();
        //Consumer<Too> c4=Too2::show;//这个就不行,因为抽象方法的第一个参数类型(Too)不是实例方法的类型
        c1.accept(new Too());
        c2.accept(new Too());
        c3.accept(new Too());
        
        /**
         * Function
         */
        Function<Too2, String> f1=(too2)->new Too2().show1();;
        Function<Too2, String> f2=Too2::show1;
        System.out.println(f1.apply(new Too2()));
        System.out.println(f2.apply(new Too2()));
        
        /**
         * BiConsumer
         */
        BiConsumer<Too, String> bc1=(too,str)->new Too().show1(str);
        BiConsumer<Too, String> bc2=Too::show1;
        bc1.accept(new Too(), "1");
        bc2.accept(new Too(), "2");
        
}
}
class Too{
    public void show() {
        System.out.println("Too show invoke");
    }
    public void show1(String str) {
        System.out.println("Too show invoke:"+str);
    }
    
}
class Too2{
    public void show() {
        System.out.println("Too2 show invoke");
        
    }
    public String show1() {
        return "Too2 show1 invoke";
    }
}

构造方法引用

package lambda1;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 构造方法方法引用
 * 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现,就可以使用调动实例方法来引用
 */
public class StructureMethod {
    public static void main(String[] args) {
        // 调用无参构造方法
        Supplier<Man> s1 = () -> new Man();
        Supplier<Man> s2 = Man::new;
        s1.get();
        s2.get();

        // 调用无参构造方法;可以通过此函数式接口代替 Object obj=new Object(),华丽转身
        Supplier<List<String>> s3 = ArrayList::new;
        Supplier<Set<Integer>> s4 = HashSet::new;
        Supplier<String> s5 = String::new;
        Supplier<Thread> s6 = Thread::new;
        List<String> city=s3.get();//不可变对象一个原理,动动脑子
        city.add("福州");
        city.add("北京");
        city.add("上海");
        
        for (int i = 0; i <city.size(); i++) {
            
            System.out.println("no."+(i+1)+"  城市:"+ city.get(i)+"");
        }
        
        // 一个的有参构造方法
        Consumer<String> c1 = str -> new Man(str);
        Consumer<String> c2 = Man::new;

        c1.accept("c1的实参");
        c2.accept("c2的实参");

        // 相应的两个参数的构造方法可以使用
        BiConsumer<String, Integer> b1 = (str, num) -> new Man(str, num);
        BiConsumer<String, Integer> b2 = Man::new;
        b1.accept("b1的字符串", 5);
        b2.accept("b2的字符串", 3);

        Function<String, Integer> f1 = (str) -> Integer.valueOf(str);
        Function<String, Integer> f2 = Integer::valueOf;
        f1.apply("122");
        f2.apply("133");

        // 因为man中有无参构造方法所以f3可以,
        // 因为f4中有只有一个String类型的有参构造方法所以可以,
        // f5是调用了只有一个String类型的构造方法,因为Function有一个输入参数,所以会匹配
        Function<String, Man> f3 = (str) -> new Man();
        Function<String, Man> f4 = (str) -> new Man(str);
        Function<String, Man> f5 = Man::new;
        f3.apply("111");
        f4.apply("111");
        f5.apply("111");

    }

}
class Man{
    public Man() {
        System.out.println("调用Man的无参构造方法!");
    }
    
    public Man(String str) {
        System.out.println("调用Man的参数为"+str+"的有参构造方法!");
    }
    
    public Man(String str,int num) {
        System.out.println("调用Man的参数为字符串"+str+"和数值"+num+"的有参构造方法!");
    }
}

推荐阅读更多精彩内容