Question

是否有一种简洁的方法可以在一次传递中提取流的最小值和最大值（基于某个比较器）？

似乎有很多方法可以单独获取最小值和最大值，或者我可以将流排序为临时对象，例如：

List<T> sorted = Stream.of(...).sorted().collect(Collectors.toList());
T min = sorted.get(0);
T max = sorted.get(sorted.size() - 1);

但这并不简洁，需要分配一个临时对象。我宁愿不分配临时对象或在流中进行两次传递。还有其他选择吗？

Pair<T> extent = Stream.of(...).???

Answer 1

如果你有一个整数流，summarizingInt收集器效果很好。

IntSummaryStatistics stats = Stream.of(2,4,3,2)
      .collect(Collectors.summarizingInt(Integer::intValue));

int min = stats.getMin();
int max = stats.getMax();

如果你有双打，你可以使用summarizingDouble收集器。

DoubleSummaryStatistics stats2 = Stream.of(2.4, 4.3, 3.3, 2.5)
  .collect(Collectors.summarizingDouble((Double::doubleValue)));

Answer 2

如果这是经常需要的功能，我们最好让Collector来完成这项工作。我们需要一个Stats类来保存count, min, max，以及工厂方法来创建统计信息收集器。

Stats<String> stats = stringStream.collect(Stats.collector())

fooStream.collect(Stats.collector(fooComparator))

（也许更方便的方法是Stats.collect(stream)）

我做了一个例子Stats类 -

https://gist.github.com/zhong-j-yu/ac5028573c986f7820b25ea2e74ed672

public class Stats<T>
{
    int count;

    final Comparator<? super T> comparator;
    T min;
    T max;

    public Stats(Comparator<? super T> comparator)
    {
        this.comparator = comparator;
    }

    public int count(){ return count; }

    public T min(){ return min; }
    public T max(){ return max; }

    public void accept(T val)
    {
        if(count==0)
            min = max = val;
        else if(comparator.compare(val, min)<0)
            min = val;
        else if(comparator.compare(val, max)>0)
            max = val;

        count++;
    }

    public Stats<T> combine(Stats<T> that)
    {
        if(this.count==0) return that;
        if(that.count==0) return this;

        this.count += that.count;
        if(comparator.compare(that.min, this.min)<0)
            this.min = that.min;
        if(comparator.compare(that.max, this.max)>0)
            this.max = that.max;

        return this;
    }

    public static <T> Collector<T, Stats<T>, Stats<T>> collector(Comparator<? super T> comparator)
    {
        return Collector.of(
            ()->new Stats<>(comparator),
            Stats::accept,
            Stats::combine,
            Collector.Characteristics.UNORDERED, Collector.Characteristics.IDENTITY_FINISH
        );
    }

    public static <T extends Comparable<? super T>> Collector<T, Stats<T>, Stats<T>> collector()
    {
        return collector(Comparator.naturalOrder());
    }
}

Answer 3

将流的每个元素映射到一对，其中两个元素表示最小值和最大值;然后通过获取分钟的最小值和最大值来减少对。

例如，使用一些Pair类和一些Comparator<T>：

Comparator<T> comparator = ...;
Optional<Pair<T, T>> minMax = list.stream()
    .map(i -> Pair.of(i /* "min" */, i /* "max" */))
    .reduce((a, b) -> Pair.of(
        // The min of the min elements.
        comparator.compare(a.first, b.first) < 0 ? a.first : b.first,
        // The max of the max elements.
        comparator.compare(a.second, b.second) > 0 ? a.second : b.second));

Answer 4

从 Java 12 开始，您可以使用 Collectors::teeing 一次获得两个或更多结果：

class Movie {
    String title;
    double rating;
    //...
}

class Pair<T1, T2> {
    T1 left;
    T2 right;
    //...
}

@Test
void shouldFindWorstAndBestMovie() {
    var m1 = new Movie("Groundhog Day", 8);
    var m2 = new Movie("Stop! Or My Mom Will Shoot", 4.4);
    var m3 = new Movie("Forrest Gump", 8.8);

    var ratingComparator = Comparator.comparing(Movie::getRating);

    Pair<Movie, Movie> result = Stream.of(m1, m2, m3)
            .collect(Collectors.teeing(
                    Collectors.minBy(ratingComparator),
                    Collectors.maxBy(ratingComparator),
                    (min, max) -> new Pair<>(min.orElse(null), max.orElse(null))
            ));

    assertEquals(m2, result.getLeft(), "min does not match");
    assertEquals(m3, result.getRight(), "max does not match");
}

您可以在 this article 中找到更多详细信息和示例。

Answer 5

使用任何可变Pair类的直接方法：

final Pair<T, T> pair = new Pair<>();
final Comparator<T> comparator = ...;
Stream.of(...).forEachOrdered(e -> {
    if(pair.first == null || comparator.compare(e, pair.first) < 0){
        pair.first = e;
    }
    if(pair.second == null || comparator.compare(e, pair.second) > 0){
        pair.second = e;
    }
});

Answer 6

对于一个相当简洁的纯Java解决方案，您可以使用.peek（）。这不是真正的功能，因为.peek（）所做的任何事都是副作用。但这确实在一次通过中完成所有操作，不需要排序，也不太冗长。有一个＆＃34; temp＆＃34;对象，AtomicRef，但你可能会分配一个局部var / ref来保持最小值和最大值。

Comparator<T> cmp = ...
Stream<T> source = ...
final AtomicReference<T> min = new AtomicReference<T>();
Optional<T> max = source.peek(t -> {if (cmp.compare(t,min.get()) < 0) min.set(t);})
    .max(cmp);
//Do whatever with min.get() and max.get()

Answer 7

我认为您需要

IntStream myIntStream = IntStream.rangeClosed(1, 100);
IntSummaryStatistics intStatistic = myIntStream.summaryStatistics();

System.out.println("Max: " + intStatistic.getMax() + " Min: " + intStatistic.getMin());

获得Java 8流的最小值和最大值的简明方法

7 个答案: