函数式接口方法引用

Posted xinruyi

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了函数式接口方法引用相关的知识,希望对你有一定的参考价值。

概念

函数式接口在Java中是指:有且仅有一个抽象方法的接口

函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。

备注:“语法糖”是指使用更加方便,但是原理不变的代码语法。例如在遍历集合时使用的for-each语法,其实底层的实现原理仍然是迭代器,这便是“语法糖”。从应用层面来讲,Java中的Lambda可以被当做是匿名内部类的“语法糖”,但是二者在原理上是不同的。

格式

只要确保接口中有且仅有一个抽象方法即可:

修饰符 interface 接口名称 
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容

  由于接口当中抽象方法的public abstract是可以省略的,所以定义一个函数式接口很简单:

public interface MyFunctionalInterface 	
	void myMethod();

  

@FunctionalInterface注解

@Override注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解:@FunctionalInterface。该注解可用于一个接口的定义上:

@FunctionalInterface
public interface MyFunctionalInterface 
	void myMethod();

  

一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。需要注意的是,即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。

问题:为什么要使用该接口来验证一个接口是否是函数式接口呢?

如果一个接口是函数式接口,可以使用Lambda来简化代码的开发。

 

自定义函数式接口

对于刚刚定义好的MyFunctionalInterface函数式接口,典型使用场景就是作为方法的参数:

public class Demo09FunctionalInterface 	
	// 使用自定义的函数式接口作为方法参数
	private static void doSomething(MyFunctionalInterface inter) 
		inter.myMethod(); // 调用自定义的函数式接口方法
	
	
	public static void main(String[] args) 
		// 调用使用函数式接口的方法
		doSomething(() -> System.out.println("Lambda执行啦!"));
	

  

自定义函数式接口(无参无返回)

请定义一个函数式接口Eatable,内含抽象eat方法,没有参数或返回值。使用该接口作为方法的参数,并进而通过Lambda来使用它。

函数式接口的定义:

@FunctionalInterface
public interface Eatable 
	void eat();

  应用场景代码:

/*
    请定义一个函数式接口Eatable,内含抽象eat方法,
    没有参数或返回值。使用该接口作为方法的参数,并进而通过Lambda来使用它。
 */
public class Demo01 
    public static void main(String[] args) 
        //调用show方法
        show(new Eatable() 
            @Override
            public void eat() 
                System.out.println("吃饭了。。。。");
            
        );
        System.out.println("---------------------------");
        show(()->System.out.println("吃饭了。。。。"));
    
    /*
        Eatable e = new Eatable() 
            @Override
            public void eat() 
                System.out.println("吃饭了。。。。");
            
        
        ----------------------------------------------
        Eatable e = ()->System.out.println("吃饭了。。。。")
     */
    public static void show(Eatable e)
    
        e.eat();
    

  

自定义函数式接口(有参有返回)

请定义一个函数式接口Sumable,内含抽象sum方法,可以将两个int数字相加返回int结果。使用该接口作为方法的参数,并进而通过Lambda来使用它。

函数式接口的定义:

@FunctionalInterface
public interface Sumable 	
	int sum(int a, int b);

  应用场景代码:

/*
请定义一个函数式接口Sumable,内含抽象sum方法,
可以将两个int数字相加返回int结果。使用该接口作为方法的参数,并进而通过Lambda来使用它。
*/
public class Demo01 
public static void main(String[] args) 
//调用方法求两个数的和值
sumInt(3, 4, new Sumable() 
@Override
public int sum(int i, int j) 
return i+j;

);
System.out.println("-----------------------");
sumInt(3,4,(int i,int j)->i+j);//这里完成sum方法体的内容

//定义方法求两个数的和值
/*
int x=3 int y=4
Sumable lambda = new Sumable() 
@Override
public int sum(int i, int j) 
return i+j;




int x=3 int y=4
Sumable lambda = (int i,int j)->i+j
*/
public static void sumInt(int x,int y,Sumable lambda)

int sum = lambda.sum(x, y);
System.out.println("sum = " + sum);



 

  

方法引用

在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑?

冗余的Lambda场景

来看一个简单的函数式接口以应用Lambda表达式:

@FunctionalInterface
public interface Printable 
  	//打印字符串str
  	void print(String str);

  

