Du har med succes refaktoreret koden, hvilket gør den renere, kortere og mere udtryksfuld. Men hvad med ydelse? Hvor effektiv er Stream API sammenlignet med traditionelle løkker? Kan du øge hastigheden ved at bruge parallelStream()? Lad os finde ud af det!

Måling af eksekveringstid

For objektivt at sammenligne ydelse, oprettes et testdatasæt med 100.000 brugere og forskellige ordrer. Derefter implementeres tre filtreringsmetoder:

Traditionel for-loop – en klassisk metode med indlejrede løkker;
Stream API (stream()) – en moderne deklarativ metode;
Parallel Stream API (parallelStream()) – multitrådet behandling.

Eksekveringstiden måles med System.nanoTime(), som giver højpræcise tidsforskelle.

Testimplementering

Der genereres 100.000 brugere, hvor alle har ordrer over $10,000, og alle tre metoder køres for at se, hvilken der klarer sig bedst.

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<User> users = generateUsers(100000);

        // Measuring traditional loop execution time
        long startTime = System.nanoTime();
        List<User> premiumUsersLoop = new ArrayList<>();
        for (User user : users) {
            if (user.isActive()) {
                int totalOrders = 0;
                for (Order order : user.getOrders()) {
                    if (order.getTotal() >= 10000) {
                        totalOrders++;
                    }
                }
                if (totalOrders >= 3) {
                    premiumUsersLoop.add(user);
                }
            }
        }
        long endTime = System.nanoTime();
        System.out.println("For-loop: " + (endTime - startTime) / 1_000_000 + " ms");

        // Measuring Stream API execution time
        startTime = System.nanoTime();
        List<User> premiumUsersStream = users.stream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();
        endTime = System.nanoTime();
        System.out.println("Stream API: " + (endTime - startTime) / 1_000_000 + " ms");

        // Measuring Parallel Stream API execution time
        startTime = System.nanoTime();
        List<User> premiumUsersParallelStream = users.parallelStream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();
        endTime = System.nanoTime();
        System.out.println("Parallel Stream API: " + (endTime - startTime) / 1_000_000 + " ms");
    }

    private static List<User> generateUsers(int count) {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            users.add(new User("User" + i, true, List.of(
                    new Order(14000),
                    new Order(5000),
                    new Order(7000)
            )));
        }
        return users;
    }
}

class Order {
    private final double total;

    public Order(double total) {
        this.total = total;
    }

    public double getTotal() {
        return total;
    }
}

class User {
    private final String name;
    private final boolean active;
    private final List<Order> orders;

    public User(String name, boolean active, List<Order> orders) {
        this.name = name;
        this.active = active;
        this.orders = orders;
    }

    public boolean isActive() {
        return active;
    }

    public List<Order> getOrders() {
        return orders;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "'}";
    }
}

Efter at have kørt testen med 100.000 brugere, kan følgende tendenser observeres:

Traditionel for-loop er hurtigere ved simple operationer, da den undgår overhead fra oprettelse af streams og ekstra objekter. Den yder bedst, når rå hastighed er en prioritet.

Stream API er nogle gange en smule langsommere på grund af ekstra stream-objekter, men forbedrer markant kode-læselighed og vedligeholdelse.

Parallel Stream API kan øge behandlingshastigheden på multi-core systemer, men ikke altid. Hvis datasættet er lille, kan overhead ved trådhåndtering faktisk sænke hastigheden. Den fungerer bedst til tunge beregninger, men ikke ved ændring af delte variabler, da tråde kører uafhængigt.

Resumé

Stream API er et kraftfuldt værktøj, der gør koden mere læsbar og kortfattet. Når det gælder ydelse, er det dog vigtigt at forstå dets begrænsninger. I nogle tilfælde er traditionelle for-løkker hurtigere, især når der arbejdes med små datasæt. parallelStream() kan forbedre behandlingstiden, men det kræver test for at sikre, at det faktisk giver en fordel.

Valget af den rette tilgang bør derfor være bevidst: hvis læsbarhed er en prioritet, brug Stream API; hvis ydelse er afgørende, test og mål!

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?

Var alt klart?

