Ritorno da lambda forEach () in java

Sto cercando di cambiare alcuni cicli for-each in lambda forEach()-methods per scoprire le possibilità delle espressioni lambda. Sembra possibile quanto segue:

ArrayList<Player> playersOfTeam = new ArrayList<Player>();      
for (Player player : players) {
    if (player.getTeam().equals(teamName)) {
        playersOfTeam.add(player);
    }
}

Con lambda forEach()

players.forEach(player->{if (player.getTeam().equals(teamName)) {playersOfTeam.add(player);}});

Ma il prossimo non funziona:

for (Player player : players) {
    if (player.getName().contains(name)) {
        return player;
    }
}

con lambda

players.forEach(player->{if (player.getName().contains(name)) {return player;}});

C'è qualcosa di sbagliato nella sintassi dell'ultima riga o è impossibile tornare dal forEach()metodo?

Il returnritorno dall'espressione lambda invece che dal metodo contenitore. Invece di forEachaver bisogno filterdello stream:

players.stream().filter(player -> player.getName().contains(name))
       .findFirst().orElse(null);

Qui filterlimita il flusso a quegli elementi che corrispondono al predicato e findFirstquindi restituisce un Optionalcon la prima voce corrispondente.

Questo sembra meno efficiente dell'approccio for-loop, ma in realtà findFirst()può cortocircuitare: non genera l'intero flusso filtrato e quindi estrae un elemento da esso, piuttosto filtra solo tutti gli elementi necessari per trova il primo corrispondente. Puoi anche usare findAny()invece di findFirst()se non ti interessa necessariamente ottenere il primo giocatore corrispondente dallo stream (ordinato) ma semplicemente qualsiasi elemento corrispondente. Ciò consente una migliore efficienza quando è coinvolto il parallelismo.

Ti suggerisco di provare prima a capire Java 8 in tutto il quadro, soprattutto nel tuo caso saranno stream, lambda e riferimenti a metodi.

Non dovresti mai convertire il codice esistente in codice Java 8 riga per riga, dovresti estrarre le funzionalità e convertirle.

Quello che ho identificato nel tuo primo caso è il seguente:

• Si desidera aggiungere elementi di una struttura di input a un elenco di output se corrispondono a un predicato.

Vediamo come lo facciamo, possiamo farlo con quanto segue:

List<Player> playersOfTeam = players.stream()
    .filter(player -> player.getTeam().equals(teamName))
    .collect(Collectors.toList());

Quello che fai qui è:

1. Trasforma la tua struttura di input in un flusso (presumo che qui sia di tipo Collection<Player>, ora hai un file Stream<Player>.
2. Filtra tutti gli elementi indesiderati con un Predicate<Player>, mappando ogni giocatore sul booleano true se desideri mantenerlo.
3. Raccogli gli elementi risultanti in un elenco, tramite a Collector, qui possiamo usare uno dei raccoglitori di libreria standard, che è Collectors.toList().

Questo include anche altri due punti:

1. Codice contro interfacce, quindi codice contro List<E>oltre ArrayList<E>.
2. Usa l'inferenza del diamante per il parametro del tipo in new ArrayList<>(), dopotutto stai usando Java 8.

Ora sul secondo punto:

Ancora una volta vuoi convertire qualcosa del vecchio Java in Java 8 senza guardare il quadro più grande. Questa parte ha già ricevuto risposta da @IanRoberts , anche se penso che tu debba fare players.stream().filter(...)...ciò che ha suggerito.

Se vuoi restituire un valore booleano, puoi usare qualcosa di simile (molto più veloce del filtro):

players.stream().anyMatch(player -> player.getName().contains(name));

Questo mi ha aiutato:

List<RepositoryFile> fileList = response.getRepositoryFileList();
RepositoryFile file1 = fileList.stream().filter(f -> f.getName().contains("my-file.txt")).findFirst().orElse(null);

Tratto da Java 8 Finding Specific Element in List with Lambda

Puoi anche generare un'eccezione:

Nota:

Per motivi di leggibilità, ogni passaggio del flusso dovrebbe essere elencato in una nuova riga.

players.stream()
       .filter(player -> player.getName().contains(name))
       .findFirst()
       .orElseThrow(MyCustomRuntimeException::new);

se la tua logica è vagamente "guidata dalle eccezioni", ad esempio c'è un punto nel codice che cattura tutte le eccezioni e decide cosa fare dopo. Usa lo sviluppo guidato dalle eccezioni solo quando puoi evitare di sporcare la tua base di codice con multipli try-catche lanciare queste eccezioni sono per casi molto speciali che ti aspetti e possono essere gestiti correttamente.)