Printable接口当中唯一的抽象方法print接收一个字符串参数,目的就是为了打印显示它。那么通过Lambda来使用它的代码很简单:

public class Demo02 
    public static void main(String[] args) 
        //调用自定义方法
        printString(new Printable() 
            @Override
            public void print(String s) 
                System.out.println("s = " + s);
            
        );
        System.out.println("==============================");
        printString(s -> System.out.println("s = " + s));

    
    //自定义方法 Printable接口作为参数
    /*
        Printable pt = new Printable() 
            @Override
            public void print(String s) 
                System.out.println("s = " + s);
            
        
     */
    public static void printString(Printable pt)
    
        //传递参数
        pt.print("Hello 上海");
    

  其中在printString方法中只管调用Printable接口的print方法,而并不管print方法的具体实现逻辑会将字符串打印到什么地方去。而main方法通过Lambda表达式指定了函数式接口Printable的具体操作方案为:拿到String(类型可推导,所以可省略)数据后,在控制台中输出它

问题分析

这段代码的问题在于,对字符串进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是System.out对象中的println(String)方法。既然Lambda希望做的事情就是调用println(String)方法,那何必自己手动调用呢?

用方法引用改进代码

能否省去Lambda的语法格式(尽管它已经相当简洁)呢?只要“引用”过去就好了:

public class Demo02PrintRef 
    private static void printString(Printable data) 
        data.print("Hello, World!");
    

    public static void main(String[] args) 
      	printString(System.out::println);   //这种写法被称为方法引用
    

  请注意其中的双冒号::写法,这种写法被称为“方法引用”,而双冒号是一种新的语法。

方法引用符

双冒号::为引用运算符,而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为Lambda的替代者。

语义分析

例如上例中,System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数,对比下面两种写法,完全等效:

  • Lambda表达式写法:s -> System.out.println(s);

  • 方法引用写法:System.out::println

第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println方法去处理。

第二种等效写法的语义是指:直接让System.out中的println方法来取代Lambda。两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。

推导与省略

如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用,也是同样可以根据上下文进行推导。

函数式接口是Lambda的基础,而方法引用是Lambda的孪生兄弟就是只要可以使用Lambda的地方都可以使用方法引用,没有使用Lambda表达式就不能使用方法引用。

下面这段代码将会调用println方法的不同重载形式,将函数式接口改为int类型的参数:

@FunctionalInterface
public interface PrintableInteger 
  	void print(int str);

  由于上下文变了之后可以自动推导出唯一对应的匹配重载,所以方法引用没有任何变化:

public class Demo03PrintOverload 
    private static void printInteger(PrintableInteger data) 
      	data.print(1024);
    

    public static void main(String[] args) 
      	printInteger(System.out::println);
    

  这次方法引用将会自动匹配到println(int)的重载形式。

通过对象名引用成员方法

这是最常见的一种用法,与上例相同。如果一个类中已经存在了一个成员方法:

在MethodRefObject类的方法printUpperCase中负责将参数str转换为大写。

public class MethodRefObject 
    public void printUpperCase(String str) 
      	System.out.println(str.toUpperCase());
    

  函数式接口仍然定义为:

@FunctionalInterface
public interface Printable 
  	void print(String str);

  

那么当需要使用这个printUpperCase成员方法来替代Printable接口的Lambda的时候,已经具有了MethodRefObject类的对象实例,则可以通过对象名引用成员方法,代码为:

注意:

Lambda表达式格式:(参数) -> 对象.方法名(参数)

方法引用格式: 对象::方法名

