In che modo Stream.max() gestisce l'uguaglianza?

Question

Anche se ho il sospetto che la risposta sia "Non è specificato" ...

Se ci sono più "grandi/più bassi" elementi in un Stream cui il Comparator passò ai max o min metodi considera uguale (restituisce 0) , è specificato da qualche parte quale elemento verrà trovato?

Answer 1

È davvero difficile estrarre una dichiarazione definitiva dalla documentazione. Se proviamo a trarre una conclusione dalla descrizione generale del processo di "Riduzione" e da accenni simili alla documentazione, sembrerà sempre che stiamo facendo troppa interpretazione.

Tuttavia, c'è un explicit statement regarding this matter da Brian Goetz che è piuttosto un autorità per quanto riguarda l'API Stream:

Se il flusso viene ordinato (come ad esempio i flussi si ottiene da un array o List), restituisce il prima elemento che è massimale nel caso di più elementi massimali; solo se lo stream non è ordinato è consentito selezionare un elemento arbitrario.

E 'un peccato che una dichiarazione così esplicita non è fatta proprio alla documentazione dei Stream.max, ma almeno è in linea con la nostra esperienza e conoscenza della realizzazione (those of us who looked at the source code). E non dimenticare, considerazioni pratiche, poiché è facile dire "sceglierne uno piuttosto che prima" tramite lo unordered().max(comparator) con lo stato attuale anziché pronunciare "scegli prima piuttosto che qualsiasi" se lo max è stato autorizzato a scegliere un elemento arbitrario in primo luogo .

Answer 2

Dopo aver letto il codice sorgente, penso che dovrebbe essere il primo elemento più grande verrà trovato in base all'ordine di raccolta. Siamo in grado di controllare il codice sorgente del Stream.max(Comparator<? super T> comparator), la classe di implementazione è ReferencePipeline.max

@Override 
    public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) { 
     return reduce(BinaryOperator.maxBy(comparator)); 
    } 

che si può vedere, quando si chiama il Stream.max, vuoi dire chiamare il Stream.reduce(BinaryOperator<P_OUT> accumulator)

E guardare il codice sorgente di BinaryOperator.maxBy(comparator)

public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) { 
     Objects.requireNonNull(comparator); 
     return (a, b) -> comparator.compare(a, b) >= 0 ? a : b; 
    } 

E 'chiaro, quando a uguale b, restituisce a. Quindi, quando ci sono più elementi "più grandi/più bassi" in un flusso, l'elemento "più grande/più basso" dovrebbe essere il primo elemento "più grande/più basso" in base all'ordine di raccolta

C'è un esempio a blew, solo per il tuo riferimento.

 List<Student> list = Arrays.asList(new Student("s1", 1), new Student("s2", 5), new Student("s3", 3), new Student("s4", 5)); 
     // it should be student of 's2' 
     list.stream().max(Comparator.comparing(Student::getScore)); 
     // it should be student of 's4' 
     list.stream().reduce((a, b) -> Comparator.comparing(Student::getScore).compare(a, b) > 0 ? a : b);