java - 这是如何编译的?
问题描述
我正在编写一个函数,它采用一系列 keyExtractor 函数来生成一个 Comparator(想象我们有一个具有许多属性的对象,并且希望能够以任意顺序任意比较大量属性)。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
class Test {
public static <T, S extends Comparable<S>> Comparator<T> parseKeysAscending(List<Function<T, S>> keyExtractors) {
if (keyExtractors.isEmpty()) {
return (a, b) -> 0;
} else {
Function<T, S> firstSortKey = keyExtractors.get(0);
List<Function<T, S>> restOfSortKeys = keyExtractors.subList(1, keyExtractors.size());
return Comparator.comparing(firstSortKey).thenComparing(parseKeysAscending(restOfSortKeys));
}
}
public static void main(String[] args) {
List<Extractor<Data, ?>> extractors = new ArrayList<>();
extractors.add(new Extractor<>(Data::getA));
extractors.add(new Extractor<>(Data::getB));
Comparator<Data> test = parseKeysAscending(
extractors.stream()
.map(e -> e)
.collect(Collectors.toList()));
}
}
class Extractor<T, S extends Comparable<S>> implements Function<T, S> {
private final Function<T, S> extractor;
Extractor(Function<T, S> extractor) {
this.extractor = extractor;
}
@Override
public S apply(T t) {
return extractor.apply(t);
}
}
class Data {
private final Integer a;
private final Integer b;
private Data(int a, int b) {
this.a = a;
this.b = b;
}
public Integer getA() {
return a;
}
public Integer getB() {
return b;
}
}
对我来说,有三个主要的困惑点:
1)。如果我不定义 Extractor 类,这将无法编译。我不能直接拥有 Functions 或某种功能接口。
2)。如果我删除标识函数映射行“.map(e -> e)”,则不会进行类型检查。
3)。我的 IDE 说我的函数正在接受 Data -> 类型的函数列表?这不符合 parseKeysAscending 函数的界限。
解决方案
它在没有Extractor
课程的情况下对我有用,也无需map(e -> e)
在流管道中调用。实际上,如果您使用正确的泛型类型,则根本不需要流式传输提取器列表。
至于为什么您的代码不起作用,我不完全确定。泛型是 Java 的一个艰难而脆弱的方面……我所做的只是调整parseKeysAscending
方法的签名,使其符合Comparator.comparing
实际期望。
这是parseKeysAscending
方法:
public static <T, S extends Comparable<? super S>> Comparator<T> parseKeysAscending(
List<Function<? super T, ? extends S>> keyExtractors) {
if (keyExtractors.isEmpty()) {
return (a, b) -> 0;
} else {
Function<? super T, ? extends S> firstSortKey = keyExtractors.get(0);
List<Function<? super T, ? extends S>> restOfSortKeys =
keyExtractors.subList(1, keyExtractors.size());
return Comparator.<T, S>comparing(firstSortKey)
.thenComparing(parseKeysAscending(restOfSortKeys));
}
}
这是一个带有调用的演示:
List<Function<? super Data, ? extends Comparable>> extractors = new ArrayList<>();
extractors.add(Data::getA);
extractors.add(Data::getB);
Comparator<Data> test = parseKeysAscending(extractors);
List<Data> data = new ArrayList<>(Arrays.asList(
new Data(1, "z"),
new Data(2, "b"),
new Data(1, "a")));
System.out.println(data); // [[1, 'z'], [2, 'b'], [1, 'a']]
data.sort(test);
System.out.println(data); // [[1, 'a'], [1, 'z'], [2, 'b']]
使代码在没有警告的情况下编译的唯一方法是将函数列表声明为List<Function<Data, Integer>>
. 但这仅适用于返回的吸气剂Integer
。我假设您可能想要比较Comparable
s 的任何组合,即上面的代码适用于以下Data
类:
public class Data {
private final Integer a;
private final String b;
private Data(int a, String b) {
this.a = a;
this.b = b;
}
public Integer getA() {
return a;
}
public String getB() {
return b;
}
@Override
public String toString() {
return "[" + a + ", '" + b + "']";
}
}
这是演示。
编辑:请注意,使用 Java 8,parseKeysAscending
方法的最后一行可以是:
return Comparator.comparing(firstSortKey)
.thenComparing(parseKeysAscending(restOfSortKeys));
而对于较新版本的 Java,您必须提供显式的泛型类型:
return Comparator.<T, S>comparing(firstSortKey)
.thenComparing(parseKeysAscending(restOfSortKeys));