Considere el siguiente código:

urls.stream()
    .flatMap(url -> fetchDataFromInternet(url).stream())
    .filter(...)
    .findFirst()
    .get();

SeráfetchDataFromInternet ser llamado para la segunda url cuando la primera fue suficiente?

Intenté con un ejemplo más pequeño y parece funcionar como se esperaba. Es decir, procesa los datos uno por uno, pero ¿se puede confiar en este comportamiento? Si no, llama.sequential() antes de.flatMap(...) ¿ayuda?

    Stream.of("one", "two", "three")
            .flatMap(num -> {
                System.out.println("Processing " + num);
                // return FetchFromInternetForNum(num).data().stream();
                return Stream.of(num);
            })
            .peek(num -> System.out.println("Peek before filter: "+ num))
            .filter(num -> num.length() > 0)
            .peek(num -> System.out.println("Peek after filter: "+ num))
            .forEach(num -> {
                System.out.println("Done " + num);
            });

Salida:

Processing one
Peek before filter: one
Peek after filter: one
Done one
Processing two
Peek before filter: two
Peek after filter: two
Done two
Processing three
Peek before filter: three
Peek after filter: three
Done three

Actualizar: Uso de Oracle JDK8 oficial si eso importa en la implementación

Responder: Según los comentarios y las respuestas a continuación, flatmap es parcialmente vago. es decir, lee la primera transmisión por completo y solo cuando es necesario, pasa a la siguiente. Leer una secuencia es ansioso, pero leer varias secuencias es vago.

Si se pretende este comportamiento, la API debe permitir que la función devuelva unIterable en lugar de una corriente

En otras palabras:enlazar