Retorno de lambda forEach () en java

Estoy tratando de cambiar algunos bucles for-each a forEach()métodos lambda para descubrir las posibilidades de las expresiones lambda. Parece posible lo siguiente:

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);}});

Pero el siguiente no funciona:

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

con lambda

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

¿Hay algún error en la sintaxis de la última línea o es imposible regresar del forEach()método?

El returnno está regresando de la expresión lambda en lugar de a partir del método que contiene. En lugar de forEachnecesitar filterla transmisión:

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

Aquí filterrestringe la secuencia a aquellos elementos que coinciden con el predicado y findFirstluego devuelve un Optionalcon la primera entrada coincidente.

Esto parece menos eficiente que el enfoque de bucle for, pero de hecho findFirst()puede provocar un cortocircuito: no genera todo el flujo filtrado y luego extrae un elemento de él, sino que filtra solo tantos elementos como sea necesario para encuentra el primero que coincida. También puede usar en findAny()lugar de findFirst()si no necesariamente le importa obtener el primer reproductor coincidente de la transmisión (ordenada), sino simplemente cualquier elemento coincidente. Esto permite una mejor eficiencia cuando hay paralelismo involucrado.

Le sugiero que primero intente comprender Java 8 en su totalidad, lo más importante en su caso serán los flujos, las lambdas y las referencias a métodos.

Usted debe no convertir el código existente para Java 8 código en una base de línea por línea, se debe extraer y convertir los rasgos.

Lo que identifiqué en su primer caso es lo siguiente:

• Desea agregar elementos de una estructura de entrada a una lista de salida si coinciden con algún predicado.

Veamos cómo lo hacemos, podemos hacerlo con lo siguiente:

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

Lo que haces aquí es:

1. Convierta su estructura de entrada en una secuencia (supongo que aquí es de tipo Collection<Player>, ahora tiene un archivo Stream<Player>.
2. Filtre todos los elementos no deseados con un Predicate<Player>, mapeando cada jugador al booleano verdadero si desea que se mantenga.
3. Recopile los elementos resultantes en una lista, a través de a Collector, aquí podemos usar uno de los recopiladores de bibliotecas estándar, que es Collectors.toList().

Esto también incorpora otros dos puntos:

1. Codifique contra interfaces, entonces codifique contra List<E>over ArrayList<E>.
2. Use la inferencia de diamante para el parámetro de tipo en new ArrayList<>(), después de todo, está usando Java 8.

Ahora en su segundo punto:

Una vez más, desea convertir algo de Java heredado a Java 8 sin mirar el panorama general. Esta parte ya ha sido respondida por @IanRoberts , aunque creo que debes hacer players.stream().filter(...)...lo que sugirió.

Si desea devolver un valor booleano, puede usar algo como esto (mucho más rápido que el filtro):

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

Esto es lo que me ayudó:

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

Tomado de Java 8 Búsqueda de elementos específicos en una lista con Lambda

También puede lanzar una excepción:

Nota:

En aras de la legibilidad, cada paso del flujo debe aparecer en una nueva línea.

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

si su lógica está vagamente "impulsada por excepciones", por ejemplo, hay un lugar en su código que detecta todas las excepciones y decide qué hacer a continuación. Solo use el desarrollo impulsado por excepciones cuando pueda evitar ensuciar su base de código con múltiples try-catchy lanzar estas excepciones son para casos muy especiales que espera y se pueden manejar correctamente).