Stream vs For в Java: как писать максимально быстрый код

long sum = 0;
for (int i = 0; i < data.length; i++) {
    int x = data[i];
    if (x > 100) {
        sum += x;
    }
}

Arrays.stream(data)
    .filter(x -> x > 100)
    .sum();

List<Integer>

int[] data

long sum = Arrays.stream(data)
    .filter(x -> x > 100)
    .sum();

⚔️ Stream vs For в Java — максимально подробная сравнительная таблица

⚡ Итог:

- For = контроль + максимальная производительность
- Stream = выразительность + удобство

🔥 В Java скорость определяется не стилем, а:
- памятью
- аллокациями
- boxing/unboxing
- cache locality
- JIT inline decisions

⚡ Stream vs Loop - Пример кода с комментариями

import java.util.Arrays;

public class Test {

    static int[] data;

    public static void main(String[] args) {

        int size = 20_000_000;
        data = new int[size];

        // =========================
        // INIT DATA (один раз)
        // =========================
        for (int i = 0; i < size; i++) {
            data[i] = i;
        }

        // =========================
        // WARMUP (очень важно для JVM)
        // =========================
        // JVM ещё НЕ оптимизировала код полностью
        // JIT (Just-In-Time compiler) сейчас:
        // - анализирует hot methods
        // - может заменить bytecode на native code
        // - делает inline оптимизации
        for (int i = 0; i < 5; i++) {
            streamSum(); // прогрев Stream pipeline
            loopSum();   // прогрев обычного цикла
        }

        // =========================
        // TEST ORDER 1: STREAM -> LOOP
        // =========================
        System.out.println("=== ORDER 1: STREAM -> LOOP ===");

        long t1 = System.nanoTime();

        // Stream pipeline:
        // Arrays.stream -> IntPipeline -> lambda filter -> sum
        // создаются промежуточные объекты (пусть и оптимизированные JIT)
        long r1 = streamSum();

        long t2 = System.nanoTime();

        // Loop:
        // прямой доступ к массиву
        // без объектов, без pipeline
        long t3 = System.nanoTime();

        long r2 = loopSum();

        long t4 = System.nanoTime();

        System.out.println("Stream result = " + r1);
        System.out.println("Stream time   = " + (t2 - t1) / 1_000_000 + " ms");

        System.out.println("Loop result   = " + r2);
        System.out.println("Loop time     = " + (t4 - t3) / 1_000_000 + " ms");


        // =========================
        // TEST ORDER 2: LOOP -> STREAM
        // =========================
        System.out.println("\n=== ORDER 2: LOOP -> STREAM ===");

        long t5 = System.nanoTime();

        // теперь Loop выполняется ПЕРВЫМ
        // CPU cache + branch predictor уже могут быть "прогреты"
        long r3 = loopSum();

        long t6 = System.nanoTime();

        long t7 = System.nanoTime();

        // Stream теперь второй
        // может выиграть или проиграть из-за cache state
        long r4 = streamSum();

        long t8 = System.nanoTime();

        System.out.println("Loop result   = " + r3);
        System.out.println("Loop time     = " + (t6 - t5) / 1_000_000 + " ms");

        System.out.println("Stream result = " + r4);
        System.out.println("Stream time   = " + (t8 - t7) / 1_000_000 + " ms");


        // =========================
        // ВАЖНЫЙ МОМЕНТ
        // =========================
        // Даже если код одинаковый:
        // - CPU cache меняется
        // - JIT может уже "inline'ить" loop
        // - branch predictor обучается
        // - GC мог случиться между измерениями
    }

    // =========================
    // STREAM VERSION
    // =========================
    static long streamSum() {
        return Arrays.stream(data)
                // lambda -> может быть:
                // - inline
                // - или вызов через invokedynamic
                .filter(x -> x > 100)
                .sum();
    }

    // =========================
    // LOOP VERSION
    // =========================
    static long loopSum() {

        long sum = 0;

        // прямой for-each:
        // - нет объектов
        // - нет pipeline
        // - минимальный overhead
        for (int x : data) {
            if (x > 100) {
                sum += x;
            }
        }

        return sum;
    }
}

//Ответ
//=== ORDER 1: STREAM -> LOOP ===
//Stream result = 542889414
//Stream time   = 14 ms
//Loop result   = 199999989994950
//Loop time     = 9 ms

//=== ORDER 2: LOOP -> STREAM ===
//Loop result   = 199999989994950
//Loop time     = 9 ms
//Stream result = 542889414
//Stream time   = 15 ms
// ---------------- Итог
//✔ JVM уже прогрелась
//✔ порядок не важен
//✔ результаты стабильные
//✔ Loop быстрее Stream в этом кейсе