Lære Beregning av Strømstatistikk med count(), max() og min()

Sveip for å vise menyen

I programmering er det ofte nødvendig å telle antall elementer i en samling eller finne minimums- og maksimumsverdier blant dem.

Vanligvis skriver ikke utviklere egne algoritmer for slike oppgaver, siden det allerede finnes innebygde metoder. Stream API tilbyr praktiske metoder for å arbeide med samlinger, og muliggjør beregninger på strømmelementer.

Blant disse metodene finner vi count(), max() og min(), som hjelper med å bestemme antall elementer og finne de største og minste verdiene.

Metoden count()

Metoden count() returnerer antall elementer i en strøm. Den brukes ofte når det er behov for å finne størrelsen på en samling etter filtrering av data.

long count();

Den tar ingen parametere og returnerer en primitiv long-type.

Praktisk eksempel

I en nettbutikk er det behov for å telle antall produkter med en rabatt på over 20%.

Main.java


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 15.0),
                new Product("Smartphone", 25.0),
                new Product("Tablet", 30.0)
        );

        long discountedProducts = products.stream()
                .filter(product -> product.getDiscount() > 20.0)
                .count();

        System.out.println("Number of products with more than 20% discount: " + discountedProducts);
    }
}

class Product {
    private String name;
    private double discount;

    public Product(String name, double discount) {
        this.name = name;
        this.discount = discount;
    }

    public double getDiscount() {
        return discount;
    }
}

I dette eksempelet velger filter()-metoden produkter med en rabatt større enn 20%, og count() fastslår deres antall.

Metoden max()

Metoden max() returnerer det største elementet i en strøm basert på en gitt Comparator. Hvis strømmen er tom, returnerer den Optional.empty().

Optional<T> max(Comparator<? super T> comparator);

Praktisk eksempel

Finn det dyreste produktet i en nettbutikk for å promotere det som et premiumprodukt.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940
            
package com.example;

import java.util.List;
import java.util.Optional;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Smartphone", 800.0),
                new Product("Tablet", 600.0)
        );

        Optional<Product> mostExpensiveProduct = products.stream()
                .max(Comparator.comparing(Product::getPrice));

        mostExpensiveProduct.ifPresent(product ->
                System.out.println("Most expensive product: " + product.getName() + " - $" + product.getPrice())
        );
    }
}

class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public String getName() {
        return name;
    }
}

I denne koden sammenligner Comparator.comparing(Product::getPrice) produkter etter pris, og max() velger det dyreste.

Metoden min()

Metoden min() ligner på max(), men returnerer det minste elementet i en strøm basert på en gitt Comparator.

Optional<T> min(Comparator<? super T> comparator);

Praktisk eksempel

Finn produktet med lavest lagerbeholdning for å vurdere behovet for påfylling.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637383940
            
package com.example;

import java.util.List;
import java.util.Optional;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 5),
                new Product("Smartphone", 0),
                new Product("Tablet", 2)
        );

        Optional<Product> leastStockProduct = products.stream()
                .min(Comparator.comparing(Product::getStock));

        leastStockProduct.ifPresent(product ->
                System.out.println("Product with the lowest stock: " + product.getName() + " - " + product.getStock() + " units")
        );
    }
}

class Product {
    private String name;
    private int stock;

    public Product(String name, int stock) {
        this.name = name;
        this.stock = stock;
    }

    public int getStock() {
        return stock;
    }

    public String getName() {
        return name;
    }
}

Denne koden identifiserer produktet med lavest lagerbeholdning ved å bruke min()-metoden og Comparator.comparing(Product::getStock).

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 34

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 1. Kapittel 34