È un antipattern usare peek () per modificare un elemento stream?

Supponiamo di avere un flusso di cose e che voglio "arricchirle" a metà flusso, che posso usare peek()per fare questo, ad esempio:

streamOfThings.peek(this::thingMutator).forEach(this::someConsumer);

Supponiamo che la mutazione delle cose a questo punto nel codice sia un comportamento corretto - ad esempio, il thingMutatormetodo può impostare il campo "lastProcessed" sull'ora corrente.

Tuttavia, peek()nella maggior parte dei contesti significa "guardare, ma non toccare".

L'uso peek()per mutare gli elementi del flusso è un antipattern o sconsiderato?

Modificare:

L'approccio alternativo, più convenzionale, sarebbe quello di convertire il consumatore:

private void thingMutator(Thing thing) {
    thing.setLastProcessed(System.currentTimeMillis());
}

a una funzione che restituisce il parametro:

private Thing thingMutator(Thing thing) {
    thing.setLastProcessed(currentTimeMillis());
    return thing;
}

e usa map()invece:

stream.map(this::thingMutator)...

Ma questo introduce il codice superficiale (il return) e non sono convinto che sia più chiaro, perché sai peek()restituisce lo stesso oggetto, ma con map()un colpo d'occhio non è nemmeno chiaro che è la stessa classe di oggetti.

Inoltre, con peek()te puoi avere una lambda che muta, ma con map()te devi costruire un disastro ferroviario. Confrontare:

stream.peek(t -> t.setLastProcessed(currentTimeMillis())).forEach(...)
stream.map(t -> {t.setLastProcessed(currentTimeMillis()); return t;}).forEach(...)

Penso che la peek()versione sia più chiara e che la lambda sia chiaramente mutante, quindi non c'è alcun effetto "misterioso". Allo stesso modo, se viene utilizzato un riferimento al metodo e il nome del metodo implicava chiaramente una mutazione, anche questo è chiaro e ovvio.

Su una nota personale, non esito a usare peek()per mutare - lo trovo molto conveniente.

Hai ragione, "sbirciare" nel senso inglese della parola significa "guarda, ma non toccare".

Tuttavia le JavaDoc stati:

sbirciare

Stream peek (azione del consumatore)

Restituisce un flusso costituito dagli elementi di questo flusso, eseguendo inoltre l'azione fornita su ciascun elemento quando gli elementi vengono consumati dal flusso risultante.

Parole chiave: "performing ... action" e "consumed". JavaDoc è molto chiaro che dovremmo aspettarci peekdi avere la possibilità di modificare il flusso.

Tuttavia JavaDoc afferma anche:

Nota API:

Questo metodo esiste principalmente per supportare il debug, in cui si desidera vedere gli elementi mentre passano oltre un certo punto in una pipeline

Ciò indica che è destinato maggiormente all'osservazione, ad esempio la registrazione di elementi nel flusso.

Ciò che prendo da tutto ciò è che possiamo eseguire azioni usando gli elementi nel flusso, ma dovremmo evitare di mutare gli elementi nel flusso. Ad esempio, vai avanti e chiama i metodi sugli oggetti, ma cerca di evitare operazioni di mutazione su di essi.

Come minimo, aggiungerei un breve commento al tuo codice seguendo queste linee:

// Note: this peek() call will modify the Things in the stream.
streamOfThings.peek(this::thingMutator).forEach(this::someConsumer);

Le opinioni differiscono sull'utilità di tali commenti, ma vorrei usare un commento del genere in questo caso.

Potrebbe essere facilmente frainteso, quindi eviterei di usarlo in questo modo. Probabilmente l'opzione migliore è usare una funzione lambda per unire le due azioni necessarie nella chiamata forEach. Puoi anche considerare di restituire un nuovo oggetto piuttosto che mutare quello esistente: potrebbe essere leggermente meno efficiente, ma è probabile che si traduca in un codice più leggibile e riduce il potenziale dell'utilizzo accidentale dell'elenco modificato per un'altra operazione che dovrebbe ho ricevuto l'originale.

La nota API ci dice che il metodo è stato aggiunto principalmente per azioni come il debug / registrazione / attivazione statistiche ecc.

@apiNote Questo metodo esiste principalmente per supportare il debug, in cui si desidera * vedere gli elementi mentre passano oltre un certo punto in una pipeline: *

       {@codice
     * Stream.of ("uno", "due", "tre", "quattro")
     * .filter (e -> e.length ()> 3)
     * .peek (e -> System.out.println ("Valore filtrato:" + e))
     * .map (String :: toUpperCase)
     * .peek (e -> System.out.println ("Valore mappato:" + e))
     * .collect (Collectors.toList ());
     *}