Encontre o primeiro elemento por predicado

Acabei de começar a jogar com o Java 8 lambdas e estou tentando implementar algumas das coisas com as quais estou acostumado nas linguagens funcionais.

Por exemplo, a maioria das linguagens funcionais possui algum tipo de função find que opera em seqüências ou listas que retornam o primeiro elemento, para o qual o predicado é true. A única maneira de conseguir isso no Java 8 é:

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

No entanto, isso me parece ineficiente, pois o filtro varrerá a lista inteira, pelo menos para minha compreensão (o que pode estar errado). Existe uma maneira melhor?

Não, o filtro não varre o fluxo inteiro. É uma operação intermediária, que retorna um fluxo lento (na verdade, todas as operações intermediárias retornam um fluxo lento). Para convencê-lo, você pode simplesmente fazer o seguinte teste:

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

Quais saídas:

will filter 1
will filter 10
10

Você vê que apenas os dois primeiros elementos do fluxo são realmente processados.

Então você pode seguir sua abordagem, o que é perfeitamente correto.

No entanto, isso me parece ineficiente, pois o filtro varrerá a lista inteira

Não, não vai - ele irá "quebrar" assim que o primeiro elemento que satisfizer o predicado for encontrado. Você pode ler mais sobre preguiça no pacote stream javadoc , em particular (ênfase minha):

Muitas operações de fluxo, como filtragem, mapeamento ou remoção duplicada, podem ser implementadas com preguiça, expondo oportunidades de otimização. Por exemplo, "encontre a primeira String com três vogais consecutivas" não precisa examinar todas as strings de entrada. As operações de fluxo são divididas em operações intermediárias (produção de fluxo) e operações terminais (produção de valor ou efeito colateral). Operações intermediárias são sempre preguiçosas.

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

Eu tive que filtrar apenas um objeto de uma lista de objetos. Então eu usei isso, espero que ajude.

Além da resposta de Alexis C , se você estiver trabalhando com uma lista de matrizes, na qual não tem certeza se o elemento que está procurando existe, use-o.

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

Então você pode simplesmente verificar se um é 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);
        }
    }
}

Resposta aprimorada de uma linha: se você estiver procurando por um valor de retorno booleano, podemos fazer isso melhor adicionando isPresent:

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