删除Java中的重载方法

Question

有 2 个重载方法。
这些方法中的每一个都将一种类型的列表转换为不同类型的列表。但是第一种方法使用比较器。

class SomeClass {
    public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                                 Function<T, G> mapperFunction, 
                                                 Comparator<? super G> comparator) {
           return Stream.ofNullable(inputList)
                        .flatMap(List::stream)
                        .map(mapperFunction)
                        .sorted(comparator)
                        .collect(Collectors.toList());
    }
    public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                                 Function<T, G> mapperFunction) {
           return Stream.ofNullable(inputList)
                        .flatMap(List::stream)
                        .map(mapperFunction)
                        .collect(Collectors.toList());
    }
}

如您所见，大部分行都是重复的。如何摆脱第二种方法，以便将 null 作为比较器传递给第一种方法不会破坏它？

换句话说，如何在没有比较器的情况下使第一个工作？

Answer 1

使用if 语句检查null：

public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction,
                                             Comparator<? super G> comparator) {
    Stream<G> stream = Stream.ofNullable(inputList)
            .flatMap(List::stream)
            .map(mapperFunction);
    if (comparator != null)
        stream = stream.sorted(comparator);
    return stream.collect(Collectors.toList());
}

public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction) {
    return toListOfNewType(inputList, mapperFunction, null);
}

Answer 2

虽然我的第二个目标是在实现方面消除代码重复，但我认为给 null 赋予特殊含义而不是明确重载方法是朝着错误方向迈出的一步。

为了调用者的方便，你仍然可以有两种方法，在实现中没有代码重复，例如：

public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction,
                                             Comparator<? super G> comparator) {
  List<G> resultList = toListOfNewType(inputList, mapperFunction);
  if(!resultList.isEmpty()) resultList.sort(comparator);
  return resultList;
}
public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction) {
  return inputList==null? Collections.emptyList():
    inputList.stream().map(mapperFunction).collect(Collectors.toCollection(ArrayList::new));
}

我什至会考虑放弃对null 输入列表的支持，因为它只会导致隐藏问题而不是解决问题。

另一种选择是：

public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction,
                                             Comparator<? super G> comparator) {
  return toListOfNewTypeImpl(inputList, mapperFunction, s -> s.sorted(comparator));
}
public static <T, G> List<G> toListOfNewType(List<T> inputList,
                                             Function<T, G> mapperFunction) {
  return toListOfNewTypeImpl(inputList, mapperFunction, UnaryOperator.identity());
}
private static <T, G> List<G> toListOfNewTypeImpl(List<T> inputList,
                                                  Function<T, G> mapperFunction,
                                                  UnaryOperator<Stream<G>> lastOp) {
  return lastOp.apply(inputList.stream().map(mapperFunction)).collect(Collectors.toList());
}

Answer 3

我可能只是用非常小的输入对其进行了测试（当然，即使在不需要时，执行元素比较的效率也较低），但可能这样做：

public static <T, G> List<G> toListOfNewType(List<T> inputList, Function<T, G> mapperFunction) {
    return toListOfNewType(inputList, mapperFunction, (a, b) -> 0);
}

Answer 4

在我的团队中询问一些代码审查也是一件有趣的事情......这里的问题是，如果你允许 nullable Comparator 你有点违背目的。 argument 是 Comparator and 是 null 是 自然顺序 排序的完全有效含义，这意味着这是完全有效的：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);

Collections.sort(list, null);

即使您的 internal 实现不允许它按原样进行，这意味着：

List.of(4, 3, 2)
     .stream()
     .sorted(null)
     .forEachOrdered(System.out::println);

会抛出一个NullPointerException。

所以除非你清楚地记录你对这个方法的意图是什么，用户可能会感到困惑（我会）。

恕我直言，“复制”的代码并不多，您可以强制用户通过 Function 返回“某事”，即Comparable：

public static <T, G extends Comparable<? extends G>> List<G> sortedToListOfNewType(
    List<T> inputList,
    Function<T, G> mapperFunction) {

    return Stream.ofNullable(inputList)
                 .flatMap(List::stream)
                 .map(mapperFunction)
                 .sorted()
                 .collect(Collectors.toList());
}

public static <T, G> List<G> toListOfNewType(
    List<T> inputList,
    Function<T, G> mapperFunction) {

    return Stream.ofNullable(inputList)
                 .flatMap(List::stream)
                 .map(mapperFunction)
                 .collect(Collectors.toList());
}

缺点是 1) 重复的代码——你试图完全避免这意味着 2) 这些不能是重载的方法——因为擦除是相同的，编译器不允许这样做。

但是，如上所述，这种方法非常主观。

Answer 5

我认为没有简单的方法可以做到这一点，或者我不知道。但如果你想试试我的库：abacus-util，你可以这样做：

StreamEx.of(inputList)
    .map(mapperFunction)
    .__(s -> comparator == null ? s : s.sort(comparator))
    .toList()