如何理解并使用Java中双冒号(::)运算操作符

Java基础 潘老师 4个月前 (08-16) 172 ℃ (0) 扫码查看

Java中双冒号操作符是Java 8中的Lambda表达式写法之一,对于Lambda表达式潘老师之前也写过总结的博文,大家可执行在博客中搜索,下面我们来看一下我们应该如何理解并使用Java中双冒号操作符。

1、定义

双冒号运算操作符是类方法的句柄,lambda表达式的一种简写,这种简写的学名叫eta-conversion或者叫η-conversion。
2、理解

英文格式双冒号::,读:double colon,双冒号(::)运算符在Java 8中被用作方法引用(method reference),方法引用是与lambda表达式相关的一个重要特性。它提供了一种执行方法的方法,为此,方法引用需要由兼容的函数式接口组成的目标类型上下文。

Method References(关于方法引用的描述-来自Oracle官网)
You use lambda expressions to create anonymous methods. Sometimes, however, a lambda expression does nothing but call an existing method. In those cases, it’s often clearer to refer to the existing method by name. Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name.

大概意思就是,使用lambda表达式会创建匿名函数, 但有时候需要使用一个lambda表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!

1、使用场景

双冒号(::)使用场景一般有如下6种:

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

2、案例详解

2.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);
        //上一行等价于
        //list.forEach((x)->Colon.print(x));
    }
    //静态方法
    public static void print(String s){
        System.out.println(s);
    }
}

2.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");
        //实例方法引用  instanceRef::methodName
        list.forEach(new Colon()::print);
        //上一行等价于
        //list.forEach((x)->new Colon().print(x));
    }
    //实例方法
    public void print(String s){
        System.out.println(s);
    }
}

2.3)引用特定类型的任意对象的实例方法

import org.junit.Test;
import java.util.Arrays;

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

注意:不要和引用静态方法搞混,认为为什么compareToIgnoreCase是非静态方法却可以使用类名去引用,这两者根本不是一回事,双冒号前的类含义也不同,就是两个应用方向

运行结果如下:
如何理解并使用Java中双冒号(::)运算操作符
2.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);
    }
}

2.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);
        //有参构造引用
        ColonWithParam 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);
}

运行结果可以看下:
如何理解并使用Java中双冒号(::)运算操作符
2.6)引用数组构造方法
我们可以借助jdk自带的java.util.function.Function类实现对数组构造函数的引用。

import java.util.function.Function;

public class Colon{

    public static void main(String[] args) {
        Function<Integer,Colon[]> function = Colon[]::new;
        //调用apply方法创建数组,这里的5是数组的长度
        Colon[] arr = function.apply(5);
        //循环输出-初始都为null
        for(Colon c:arr){
            System.out.println(c);
        }
    }
}

当然,我们也可以使用@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);
}

以上就是Java中双冒号(::)运算操作符使用方式,在一定程度上简化了我们Java开发的冗余代码,但也增加了我们的Java学习难度,如果你无法理解此种用法,最好不使用就可以了,以免出错!


版权声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系潘老师进行处理。
喜欢 (0)
请潘老师喝杯Coffee吧!】
分享 (0)

您必须 微信登录 才能发表评论!