【Java】【Lambda】Lambda方法引用常见的几种用法
基本用法：
直接拿参数执行代码，推导出返回值
public class Test {
public static void main(String[] args) {
AddressComparator comparator = (source, target) -> {
return source.hashCode() - target.hashCode();
};
}
public int compare(Object target) {
return hashCode() - target.hashCode();
}
public interface AddressComparator {
int compare(Test source, Object target);
}
}
省略用法：
当执行代码只有一行时，可以省略代码块和return
public class Test {
public static void main(String[] args) {
AddressComparator comparator = (source, target) -> source.hashCode() - target.hashCode();
}
public int compare(Object target) {
return hashCode() - target.hashCode();
}
public interface AddressComparator {
int compare(Test source, Object target);
}
}
引用类的静态方法：
当类中含有参数列表，返回值类型和接口方法完全一致的静态方法时，可以引用这个类静态方法
public class Test {
public static void main(String[] args) {
AddressComparator comparator = Test::compare;
}
public static int compare(Test source, Object target) {
return 0;
}
public interface AddressComparator {
int compare(Test source, Object target);
}
}
引用特定对象的方法：
当对象中含有参数列表，返回值类型和接口方法完全一致的方法时，可以引用这个对象方法
当某个对象执行代码时，要引用父类或自己的方法，可以使用this或super指定作用域
public class Test {
public static void main(String[] args) {
Test test = new Test();
AddressComparator comparator = test::compare;
}
public void run(){
AddressComparator comparator = this::compare;
}
public int compare(Test source, Object target) {
return source.hashCode() - target.hashCode();
}
public interface AddressComparator {
int compare(Test source, Object target);
}
}
引用任意对象的方法：
这种模式下，会将接口方法的第一个参数作为执行对象，调用引用方法去执行后面的参数
显然，这种模式下，接口方法的第一个参数要和引用类类型一致，引用方法参数列表和接口方法后续参数列表一致
public class Test {
public static void main(String[] args) {
//使用source.compareTo(target)作为接口方法返回值
AddressComparator comparator = Test::compare;
}
public int compare(Object target) {
return hashCode() - target.hashCode();
}
public interface AddressComparator {
int compare(Test source, Object target);
}
}
引用构造方法：
当类中含有和接口方法参数列表，返回值类型完全一致的构造方法时，可以直接引用这个类的构造方法
public class Test {
public static void main(String[] args) {
AddressComparator comparator = Test::new;
}
public Test() {
}
public Test(int arg) {
}
public Test(int[] args) {
}
public interface AddressComparator {
void compare(int arg);
}
}
引用数组构造方法：
这种情形，要求接口方法必须接收int，返回数组
接口方法的实际实现方式，就是创建一个int长度的数组
public class Test {
public static void main(String[] args) {
AddressComparator<int[]> comparator = int[]::new;
int[] compare = comparator.length(10);
System.out.println(compare.length);
}
public interface AddressComparator<R> {
R length(int arg);
}
}
数组构造方法式lambda一个很重要的用途，就是用来创建泛型数组
由于泛型的实际类型是不确定的，不一定有public构造方法，因此一定是无法new出来的
而通过lambda，我们则可以用一种比较优雅的方式来间接new一个泛型数组
public class Test {
private static final List<String> list = new ArrayList();
static {
list.add("item");
list.add("item");
list.add("item");
list.add("item");
}
public static void main(String[] args) {
ListArrayConvertor<String> convertor = String[]::new;
String[] array = convertor.listToArray(list);
System.out.println(array[3]);
}
public interface ListArrayConvertor<R> {
R[] buildArray(int length);
default R[] listToArray(List<R> list) {
R[] array = buildArray(list.size());
for (int i = 0; i < list.size(); i++)
array[i] = list.get(i);
return array;
}
}
}