/*
           Lambda表达式格式:(参数) -> 对象.方法名(参数)
           方法引用格式:    对象::方法名
*/
public class MethodRefTest 
    public static void main(String[] args) 
        //创建对象
        MethodRefObject methodRefObject = new MethodRefObject();
        System.out.println("--------------匿名内部类形式---------------");
        //调用自定义方法将指定的字符串变为大写
        show("suoge", new Printable() 
            @Override
            public void print(String str) 
                //使用methodRefObject对象调用方法
                methodRefObject.printUpperCase(str);
            
        );
        System.out.println("--------------Lambda表达式形式---------------");
        //调用自定义方法将指定的字符串变为大写
        /*show("suoge",(String s2) -> 
            //使用methodRefObject对象调用方法
            methodRefObject.printUpperCase(s2);
        );*/
        //Lambda省略和推到形式
        show("suoge", s2 -> methodRefObject.printUpperCase(s2));
        System.out.println("--------------方法引用形式---------------");
        //调用自定义方法将指定的字符串变为大写
        /*
            Lambda表达式格式:(参数) -> 对象.方法名(参数)
            方法引用格式:    对象::方法名
         */
        show("suoge", methodRefObject::printUpperCase);
    

    //自定义方法
    public static void show(String s, Printable pt) 
        //调用Printable接口中的方法将s变为大写
        pt.print(s);
    

  

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:s2 -> methodRefObject.printUpperCase(s2)

  • 方法引用:methodRefObject::printUpperCase

    使用方法引用前提:使用对象引用成员方法,要求必须有该对象。

 

对象名引用成员方法

假设有一个助理类Assistant,其中含有成员方法dealFile如下:

public class Assistant   
    public void dealFile(String file) 
      	System.out.println("帮忙处理文件:" + file);
       

  请自定义一个函数式接口WorkHelper,其中的抽象方法help的预期行为与dealFile方法一致,并定义一个方法使用该函数式接口作为参数。通过方法引用的形式,将助理对象中的help方法作为Lambda的实现。

函数式接口可以定义为:

@FunctionalInterface
public interface WorkHelper  
    void help(String file);  

  通过对象名引用成员方法的使用场景代码为:

public class DemoAssistant
private static void work(WorkHelper helper)
helper.help("机密文件");

public static void main(String[] args)
Assistant assistant = new Assistant();
work(assistant::dealFile);

 

通过类名称引用静态方法

由于在java.lang.Math类中已经存在了静态方法abs,所以当我们需要通过Lambda来调用该方法时,有两种写法。首先是函数式接口:

@FunctionalInterface
public interface Calcable 
  	int calc(int num);

  第一种写法是使用Lambda表达式:

public class Demo05Lambda 
    private static void method(int num, Calcable lambda) 
      	int x = lambda.calc(num);
      	System.out.println(x);
    

    public static void main(String[] args) 
      	method(-10, n -> Math.abs(n));
    

  但是使用方法引用的更好写法是:

public class Demo06MethodRef 
    private static void method(int num, Calcable lambda) 
      	int x = lambda.calc(num);
      	System.out.println(x);
    

    public static void main(String[] args) 
      	method(-10, Math::abs);
    

  

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:`n -> Math.abs(n)`

  • 方法引用:Math::abs

 

类名称引用静态方法

假设有一个StringUtils字符串工具类,其中含有静态方法isBlank如下:

public class StringUtils 
    //定义一个成员方法判断是否为空
    public static boolean isBlank(String s)
    
        //"".equals(s.trim()去掉两端空格之后判断是否是空字符串
        return s == null || "".equals(s.trim());
    

  请自定义一个函数式接口StringChecker,其中的抽象方法checkBlank的预期行为与isBlank一致,并定义一个方法使用该函数式接口作为参数。通过方法引用的形式,将StringUtils工具类中的isBlank方法作为Lambda的实现。

函数式接口的定义可以为:

@FunctionalInterface
public interface StringChecker 
    boolean checkString(String str);    

  应用场景代码为:

public class Demo 
    public static void main(String[] args) 
        //调用自定义方法
        /*methodCheck(" haha ",(s1)->
            return StringUtils.isBlank(s1);
        );*/
        //推到省略格式
//        methodCheck("  ",s1->StringUtils.isBlank(s1));
        //方法引用格式
        methodCheck("  ",StringUtils::isBlank);
    
    //定义自定义方法
    public static void methodCheck(String s,StringChecker stringChecker)
    
        boolean boo = stringChecker.checkString(s);
        System.out.println("boo = " + boo);
    

  

通过super引用成员方法

如果存在继承关系,当Lambda中需要出现super调用时,也可以使用方法引用进行替代。首先是函数式接口:

@FunctionalInterface
public interface Greetable 
  	void greet();

  然后是父类Fu的内容:

public class Fu 
    public void say() 
      	System.out.println("Fu 。。。Hello!");
    

  最后是子类Zi的内容,其中使用了Lambda的写法:

