1.方法引用的理解
(1). 方法的引用,可以看作是对lambda表达式的进一步刻画.
(2). 当需要提供一个函数式接口的实例时,可以使用lambda表达式提供.当满足一定的条件下,我们还可以使用方法引用或构造器引用替代.
(3). 方法引用的本质就是提供了函数式接口的实例.
2.使用情况
(1). 对象 :: 实例方法
要求 : 函数式接口的抽象方法a与其内部实现时调用的某个方法b的形参列表与返回值类型都相同或一致时.此时可以使用方法b对方法a实现覆盖,替换.
@Test
public void test1() {
//繁琐的匿名实现类的对象的写法
Consumer<String> c1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
c1.accept("hexua");
//简洁的方法引用的写法
//System.out为标准输出流, 类型为PrintStream
Consumer<String> c2 = System.out :: println;
c2.accept("hexua");
//输出 : hexua
// hexua
}
注 : 此时accept方法与println方法形参列表相同(都是String类型),都没有返回值类型.所以可以用方法引用,用println方法对accept方法进行覆盖.
(2). 类 :: 类方法
要求 : 函数式接口的抽象方法a与其内部实现时调用的某个类中的静态方法b的形参列表与返回值类型都相同或一致时.此时可以使用方法b对方法a实现覆盖,替换.
@Test
public void test2() {
//繁琐的匿名实现类的对象的写法
Function<Double , Long> f1 = new Function<Double, Long>() {
@Override
public Long apply(Double aDouble) {
return Math.round(aDouble);
}
};
System.out.println(f1.apply(34.4));
//简洁的方法引用的写法
Function<Double, Long> f2 = Math :: round;
System.out.println(f2.apply(34.4));
//输出 : 34
// 34
}
注 : 此时apply方法与round方法的形参列表一致(apply是Double型,round是double型).且返回值类型同样一致.所以可以实现round方法对apply的覆盖.
(3). 类 :: 实例方法
要求 : 函数式接口中的抽象方法a与其内部实现时调用的某个对象的实例方法b的返回值类型相同或一致.
同时,抽象方法a中有n个参数,方法b中有n-1个参数,且抽象方法a中的第一个参数作为方法b的调用者,且抽象方法a的第一个参数后的n-1的参数与方法b的n-1个参数类型均相同或一致,则可以考虑使用方法b对方法a的覆盖.
注 : 此时方法b为非静态方法,需要对象调用,但形式上,需要写出对象a(抽象方法a参数列表中的第一个参数)所属的类.
@Test
public void test3() {
//繁琐的匿名实现类的对象的写法
Comparator<String> c1 = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
};
System.out.println(c1.compare("hexua", "hexuan"));
//简洁的方法引用的写法
Comparator<String> c2 = String :: compareTo;
System.out.println(c2.compare("hexua", "hexuan"));
//输出 : -1
// -1
}
注 : compare方法的第一个参数作为compareTo方法的调用者,且compare方法的后一个参数的类型与compareTo方法的参数类型相同,且该两个方法的返回类型相同,故可以实现compareTo方法对compare方法的覆盖.
3.构造器引用
(1). 格式 : 类名 :: new.
(2). 例 :
public class Employee {
int age;
String name;
public Employee() {
System.out.println("调用了空参构造器");
}
public Employee(int age, String name) {
System.out.println("调用了有两个参数的构造器");
this.age = age;
this.name = name;
}
public Employee(int age) {
System.out.println("调用了一个参数构造器");
this.age = age;
}
}
@Test
public void test4() {
Supplier<Employee> s1 = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
Employee e1 = s1.get();
Supplier<Employee> e2 = Employee :: new;
Employee s2 = e2.get();
//输出 : 调用了空参构造器
//调用了空参构造器
}
@Test
public void test5() {
Function<Integer, Employee> f1 = Employee :: new;
f1.apply(12);
//输出 : 调用了一个参数构造器
}
@Test
public void test6() {
BiFunction<Integer, String, Employee> f1 = Employee :: new;
f1.apply(12, "hexua");
//输出:调用了有两个参数的构造器
}
注 :
- 调用了类名对应的类中某个对应的构造器.
- 具体调用的构造器取决于函数式接口中的抽象方法的参数列表.如Supplier接口中的get()方法无参,返回值类型为Employee,则返回无参数的Employee对象.Function接口中的apply方法有一个参数(类型Integer),则返回有一个参数的Employee对象.
4.数组引用.
(1). 格式 : 数组元素的类型[] :: new
(2). 例 :
@Test
public void test7() {
Function<Integer, Employee[]> f1 = new Function<Integer, Employee[]>() {
@Override
public Employee[] apply(Integer integer) {
return new Employee[integer];
}
};
Employee[] e1 = f1.apply(4);
System.out.println("数组的长度" + e1.length);
Function<Integer, Employee[]> f2 = Employee[] :: new;
Employee[] e2 = f2.apply(4);
System.out.println("数组的长度" + e2.length);
//输出 :数组的长度4
//数组的长度4
}