Come fare catena e applicare un flusso di comparatori?

Question

Ho un flusso di articoli non ordinati e un flusso di comparatori. Voglio applicare tutti i comparatori sullo stream usando "thenComparing" (Multisort) Esiste un modo più elegante del seguente codice per ottenere questo?

Stream unsorted = ...; 
Stream<Comparator> comparators = ...; 

Comparator compareFunc = comparators.reduce(null, (a, b) -> { 
     if(a == null) { 
      return b; 
     }else { 
      return a.thenComparing(b); 
     } 

    }); 

Stream result = unsorted.sorted(compareFunc); 

Answer 1

Non utilizzare un valore di identità per s. Se il flusso comparators è vuoto (cioè non contiene alcuna Comparator) non si dovrebbe sorta:

Stream result=comparators.reduce(Comparator::thenComparing) 
      .map(unsorted::sorted).orElse(unsorted); 

Si noti che se il flusso comparators contiene un solo Comparator, che Comparator sarà il risultato della riduzione.

---

Il riferimento metodo passato a Optional.map potrebbe aver bisogno di una certa esperienza per abituarsi ad esso. Quindi, forse vale la pena utilizzare la sintassi lambda più prolisso per mostrare ciò che sta succedendo lì:

Stream<String> result=comparators.reduce(Comparator::thenComparing) 
    .map((comparator) -> unsorted.sorted(comparator)).orElse(unsorted); 

Questa è una questione di stile di programmazione o di preferenze personali e potrebbe cambiare nel tempo.

Answer 2

Utilizzando suggerimento Mark Peters' e mescolandolo con un riferimento metodo, si potrebbe scrivere il confronto in questo modo:

Comparator compareFunc = comparators.reduce((a, b) -> 0, Comparator::thenComparing); 

o rubare un po 'da Holger invece:

Optional<Comparator> compareFunc = comparators.reduce(Comparator::thenComparing); 
Stream<?> result = compareFunc.isPresent() ? result.sorted(compareFunc.get()) 
              : unsorted;