Java——(lambda表达式)方法引用

方法的引用

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

方法引用的分类

类型	语法	对应的lambda表达式
静态方法引用	类名::staticMethod	(args)->类名.staticMethod(args)
实例方法引用	inst::instMethod	(args)->inst.Method(args)
对象方法引用	类名::instMethod	(inst,args)->类名.instMethod(args)
构造方法引用	类名::new	(args)->new 类名(args)

我们来尝试下函数式接口和静态方法引用结合的lambda表达式

public class TestFunction {
    static int StringLength(String str){
        return str.length();
    }
}

public class Test {
    public static void main(String[] args) {
        Function<String ,Integer> f1 = (a)->TestFunction.StringLength(a);
        System.out.println(f1.apply("xixixdd"));
        Function<String,Integer> f2 = TestFunction::StringLength;
        System.out.println(f2.apply("xixixdd"));
    }
}

上面f1和f2最终效果其实是一样的,但编写简便程度f2会比f1简单些

• 静态方法引用: 如果函数式接口的实现恰好可以通过调用一个静态方法来实现,那么就可以使用静态方法引用
• 实例方法引用:如果函数式接口实现恰好可以通过调用一个实例的实例方法来实现,那么就可以使用实例方法引用
• 对象方法引用:抽象方法的第一个参数类型刚好是实例方法的类型,抽象方法剩余的参数恰好可以当作实例方法的参数.如果函数式接口的实现能由上面说的实例方法调用来实现的话,那么就可以使用对象方法引用
• 构造方法引用:如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现,那么就可以使用构造方法引用

实例方法的引用

public class TestFunction {
	String insString(String str){
        return  str.toUpperCase();
    }
}

public class Test2 {
    public static void main(String[] args) {
    	Function<String,String> f0 = (a)->new TestFunction().insString(a);
        System.out.println(fi.apply("zxcaddddaT"));
        
        Function<String,String> fi = new TestFunction()::insString;
        System.out.println(fi.apply("zxcaddddaT"));
    }
}

public class Test2 {
    public static void main(String[] args) {
    	TestFunction testtt = new TestFunction();
        Function<String,String> fi = testtt::insString;
        System.out.println(fi.apply("zxcaddddaT"));
    }
}

对象方法的引用

public class Test2 {
    public static void main(String[] args) {
 		BiFunction<TestFunction,String,String>   fi = (TestFunction test,String a)->new TestFunction().insString(a); 
		System.out.println(fi.apply(new TestFunction(),"hahaha"));                                                   
                                                                                                             
		BiFunction<TestFunction,String,String>   f2 = TestFunction::insString;                                       
		System.out.println(f2.apply(new TestFunction(),"dadaddd"));                                                     	
    }
}

对象方法的引用主要是,必须要传一个跟对象类型一致的参数,后面才可使用 对象名::成员方法
不过这种引用方法一般用得比较少,这里用作理解即可

构造方法引用

public class TestFunction2 {
    public TestFunction2(){
        System.out.println("no args");
    }
    public TestFunction2(int a){
        System.out.println("args is Integer"+a);
    }
    public TestFunction2(String str){
        System.out.println("args is String"+str);
    }

}

public class Test3 {
    public static void main(String[] args) {
        Runnable rn = ()->new TestFunction2();
        rn.run();
        Runnable rn2 = TestFunction2::new;
        rn2.run();
        Consumer<Integer> co1 =(e)->new TestFunction2(e);
        co1.accept(123);
        Consumer<Integer> co2 = TestFunction2::new;
        co2.accept(114);
        Consumer<String> co3 =(e)->new TestFunction2(e);
        co3.accept("adasad");
        Consumer<String> co4 = TestFunction2::new;
        co4.accept("kjkjkjnmn");
    }
}