Tak for dine kommentarer!

Sektion 4. Kapitel 2

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 2.33

Stryg for at vise menuen

Måling af eksekveringstid

For objektivt at sammenligne ydelse, oprettes et testdatasæt med 100.000 brugere og forskellige ordrer. Derefter implementeres tre filtreringsmetoder:

Traditionel for-loop – en klassisk metode med indlejrede løkker;
Stream API (stream()) – en moderne deklarativ metode;
Parallel Stream API (parallelStream()) – multitrådet behandling.

Eksekveringstiden måles med System.nanoTime(), som giver højpræcise tidsforskelle.

Testimplementering

Der genereres 100.000 brugere, hvor alle har ordrer over $10,000, og alle tre metoder køres for at se, hvilken der klarer sig bedst.

Main.java


              123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<User> users = generateUsers(100000);

        // Measuring traditional loop execution time
        long startTime = System.nanoTime();
        List<User> premiumUsersLoop = new ArrayList<>();
        for (User user : users) {
            if (user.isActive()) {
                int totalOrders = 0;
                for (Order order : user.getOrders()) {
                    if (order.getTotal() >= 10000) {
                        totalOrders++;
                    }
                }
                if (totalOrders >= 3) {
                    premiumUsersLoop.add(user);
                }
            }
        }
        long endTime = System.nanoTime();
        System.out.println("For-loop: " + (endTime - startTime) / 1_000_000 + " ms");

        // Measuring Stream API execution time
        startTime = System.nanoTime();
        List<User> premiumUsersStream = users.stream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();
        endTime = System.nanoTime();
        System.out.println("Stream API: " + (endTime - startTime) / 1_000_000 + " ms");

        // Measuring Parallel Stream API execution time
        startTime = System.nanoTime();
        List<User> premiumUsersParallelStream = users.parallelStream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();
        endTime = System.nanoTime();
        System.out.println("Parallel Stream API: " + (endTime - startTime) / 1_000_000 + " ms");
    }

    private static List<User> generateUsers(int count) {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            users.add(new User("User" + i, true, List.of(
                    new Order(14000),
                    new Order(5000),
                    new Order(7000)
            )));
        }
        return users;
    }
}

class Order {
    private final double total;

    public Order(double total) {
        this.total = total;
    }

    public double getTotal() {
        return total;
    }
}

class User {
    private final String name;
    private final boolean active;
    private final List<Order> orders;

    public User(String name, boolean active, List<Order> orders) {
        this.name = name;
        this.active = active;
        this.orders = orders;
    }

    public boolean isActive() {
        return active;
    }

    public List<Order> getOrders() {
        return orders;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "'}";
    }
}

Efter at have kørt testen med 100.000 brugere, kan følgende tendenser observeres:

Traditionel for-loop er hurtigere ved simple operationer, da den undgår overhead fra oprettelse af streams og ekstra objekter. Den yder bedst, når rå hastighed er en prioritet.

Stream API er nogle gange en smule langsommere på grund af ekstra stream-objekter, men forbedrer markant kode-læselighed og vedligeholdelse.

Resumé

Valget af den rette tilgang bør derfor være bevidst: hvis læsbarhed er en prioritet, brug Stream API; hvis ydelse er afgørende, test og mål!

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?

Var alt klart?

Tak for dine kommentarer!

Sektion 4. Kapitel 2

Ydeevne i Stream API

Måling af eksekveringstid

Testimplementering

Resumé

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?

Awesome!

Ydeevne i Stream API

Måling af eksekveringstid

Testimplementering

Resumé

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?

Ydeevne i Stream API

Måling af eksekveringstid

Testimplementering

Resumé

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan parallelStream() nedsætte udførelseshastigheden?

Awesome!

Ydeevne i Stream API

Måling af eksekveringstid

Testimplementering

Resumé

1. Hvilken tilgang er typisk den hurtigste til simple operationer?

2. Hvorfor kan Stream API være langsommere end en almindelig løkke?

3. Hvornår kan parallelStream() nedsætte udførelseshastigheden?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?

3. Hvornår kan `parallelStream()` nedsætte udførelseshastigheden?