Java 中Lambada表达式中双冒号 ::使用总结

一、前言

双冒号运算操作符是类方法的句柄，lambda表达式的一种简写

表达式：
person -> person.getName();
可以替换成：
Person::getName
 
表达式：
() -> new HashMap<>();
可以替换成：
HashMap::new

二、定义

双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种执行方法的方法,为此，方法引用需要由兼容的函数式接口组成的目标类型上下文。使用lambda表达式会创建匿名函数， 但有时候需要使用一个lambda表达式只调用一个已经存在的方法（不做其它）， 所以这才有了方法引用！

其实，JVM 本身并不支持指向方法引用，过去不支持，现在也不支持。Java 8
对方法引用的支持只是编译器层面的支持，虚拟机执行引擎并不了解方法引用。编译器遇到方法引用的时候，会像上面那样自动推断出开发者的意图，将方法引用还原成接口实现对象，或者更形象地说，就是把方法引用设法包装成一个接口实现对象，这样虚拟机就可以无差别地执行字节码文件而不需要管什么是方法引用了。

需要注意的是，方法引用是用来简化接口实现代码的，并且凡是能够用方法引用来简化的接口，都有这样的特征：有且只有一个待实现的方法。这种接口在
Java 中有个专门的名称： 函数式接口。当试图用方法引用替代一个非函数式接口时，会有这样的错误提示： xxx is not a functional interface。

三、使用场景

类型	引用方法	案例
引用静态方法	类名::静态方法名	Integer::parseInt
引用特定对象实例方法	对象::实例方法名	System.out::println
引用特定类型的任意对象的实例方法	特定类型::实例方法名	String::compareToIgnoreCase
引用超类（父类）实例方法	super::方法名
引用类构造方法	类名::new	ArrayList::new
引用数组构造方法	数组类型[]::new	String[]::new

案例：

1、引用静态方法

import org.junit.Test;
import java.util.Arrays;
import java.util.List;
 
public class Colon{
@Test
    public void test(){
        List<String> list = Arrays.asList("a", "b","c");
        //静态方法引用ClassName::methodName
        list.forEach(Colon:: print);
        //上一行等价于
        //1ist.forEach((x)->Colon.print(x));
    }
    //静态方法
    public static void print(String s){
        system.out.println(s);
    }
}

2、引用特定对象实例方法

import org.junit.Test;
import java.util.Arrays;
import java.util.List;
public class Colon{
    @Test
    public void test(){
        List<string> list = Arrays.asList("a", "b","c");//r实例方法引用instanceRef: :methodName
        list.forEach(new Colon()::print);
        //上一行等价于
        //iist.forEach((x)->new Colon().print(x));
    }
    //实例方法
    public void print(String s){
        System.out.println(s);
    }
}

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

import org.junit.Test;
import java.util.Arrays;
 
public class Colon{
    @Test
    public void test(){
        String[] arr = { "Barbara","James","Mary", "John",
                "Patricia","Robert","Michae1", "Linda”};
        //引用String类型的任意对象的compareToIgnoreCase方法实现忽略大小写排序
        Arrays.sort(arr, String::compareToIgnoreCase);
        //上一行等价于
        //Arrays.sort(arr, (a,b)->a.compareToIgnoreCase(b));
        //输出
        for(String s:arr){
            System.out.println(s);
        }
}

4、引用超类（父类）实例方法

import org.junit.Test;
import java.util.Arrays;
import java.util.List;
 
public class Colon extends BaseColon{
    @Test
    public void test(){
        List<string> list = Arrays.asList("a", "b","c");
        //实例方法引用instanceRef::methodName
        list.forEach(super:: print);
    }
}
class Basecolon{
    //实例方法
    public void print(string s){
        System.out.println(s);
    }
}

5、引用类构造方法

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

//注意:该类无需实现接口
public class Colon{
    private String name;
    private int age;
    //无参构造
    public Colon(){ }
    //有参构造
    public colon(String name, int age){
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args){
        //无参构造引用
        ColonNoParam cnp = Colon::new;
        colon c1 = cnp.createColon();
        System.out.println(c1);
        //有参构造引用
        ColonlithParam cwp = Colon::new;
        colon c2 = cwp.createColon("小明",20);
        System.out.println(c2);
    }
    //生成toString方法打印查看
    @Override
    public string toString() {
        return "Colon{" +
                "name='"+ name + "\"+
                ",age=" + age +
                '}';
    }
}
interface colonNoParam{
    //无参方法提供对象
    Colon createColon();
}
interface ColonwithParam{
    //有参方法提供对象（数据类型要与colon有参构造函数对应)
    colon createColon(String s,int i);
}

6、引用数组构造方法

我们可以借助jdk自带的java.util.function.Function类实现对数组构造函数的引用。​​​​​​​

当然，我们也可以使用@FunctionalInterface自定义函数式接口来实现：

public class Colon{
    public static void main(string[] args) {
        MyArrayFunction<Integer,Colon[]> function = Colon[]::new;
        //调用apply方法创建数组,这里的5是教组的长度
        colon[] arr = function.apply(5);
        //循环输出-初始都为null
        for(Colon c:arr){
            System.out.println(c);
        }
    }
}
//自定义函教式接口
@FunctionalInterface
interface MyArrayFunction<A,T>{
    T apply(A a);
}