Java中双冒号操作符是Java 8中的Lambda表达式写法之一,对于Lambda表达式潘老师之前也写过总结的博文,大家可执行在博客中搜索,下面我们来看一下我们应该如何理解并使用Java中双冒号操作符。
双冒号运算操作符是类方法的句柄,lambda表达式的一种简写,这种简写的学名叫eta-conversion或者叫η-conversion。
英文格式双冒号
::
,读: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表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!
双冒号(::)使用场景一般有如下6种:
类型 | 引用语法 | 案例 |
引用静态方法 | 类名::静态方法名 | Integer::parseInt |
引用特定对象实例方法 | 对象::实例方法名 | System.out::println |
引用特定类型的任意对象的实例方法 | 特定类型::实例方法名 | String::compareToIgnoreCase |
引用超类(父类)实例方法 | super::方法名 | |
引用类构造方法 | 类名::new | ArrayList::new |
引用数组构造方法 | 数组类型[]::new | String[]::new |
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
是非静态方法却可以使用类名去引用,这两者根本不是一回事,双冒号前的类含义也不同,就是两个应用方向运行结果如下:

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); }
运行结果可以看下:
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学习难度,如果你无法理解此种用法,最好不使用就可以了,以免出错!