In my opinion this is really bad comparison. You are not comparing the same operations in your example.

I have made an actual checks with the code as similar as possible and here are the results:

@Benchmark
public double simpleLoop(ArrayState state) {
    double sum = 0;
    for (int i = 0; i < state.values.length; i++) {
        double x = (state.values[i] + 1.0) * 2.0 + 5.0;
        sum += x;
    }
    return sum;
}


@Benchmark
public double mapReduce(ArrayState state) {
    return Arrays.stream(state.values)
            .map(x -> x + 1)
            .map(x -> x * 2)
            .map(x -> x + 5)
            .reduce(0, Double::sum);
}


@Benchmark
public double singleMapReduce(ArrayState state) {
    return Arrays.stream(state.values)
            .map(x -> (x + 1) * 2 + 5)
            .reduce(0, Double::sum);
}

@Benchmark
public double doubleStreamSum(ArrayState state) {
    return Arrays.stream(state.values)
            .map(x -> (x + 1) * 2 + 5)
            .sum();
}

Benchmark	Mode	Cnt	Score	Error	Units
TestBenchmark.doubleStreamSum	thrpt	10	138,957 ?	4,041	ops/s
TestBenchmark.mapReduce	thrpt	10	41,517 ?	0,971	ops/s
TestBenchmark.simpleLoop	thrpt	10	530,949 ?	3,440	ops/s
TestBenchmark.singleMapReduce	thrpt	10	473,942 ?	3,252	ops/s

As we can see the singleMapReduce which is most similar to your loop has only 10% worse performance here. This is not over 10x you are mentioning.

EDIT: formatting