Considere o seguinte código:

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

VaifetchDataFromInternet ser chamado para o segundo URL quando o primeiro foi suficiente?

Eu tentei com um exemplo menor e parece que funciona como esperado. ou seja, processa os dados um por um, mas é possível confiar nesse comportamento? Caso contrário, chama.sequential() antes.flatMap(...) Socorro?

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

Resultado:

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

Atualizar: Usando o Oracle JDK8 oficial, se isso importa na implementação

Responda: Com base nos comentários e nas respostas abaixo, o flatmap é parcialmente preguiçoso. ou seja, lê o primeiro fluxo completamente e somente quando necessário, segue para o próximo. A leitura de um fluxo está ansiosa, mas a leitura de vários fluxos é preguiçosa.

Se esse comportamento for pretendido, a API deve deixar a função retornar umIterable em vez de um fluxo.

Em outras palavras:ligação