为什么 Java Collector.toList（） 在其返回类型中需要通配符类型占位符？

收集器有三个类型参数：

T- 简化操作的输入元素的类型

A- 缩减操作的可变累积类型（通常隐藏为实现细节）

R- 还原操作的结果类型

对于某些收集器，例如 ，的类型和 是相同的，因为结果本身用于累积。toListAR

从中返回的收集器的实际类型为 。toListCollector<T, List<T>, List<T>>

（收集器的一个示例使用与其结果不同的类型进行累积，这是 Collectors.joining（） 它使用 StringBuilder。

大多数时候，类型参数是一个通配符，因为我们通常不关心它到底是什么。它的实际类型仅由收集器内部使用，如果需要用名称引用它，我们可以捕获它：A

// Example of using a collector.
// (No reason to actually write this code, of course.)
public static <T, R> collect(Stream<T> stream,
                             Collector<T, ?, R> c) {
    return captureAndCollect(stream, c);
}
private static <T, A, R> captureAndCollect(Stream<T> stream,
                                           Collector<T, A, R> c) {
    // Create a new A, whatever that is.
    A a = c.supplier().get();

    // Pass the A to the accumulator along with each element.
    stream.forEach(elem -> c.accumulator().accept(a, elem));

    // (We might use combiner() for e.g. parallel collection.)

    // Pass the A to the finisher, which turns it in to a result.
    return c.finisher().apply(a);
}

您还可以在代码中看到它指定Collectors.CH_ID作为其特征，这指定了标识完成。这意味着它的完成器除了返回传递给它的任何内容之外什么都不做。toList

（本节由我在下面的评论中引用。

以下是为累加器携带类型参数的几种替代设计。我认为这些说明了为什么课程的实际设计是好的。Collector

1. 只是使用，但我们最终会铸造很多。Object

   interface Collector<T, R> {
       Supplier<Object> supplier();
       BiConsumer<Object, T> accumulator();
       BiFunction<Object, Object, Object> combiner();
       Function<Object, R> finisher();
   }
   
   static <T> Collector<T, List<T>> toList() {
       return Collector.of(
           ArrayList::new,
           (obj, elem) -> ((List<T>) obj).add(elem),
           (a, b) -> {
               ((List<T>) a).addAll((List<T>) b);
               return a;
           },
           obj -> (List<T>) obj);
   }
   

2. 隐藏累加器作为 的实现细节，就像自身在内部进行累积一样。我认为这可能是有道理的，但它不太灵活，合并器步骤变得更加复杂。CollectorCollector

   interface Collector<T, R> {
       void accumulate(T elem);
       void combine(Collector<T, R> that);
       R finish();
   }
   
   static <T> Collector<T, List<T>> toList() {
       return new Collector<T, List<T>>() {
           private List<T> list = new ArrayList<>();
           @Override
           public void accumulate(T elem) {
               list.add(elem);
           }
           @Override
           public void combine(Collector<T, List<T>> that) {
               // We could elide calling finish()
               // by using instanceof and casting.
               list.addAll(that.finish());
           }
           @Override
           public List<T> finish() {
               return new ArrayList<>(list);
           }
       };
   }