public class Zi extends Fu 
    @Override
    public void say() 
      	method(() -> super.say());
    

    private void method(Greetable lambda) 
        lambda.greet();
        System.out.println("I‘m a zi!");
    

  但是如果使用方法引用来调用父类中的say方法会更好,例如另一个子类Zi2

public class Zi2 extends Fu 
    @Override
    public void say() 
      	method(super::say);
    

    private void method(Greetable lambda) 
        lambda.greet();
        System.out.println("I‘m a zi2!");
    

  

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:() -> super.say()

  • 方法引用:`super::say`

 

通过this引用成员方法

this代表当前对象,如果需要引用的方法就是当前类中的成员方法,那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口:

@FunctionalInterface
public interface Richable 
   	void buy();

  下面是一个丈夫Husband类:

public class Husband 
    public void beHappy()
        marry(()-> System.out.println("买套房子")); 
    

    private void marry(Richable richable) 
        richable.buy();
    

  开心方法beHappy调用了结婚方法marry,后者的参数为函数式接口Richable,所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了,则可以对Husband丈夫类进行修改:

public class Husband_1 
    private void buyHouse()
        System.out.println("买套房子");
    

   public void beHappy()
        marry(()->this.buyHouse());
   

    private void marry(Richable richable) 
        richable.buy();
    

  如果希望取消掉Lambda表达式,用方法引用进行替换,则更好的写法为:

public class Husband_1 
    private void buyHouse()
        System.out.println("买套房子");
    

   public void beHappy()
        marry(this::buyHouse);
   

    private void marry(Richable richable) 
        richable.buy();
    

  

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:() -> this.buyHouse()

  • 方法引用:this::buyHouse

 

类的构造方法引用

由于构造方法的名称与类名完全一样,并不固定。所以构造方法引用使用类名称::new的格式表示。首先是一个简单的Person类:

 

public class Person 
  //成员变量  
  private String name;
 //构造函数
    public Person(String name) 
      	this.name = name;
    

    public String getName() 
      	return name;
    

  然后是用来创建Person对象的函数式接口:

public interface PersonBuilder 
    Person buildPerson(String name);

  要使用这个函数式接口,可以通过Lambda表达式:

public class Demo09Lambda 
    public static void main(String[] args) 
      printName("赵丽颖",(String name)->return new Person(name););

    

    private static void printName(String name,PersonBuilder builder) 
        Person p = builder.buildPerson(name);   //这一行代码中的builder哪里来的?
        System.out.println(p.getName());
    

  但是通过构造方法引用,有更好的写法:

public class Demo10ConstructorRef 
    public static void printName(String name, PersonBuilder builder) 
        Person p=builder.buildPerson(name);
      	System.out.println(p.getName());
    

    public static void main(String[] args) 
      	printName("赵丽颖", Person::new);
    

  

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:name -> new Person(name)

  • 方法引用:Person::new

 

数组的构造器引用

数组也是Object的子类对象,所以同样具有构造器,只是语法稍有不同。如果对应到Lambda的使用场景中时,需要一个函数式接口:

@FunctionalInterface
public interface ArrayBuilder 
  	int[] buildArray(int length);//length表示数组的长度

  在应用该接口的时候,可以通过Lambda表达式:

public class Demo11ArrayInitRef    
    private static int[] initArray(int length, ArrayBuilder builder) 
      	return builder.buildArray(length);
    

    public static void main(String[] args) 
        //int[] array = initArray(10, (length) ->return new int[length];);
      	int[] array = initArray(10, length -> new int[length]);
    

  但是更好的写法是使用数组的构造器引用:

public class Demo12ArrayInitRef
private static int[] initArray(int length, ArrayBuilder builder)
return builder.buildArray(length);

public static void main(String[] args)
int[] array = initArray(10, int[]::new); //方法引用

 

在这个例子中,下面两种写法是等效的:

  • Lambda表达式:length -> new int[length]

  • 方法引用:`int[]::new`

 

以上是关于函数式接口方法引用的主要内容,如果未能解决你的问题,请参考以下文章

12函数式接口方法引用

函数式接口方法引用

函数式接口与方法引用

Java8新特性:函数式接口,方法与构造器引用

Java8学习笔记-函数式接口与方法引用

Java8 lambda表达式函数式接口方法引用