Encuentra el primer elemento por predicado

Acabo de comenzar a jugar con Java 8 lambdas y estoy tratando de implementar algunas de las cosas a las que estoy acostumbrado en lenguajes funcionales.

Por ejemplo, la mayoría de los lenguajes funcionales tienen algún tipo de función de búsqueda que opera en secuencias o listas que devuelve el primer elemento, para el cual está el predicado true. La única forma en que puedo ver para lograr esto en Java 8 es:

lst.stream()
    .filter(x -> x > 5)
    .findFirst()

Sin embargo, esto me parece ineficiente, ya que el filtro escaneará toda la lista, al menos a mi entender (lo que podría estar mal). ¿Hay una mejor manera?

No, el filtro no escanea todo el flujo. Es una operación intermedia, que devuelve una secuencia diferida (en realidad, todas las operaciones intermedias devuelven una secuencia diferida). Para convencerte, simplemente puedes hacer la siguiente prueba:

List<Integer> list = Arrays.asList(1, 10, 3, 7, 5);
int a = list.stream()
            .peek(num -> System.out.println("will filter " + num))
            .filter(x -> x > 5)
            .findFirst()
            .get();
System.out.println(a);

Qué salidas:

will filter 1
will filter 10
10

Verá que solo los dos primeros elementos de la secuencia se procesan realmente.

Entonces puedes seguir con tu enfoque, que está perfectamente bien.

Sin embargo, esto me parece ineficiente, ya que el filtro escaneará toda la lista

No, no se "romperá" tan pronto como se encuentre el primer elemento que satisfaga el predicado. Puede leer más sobre la pereza en el paquete de transmisión javadoc , en particular (énfasis mío):

Muchas operaciones de flujo, como el filtrado, el mapeo o la eliminación de duplicados, se pueden implementar de manera perezosa, exponiendo oportunidades para la optimización. Por ejemplo, "encontrar la primera cadena con tres vocales consecutivas" no necesita examinar todas las cadenas de entrada. Las operaciones de flujo se dividen en operaciones intermedias (producción de flujo) y operaciones terminales (producción de valor o efecto secundario). Las operaciones intermedias son siempre flojas.

return dataSource.getParkingLots()
                 .stream()
                 .filter(parkingLot -> Objects.equals(parkingLot.getId(), id))
                 .findFirst()
                 .orElse(null);

Tuve que filtrar solo un objeto de una lista de objetos. Así que usé esto, espero que ayude.

Además de la respuesta de Alexis C , si está trabajando con una lista de matriz, en la que no está seguro de si el elemento que está buscando existe, utilícelo.

Integer a = list.stream()
                .peek(num -> System.out.println("will filter " + num))
                .filter(x -> x > 5)
                .findFirst()
                .orElse(null);

Entonces puedes simplemente verificar si un es null.

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

// Stream is ~30 times slower for same operation...
public class StreamPerfTest {

    int iterations = 100;
    List<Integer> list = Arrays.asList(1, 10, 3, 7, 5);


    // 55 ms
    @Test
    public void stream() {

        for (int i = 0; i < iterations; i++) {
            Optional<Integer> result = list.stream()
                    .filter(x -> x > 5)
                    .findFirst();

            System.out.println(result.orElse(null));
        }
    }

    // 2 ms
    @Test
    public void loop() {

        for (int i = 0; i < iterations; i++) {
            Integer result = null;
            for (Integer walk : list) {
                if (walk > 5) {
                    result = walk;
                    break;
                }
            }
            System.out.println(result);
        }
    }
}

Respuesta mejorada de One-Liner: si está buscando un valor de retorno booleano, podemos hacerlo mejor agregando isPresent:

return dataSource.getParkingLots().stream().filter(parkingLot -> Objects.equals(parkingLot.getId(), id)).findFirst().isPresent();