Trouver le premier élément par prédicat

Je viens de commencer à jouer avec les lambdas Java 8 et j'essaie d'implémenter certaines des choses auxquelles je suis habitué dans les langages fonctionnels.

Par exemple, la plupart des langages fonctionnels ont une sorte de fonction de recherche qui opère sur des séquences, ou des listes qui renvoie le premier élément, pour lequel le prédicat est true. La seule façon que je peux voir pour y parvenir dans Java 8 est:

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

Cependant, cela me semble inefficace, car le filtre analysera toute la liste, du moins à ma connaissance (ce qui pourrait être faux). Y a-t-il une meilleure façon?

Non, le filtre n'analyse pas l'intégralité du flux. Il s'agit d'une opération intermédiaire, qui renvoie un flux paresseux (en fait, toutes les opérations intermédiaires renvoient un flux paresseux). Pour vous convaincre, vous pouvez simplement faire le test suivant:

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

Quelles sorties:

will filter 1
will filter 10
10

Vous voyez que seuls les deux premiers éléments du flux sont réellement traités.

Vous pouvez donc suivre votre approche qui est parfaitement bien.

Cependant cela me semble inefficace, car le filtre va parcourir toute la liste

Non, il ne le fera pas - il "se cassera" dès que le premier élément satisfaisant le prédicat sera trouvé. Vous pouvez en savoir plus sur la paresse dans le package de flux javadoc , en particulier (c'est moi qui souligne):

De nombreuses opérations de flux, telles que le filtrage, le mappage ou la suppression des doublons, peuvent être implémentées paresseusement, ce qui expose les opportunités d'optimisation. Par exemple, "trouver la première chaîne avec trois voyelles consécutives" n'a pas besoin d'examiner toutes les chaînes d'entrée. Les opérations de flux sont divisées en opérations intermédiaires (génératrices de flux) et opérations terminales (génératrices de valeur ou d'effets secondaires). Les opérations intermédiaires sont toujours paresseuses.

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

J'ai dû filtrer un seul objet d'une liste d'objets. J'ai donc utilisé cela, j'espère que cela aide.

En plus de la réponse d' Alexis C , si vous travaillez avec une liste de tableaux dans laquelle vous ne savez pas si l'élément que vous recherchez existe, utilisez ceci.

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

Ensuite, vous pouvez simplement vérifier si un est 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);
        }
    }
}

Réponse One-Liner améliorée: Si vous recherchez une valeur de retour booléenne, nous pouvons le faire mieux en ajoutant isPresent:

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