方法的引用

直接訪問類或者實(shí)例的已經(jīng)存在的方法或者構(gòu)造方法，方法的引用提供了一種引用提供了一種引用而不執(zhí)行方法的方式，如果抽象方法的實(shí)現(xiàn)恰巧可以使用調(diào)用另外一個(gè)方法來實(shí)現(xiàn)，就有可能可以使用方法引用

方法引用分類

靜態(tài)方法引用

package lambda1;

import java.util.function.Supplier;

/**
 * 靜態(tài)方法引用
 * 如果函數(shù)式接口恰巧可以通過調(diào)用一個(gè)靜態(tài)方法來實(shí)現(xiàn)，就可以使用調(diào)動(dòng)靜態(tài)方法來引用
 */
public class StaticMethod {
    /**
     * 靜態(tài)方法
     * @return
     */
    private static String insert() {
        return "hello lambda";
    }

    public static void main(String[] args) {
        // 該函數(shù)式接口表示輸出。
        // lambda表達(dá)式
        Supplier<String> s = () -> {
            return StaticMethod.insert();
        };
        System.out.println("lambda表達(dá)式:" + s.get());
        // 方法的引用
        Supplier<String> s1 = StaticMethod::insert;
        System.out.println("方法的引用:" + s1.get());
        
    }
}

實(shí)例方法引用

package lambda1;

import java.util.function.Supplier;
/**
 * 實(shí)例方法引用
 * 如果函數(shù)式接口恰巧可以通過調(diào)用一個(gè)實(shí)例的實(shí)例方法來實(shí)現(xiàn)，就可以使用調(diào)動(dòng)實(shí)例方法來引用
 */
public class InstanceMethod {
    /**
     * 實(shí)例方法
     * @return
     */
    private  String insert() {
        return "hello lambda";
    }
    
public static void main(String[] args) {
    Supplier<String> s = () -> {
        return new InstanceMethod().insert();
    };
    System.out.println("lambda表達(dá)式:" + s.get());
    // 方法的引用
    Supplier<String> s1 = new InstanceMethod()::insert;
    System.out.println("方法的引用:" + s1.get());
 
}
}

對(duì)象方法引用

package lambda1;

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

/**
 * 
 * 對(duì)象方法引用（該函數(shù)式接口的抽象方法必須有輸入?yún)?shù)）
 * 抽象方法的第一個(gè)參數(shù)類型剛好是實(shí)例方法的類型，抽象方法剩余的參數(shù)恰巧可以當(dāng)作實(shí)例方法的參數(shù)。如果函數(shù)式接口能有上面說的實(shí)例方法調(diào)用的話，那么就可以使用對(duì)象方法引用
 */
public class ObjectMethod {

    
    public static void main(String[] args) {
        
        
        Supplier<String> s=()->null;//此函數(shù)式接口不能用對(duì)象方法引用
        
        /**
         * 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;//這個(gè)就不行，因?yàn)槌橄蠓椒ǖ牡谝粋€(gè)參數(shù)類型(Too)不是實(shí)例方法的類型
        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";
    }
}

構(gòu)造方法引用

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;

/**
 * 構(gòu)造方法方法引用
 * 如果函數(shù)式接口恰巧可以通過調(diào)用一個(gè)實(shí)例的實(shí)例方法來實(shí)現(xiàn)，就可以使用調(diào)動(dòng)實(shí)例方法來引用
 */
public class StructureMethod {
    public static void main(String[] args) {
        // 調(diào)用無參構(gòu)造方法
        Supplier<Man> s1 = () -> new Man();
        Supplier<Man> s2 = Man::new;
        s1.get();
        s2.get();

        // 調(diào)用無參構(gòu)造方法；可以通過此函數(shù)式接口代替 Object obj=new Object(),華麗轉(zhuǎn)身
        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();//不可變對(duì)象一個(gè)原理，動(dòng)動(dòng)腦子
        city.add("福州");
        city.add("北京");
        city.add("上海");
        
        for (int i = 0; i <city.size(); i++) {
            
            System.out.println("no."+(i+1)+"  城市："+ city.get(i)+"");
        }
        
        // 一個(gè)的有參構(gòu)造方法
        Consumer<String> c1 = str -> new Man(str);
        Consumer<String> c2 = Man::new;

        c1.accept("c1的實(shí)參");
        c2.accept("c2的實(shí)參");

        // 相應(yīng)的兩個(gè)參數(shù)的構(gòu)造方法可以使用
        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");

        // 因?yàn)閙an中有無參構(gòu)造方法所以f3可以，
        // 因?yàn)閒4中有只有一個(gè)String類型的有參構(gòu)造方法所以可以，
        // f5是調(diào)用了只有一個(gè)String類型的構(gòu)造方法，因?yàn)镕unction有一個(gè)輸入?yún)?shù)，所以會(huì)匹配
        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("調(diào)用Man的無參構(gòu)造方法！");
    }
    
    public Man(String str) {
        System.out.println("調(diào)用Man的參數(shù)為"+str+"的有參構(gòu)造方法！");
    }
    
    public Man(String str,int num) {
        System.out.println("調(diào)用Man的參數(shù)為字符串"+str+"和數(shù)值"+num+"的有參構(gòu)造方法！");
    }
}