Trova il primo elemento per predicato

Ho appena iniziato a giocare con Java 8 lambdas e sto cercando di implementare alcune delle cose a cui sono abituato nei linguaggi funzionali.

Ad esempio, la maggior parte dei linguaggi funzionali ha un qualche tipo di funzione find che opera su sequenze o elenchi che restituiscono il primo elemento, per cui è il predicato true. L'unico modo che posso vedere per raggiungere questo obiettivo in Java 8 è:

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

Tuttavia, questo mi sembra inefficiente, poiché il filtro analizzerà l'intero elenco, almeno per quanto ne so (che potrebbe essere sbagliato). Esiste un modo migliore?

No, il filtro non esegue la scansione dell'intero flusso. È un'operazione intermedia, che restituisce un flusso pigro (in realtà tutte le operazioni intermedie restituiscono un flusso pigro). Per convincerti, puoi semplicemente fare il seguente test:

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

Quali uscite:

will filter 1
will filter 10
10

Vedi che solo i primi due elementi del flusso vengono effettivamente elaborati.

Quindi puoi andare con il tuo approccio che è perfettamente bene.

Tuttavia, questo mi sembra inefficiente, poiché il filtro eseguirà la scansione dell'intero elenco

No non lo farà - si "spezzerà" non appena viene trovato il primo elemento che soddisfa il predicato. Puoi leggere di più sulla pigrizia nel pacchetto stream javadoc , in particolare (sottolineatura mia):

Molte operazioni di streaming, come filtraggio, mappatura o rimozione di duplicati, possono essere implementate pigramente, esponendo opportunità di ottimizzazione. Ad esempio, "trova la prima stringa con tre vocali consecutive" non è necessario esaminare tutte le stringhe di input. Le operazioni di flusso sono suddivise in operazioni intermedie (che producono flusso) e operazioni terminali (che producono valore o effetti collaterali). Le operazioni intermedie sono sempre pigre.

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

Ho dovuto filtrare solo un oggetto da un elenco di oggetti. Quindi l'ho usato, spero che sia d'aiuto.

Oltre alla risposta di Alexis C , se stai lavorando con un elenco di array, in cui non sei sicuro che l'elemento che stai cercando esista, usa questo.

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

Allora si potrebbe semplicemente verificare se un è 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);
        }
    }
}

Risposta One-Liner migliorata: se stai cercando un valore di ritorno booleano, possiamo farlo meglio aggiungendo isPresent:

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