Por que existe tanta diferença de performance entre stream e loops normais?

Estava lendo um artigo relacionado à performance das streams/loops, e me assustei com a diferença de performance entre a utilização de loops em relação à grandes quantidades de dados.

Resolvi realizar um teste rápido utilizando o seguinte código:

public static void main(String[] args) {
    final int limite = 10_000;

    long inicioFor = System.currentTimeMillis();

    for(int i = 0; i < limite; i++) {
        System.out.println(i);
    }

    long terminoFor = System.currentTimeMillis();

    long inicioStream = System.currentTimeMillis();

    IntStream.range(0, limite).forEach(System.out::println);

    long terminoStream = System.currentTimeMillis();

    System.out.println();
    System.out.println("Usando for: " + (terminoFor - inicioFor) );
    System.out.println("Usando stream: " + (terminoStream - inicioStream) );
}

É um código relativamente simples, porém notei uma coisa interessante:

1. Quando o limite é definido com valor 10_000, o tempo resultante é o seguinte:

Usando for: 54
Usando stream: 72

2. Quando o limite é definido com valor 1_000_000, a stream é relativamente mais rápida:

Usando for: 4314
Usando stream: 4202

Entendo que este é um teste simples, sem utilização de ferramentas de benchmark entre outras métricas.

Gostaria de saber o porquê da existência desta diferença de tempo no processamento utilizando streams e loops, posso não estar correto, mas parece que as streams performam melhor quanto maior a quantidade de dados (caminhando para a questão das streams infinitas).

---

Complementando com algumas informações colocadas pelo @Victor, tive resultados extremamente diferentes retirando as operações de IO:

1. Quando o limite é definido com valor 10_000:

Usando for: 0
Usando stream: 36

2. Quando o limite é definido com valor 1_000_000:

Usando for: 2
Usando stream: 43

Conforme apontado também por @Maniero, a razão se deve ser o alto custo para fazer a infraestrutura funcionar de acordo.

import java.util.stream.LongStream;

class Teste {
    public static void main(String[] args) {
        var limite = 50_000_000_000L;
        var x = new long[1];

        var inicioStream1 = System.currentTimeMillis();
        LongStream.range(0, limite).forEach(z -> x[0] = z);
        var terminoStream1 = System.currentTimeMillis();

        var inicioFor1 = System.currentTimeMillis();
        for (var i = 0L; i < limite; i++) {
            x[0] = i;
        }
        var terminoFor1 = System.currentTimeMillis();

        var inicioStream2 = System.currentTimeMillis();
        LongStream.range(0, limite).forEach(z -> x[0] = z);
        var terminoStream2 = System.currentTimeMillis();

        var inicioFor2 = System.currentTimeMillis();
        for (var i = 0L; i < limite; i++) {
            x[0] = i;
        }
        var terminoFor2 = System.currentTimeMillis();

        System.out.println();
        System.out.println("Usando for: " + (terminoFor1 - inicioFor1));
        System.out.println("Usando stream: " + (terminoStream1 - inicioStream1));
        System.out.println("Usando for outra vez: " + (terminoFor2 - inicioFor2));
        System.out.println("Usando stream outra vez: " + (terminoStream2 - inicioStream2));
    }
}

Usando for: 15169
Usando stream: 18422
Usando for outra vez: 15140
Usando stream outra vez: 18498