您可以使用filter和count缩短代码，但在这里使用循环更简洁。Stream并不总是解决方案。

return Arrays.asList(
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) > b.get(i)).count(),
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) < b.get(i)).count()
);

Java 8 -partitioningBy()和counting()

对于在给定数据集上执行仅一次迭代的流，解决该问题的方法之一是利用构建的收集器partitioningBy()和counting()：

public static List<Integer> compareTriplets(List<Integer> a, List<Integer> b) {
    
    return IntStream.range(0, a.size())
        .map(i -> a.get(i) - b.get(i))
        .filter(i -> i != 0)
        .boxed()
        .collect(Collectors.collectingAndThen(
            Collectors.partitioningBy(i -> i > 0, Collectors.counting()),
            map -> Arrays.asList(map.get(true).intValue(), map.get(false).intValue())
        ));
}

Java 8 -自定义Collector

另一种选择是使用静态工厂方法Collector.of()定义自定义收集器。与之前的方法一样，它允许使用单个流处理数据：

public static List<Integer> compareTriplets(List<Integer> a, List<Integer> b) {
    
    return IntStream.range(0, a.size())
        .boxed()
        .collect(Collector.of(
            () -> new int[]{0, 0},
            (int[] score, Integer i) -> {
                if (a.get(i) > b.get(i)) score[0]++;
                if (b.get(i) > a.get(i)) score[1]++;
            },
            (int[] left, int[] right) -> {
                Arrays.setAll(left, i -> left[i] + right[i]);
                return left;
            },
            arr -> Arrays.asList(arr[0], arr[1])
        ));
}

Java 12 -收集器teeing()

另一个允许使用单个流生成结果的选项是Java 12 Collector teeing()，它需要两个下游Collector和一个Function，后者通过合并它们生成的结果来执行最终转换。

public static List<Integer> compareTriplets(List<Integer> a, List<Integer> b) {
    
    return IntStream.range(0, a.size())
        .boxed()
        .collect(Collectors.teeing(
            Collectors.filtering(i -> a.get(i) > b.get(i), Collectors.counting()),
            Collectors.filtering(i -> b.get(i) > a.get(i), Collectors.counting()),
            (alice, bob) -> List.of(alice.intValue(), bob.intValue())
        ));
}

这对于您的情况来说可能有些过分，但您可以将其作为流缩减来处理：

class Counter {
    private int bob = 0;
    private int alice = 0;

    public void accept(int index) {
        if (a[index] > b[index])
            alice++;
        else if (a[index] < b[index])
            bob++;
    }
}

Counter counter = IntStream.range(0, a.size()).boxed().reduce(new Counter(), Counter::accept);

另一种方法是利用Integer.compare：

List<Integer> comparisons = IntStream.range(0, a.size()).map(i -> Integer.compare(a[i], b[i]).toList();
long bob = comparisons.stream().filter(n -> n < 0).count();
int alice = comparisons.stream().filter(n -> n > 0).count();