Java实现提供收集器的累加器类

Question

Collector 具有三种通用类型：

public interface Collector<T, A, R>

以A 为归约操作的可变累积类型（通常作为实现细节隐藏）.

如果我想创建我的自定义收集器，我需要创建两个类：

• 一种用于自定义累积类型
• 一个用于自定义收集器本身

是否有任何库函数/技巧可以采用累积类型并提供相应的收集器？

简单的例子

这个例子更简单地说明了这个问题，我知道我可以在这种情况下使用reduce，但这不是我想要的.这是more complex example，在这里分享会使问题变得太长，但这是相同的想法。

假设我想收集流的总和并将其作为String 返回。

我可以实现我的累加器类：

public static class SumCollector {
   Integer value;

    public SumCollector(Integer value) {
        this.value = value;
    }

    public static SumCollector supply() {
        return new SumCollector(0);
    }

    public void accumulate(Integer next) {
       value += next;
    }

    public SumCollector combine(SumCollector other) {
       return new SumCollector(value + other.value);
    }

    public String finish(){
        return Integer.toString(value);
    }
}

然后我可以从这个类创建一个Collector：

Collector.of(SumCollector::supply, SumCollector::accumulate, SumCollector::combine, SumCollector::finish);

但是对我来说似乎很奇怪，它们都指的是另一个类，我觉得有一种更直接的方法可以做到这一点。

为了只保留一个类，我可以做的是implements Collector<Integer, SumCollector, String>，但随后每个函数都会被复制（supplier() 将返回SumCollector::supply，等等）。

Answer 1

不需要将函数实现为容器类的方法。

这就是这种收款人的典型实施方式

public static Collector<Integer, ?, Integer> sum() {
    return Collector.of(() -> new int[1],
        (a, i) -> a[0] += i,
        (a, b) -> { a[0] += b[0]; return a; },
        a -> a[0],
        Collector.Characteristics.UNORDERED);
}

但是，当然，您也可以将其实现为

public static Collector<Integer, ?, Integer> sum() {
    return Collector.of(AtomicInteger::new,
        AtomicInteger::addAndGet,
        (a, b) -> { a.addAndGet(b.intValue()); return a; },
        AtomicInteger::intValue,
        Collector.Characteristics.UNORDERED, Collector.Characteristics.CONCURRENT);
}

您首先必须为您的收集器找到合适的可变容器类型。如果不存在这样的类型，则必须创建自己的类。这些函数可以实现为对现有方法的方法引用或 lambda 表达式。

对于更复杂的示例，我不知道有合适的现有类型来保存int 和List，但您可以使用盒装的Integer，就像这样

final Map<String, Integer> map = …
List<String> keys = map.entrySet().stream().collect(keysToMaximum());

public static <K> Collector<Map.Entry<K,Integer>, ?, List<K>> keysToMaximum() {
    return Collector.of(
        () -> new AbstractMap.SimpleEntry<>(new ArrayList<K>(), Integer.MIN_VALUE),
        (current, next) -> {
            int max = current.getValue(), value = next.getValue();
            if(value >= max) {
                if(value > max) {
                    current.setValue(value);
                    current.getKey().clear();
                }
                current.getKey().add(next.getKey());
            }
        }, (a, b) -> {
            int maxA = a.getValue(), maxB = b.getValue();
            if(maxA <= maxB) return b;
            if(maxA == maxB) a.getKey().addAll(b.getKey());
            return a;
        },
        Map.Entry::getKey
    );
}

但是您也可以创建一个新的专用容器类作为 ad-hoc 类型，在特定收集器之外不可见

public static <K> Collector<Map.Entry<K,Integer>, ?, List<K>> keysToMaximum() {
    return Collector.of(() -> new Object() {
        int max = Integer.MIN_VALUE;
        final List<K> keys = new ArrayList<>();
    }, (current, next) -> {
        int value = next.getValue();
        if(value >= current.max) {
            if(value > current.max) {
                current.max = value;
                current.keys.clear();
            }
            current.keys.add(next.getKey());
        }
    }, (a, b) -> {
        if(a.max <= b.max) return b;
        if(a.max == b.max) a.keys.addAll(b.keys);
        return a;
    },
    a -> a.keys);
}

要点是，您不需要创建新的命名类来创建Collector。

Answer 2

听起来你想提供只要归约函数本身，而不是通用Collector 附带的所有其他东西。也许您正在寻找Collectors.reducing。

public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)

然后，要对值求和，你会写

Collectors.reducing(0, (x, y) -> x + y);

或者，在上下文中，

Integer[] myList = new Integer[] { 1, 2, 3, 4 };
var collector = Collectors.reducing(0, (x, y) -> x + y);
System.out.println(Stream.of(myList).collect(collector)); // Prints 10

Answer 3

我想把重点放在你问题的某一点上，因为我觉得这可能是潜在混乱的症结所在。

如果我想创建我的自定义收集器，我需要创建两个类：

一种用于自定义累积类型 一个用于自定义收集器本身

不，您只需要创建一个班级，您的自定义累加器的那个。您应该使用the appropriate factory method 来实例化您的自定义Collector，就像您在问题中展示自己一样。

也许您的意思是说您需要创建两个实例。这也是不正确的；您需要创建一个Collector 实例，但要支持一般情况，许多可以创建累加器的实例（例如，groupingBy()）。因此，您不能简单地自己实例化累加器，您需要将其Supplier 提供给Collector，并将根据需要实例化尽可能多的实例的能力委托给Collector。

现在，想想你觉得缺少的重载Collectors.of() 方法，“更直接的方法来做到这一点”。显然，这种方法仍然需要Supplier，它会创建自定义累加器的实例。但是Stream.collect() 需要与您的自定义累加器实例交互，以执行累加和合并操作。所以Supplier 必须实例化类似Accumulator 接口的东西：

public interface Accumulator<T, A extends Accumulator<T, A, R>, R> {

    /**
     * @param t a value to be folded into this mutable result container
     */
    void accumulate(T t);

    /**
     * @param that another partial result to be merged with this container
     * @return the combined results, which may be {@code this}, {@code that}, or a new container
     */
    A combine(A that);

    /**
     * @return the final result of transforming this intermediate accumulator
     */
    R finish();

}

这样，就可以直接从Supplier<Accumulator> 创建Collector 实例：

    static <T, A extends Accumulator<T, A, R>, R> 
    Collector<T, ?, R> of(Supplier<A> supplier, Collector.Characteristics ... characteristics) {
        return Collector.of(supplier, 
                            Accumulator::accumulate, 
                            Accumulator::combine, 
                            Accumulator::finish, 
                            characteristics);
    }

然后，您就可以定义您的自定义Accumulator：

final class Sum implements Accumulator<Integer, Sum, String> {

    private int value;

    @Override
    public void accumulate(Integer next) {
        value += next;
    }

    @Override
    public Sum combine(Sum that) {
        value += that.value;
        return this;
    }

    @Override
    public String finish(){
        return Integer.toString(value);
    }

}

并使用它：

String sum = ints.stream().collect(Accumulator.of(Sum::new, Collector.Characteristics.UNORDERED));

现在……它起作用了，而且什么都没有也太可怕了，但是所有Accumulator<A extends Accumulator<A>> mumbo-jumbo 都比这“更直接”吗？

final class Sum {

    private int value;

    private void accumulate(Integer next) {
        value += next;
    }

    private Sum combine(Sum that) {
        value += that.value;
        return this;
    }

    @Override
    public String toString() {
        return Integer.toString(value);
    }

    static Collector<Integer, ?, String> collector() {
        return Collector.of(Sum::new, Sum::accumulate, Sum::combine, Sum::toString, Collector.Characteristics.UNORDERED);
    }

}

真的，为什么有一个Accumulator 专门收集到String？简化为自定义类型不是更有趣吗？类似于IntSummaryStatistics 的东西还有其他有用的方法，比如average() 和toString()？这种方法要强大得多，只需要一个（可变）类（结果类型），并且可以将其所有修改器封装为私有方法，而不是实现公共接口。

因此，欢迎您使用 Accumulator 之类的东西，但它并不能真正填补核心 Collector 曲目中的真正空白。