Java 8 akışının minimum ve maksimum değerini elde etmenin özlü yolu

Question

Bir geçişte (bazı karşılaştırıcılara dayalı olarak) hem minimum hem de maksimum değerini ayıklamak için kısa bir yol var mı?

bireysel min almak için birçok yol ve maksimum değerleri Orada görünüyor, yoksa örneğin bir geçici nesnesine akışı sıralayabilirsiniz:

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

Ama bu özlü değildir ve tahsis gerektirir geçici nesne Geçici bir nesne ayırmamayı veya akıştan iki geçiş yapmayı tercih ederim. Alternatif var mı?

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

Answer 1

, daha iyi iş yapmak için bir Collector olun. count, min, max'u tutturmak için Stats sınıfına ve istatistik yöntemleri oluşturmak için fabrika yöntemlerine ihtiyacımız var. Eğer bir Akış varsa

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 2

Akışın her bir öğesinin, iki öğenin min ve maks; ve daha sonra çiftleri minimuma indirerek çiftleri küçültün.

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 3

herhangi değişken Pair sınıfını kullanan bir açık yaklaşım: oldukça özlü olan bir saf Java çözüm için

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 4

, kullanabileceğiniz bazı Pair sınıf ve bazı Comparator<T> kullanarak Örneğin

, .dikizlemek(). Bu gerçekten işlevsel değildir, çünkü .peek() 'in bir yan etkisi olduğu gibi. Ama bu her şeyi bir geçişte yapıyor, sıralama gerektirmiyor ve çok ayrıntılı değil. Bir "temp" Nesne, AtomicRef var, ama muhtemelen her zaman min ve max tutmak için bir yerel var/ref tahsis edeceksin. Bu sık ihtiyaç duyulan bir özellik ise

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 5

summarizingInt kollektör iyi çalışıyor -

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

fooStream.collect(Stats.collector(fooComparator)) 

Ben Bir örnek Stats sınıf yapılan

(Belki daha iyi bir rahatlık yöntemi Stats.collect(stream) olurdu) Tamsayılar. Eğer çiftler varsa

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

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

Eğer summarizingDouble kollektörü kullanabilirsiniz.

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