Impara Calcolo delle Statistiche dello Stream con count(), max() e min()

Nella programmazione, spesso è necessario contare il numero di elementi in una collezione oppure trovare i valori minimo e massimo tra essi.

Tuttavia, i programmatori di solito non scrivono algoritmi personalizzati per questi compiti, poiché esistono già metodi integrati. La Stream API offre metodi pratici per lavorare con le collezioni, consentendo di eseguire calcoli sugli elementi dello stream.

Tra questi metodi ci sono count(), max() e min(), che permettono di determinare il numero di elementi e trovare i valori più grande e più piccolo.

Il metodo count()

Il metodo count() restituisce il numero di elementi in uno stream. Viene spesso utilizzato quando è necessario determinare la dimensione di una collezione dopo aver filtrato i dati.

long count();

Non richiede parametri e restituisce un tipo primitivo long.

Esempio pratico

In un negozio online, è necessario contare il numero di prodotti con uno sconto superiore al 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;
    }
}

In questo esempio, il metodo filter() seleziona i prodotti con uno sconto superiore al 20%, e count() determina la loro quantità.

Il metodo max()

Il metodo max() restituisce l'elemento massimo in uno stream in base a un determinato Comparator. Se lo stream è vuoto, restituisce Optional.empty().

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

Esempio pratico

Individuazione del prodotto più costoso in un negozio online per promuoverlo come prodotto premium.

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;
    }
}

In questo codice, Comparator.comparing(Product::getPrice) confronta i prodotti in base al prezzo e max() seleziona quello più costoso.

Il metodo min()

Il metodo min() è simile a max(), ma restituisce l’elemento più piccolo in uno stream in base a un determinato Comparator.

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

Esempio pratico

Individuare il prodotto con la quantità di scorte più bassa per valutare la necessità di riordino.

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;
    }
}

Questo codice individua il prodotto con la quantità di magazzino più bassa utilizzando il metodo min() e Comparator.comparing(Product::getStock).

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 8

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you show me code examples for these methods?

What is the difference between count(), max(), and min() in terms of their return types?

How do I use these methods with custom objects like Product?

Awesome!

Completion rate improved to 2.33

Scorri per mostrare il menu

Nella programmazione, spesso è necessario contare il numero di elementi in una collezione oppure trovare i valori minimo e massimo tra essi.

Tra questi metodi ci sono count(), max() e min(), che permettono di determinare il numero di elementi e trovare i valori più grande e più piccolo.

Il metodo count()

long count();

Non richiede parametri e restituisce un tipo primitivo long.

Esempio pratico

In un negozio online, è necessario contare il numero di prodotti con uno sconto superiore al 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;
    }
}

In questo esempio, il metodo filter() seleziona i prodotti con uno sconto superiore al 20%, e count() determina la loro quantità.

Il metodo max()

Il metodo max() restituisce l'elemento massimo in uno stream in base a un determinato Comparator. Se lo stream è vuoto, restituisce Optional.empty().

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

Esempio pratico

Individuazione del prodotto più costoso in un negozio online per promuoverlo come prodotto premium.

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;
    }
}

In questo codice, Comparator.comparing(Product::getPrice) confronta i prodotti in base al prezzo e max() seleziona quello più costoso.

Il metodo min()

Il metodo min() è simile a max(), ma restituisce l’elemento più piccolo in uno stream in base a un determinato Comparator.

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

Esempio pratico

Individuare il prodotto con la quantità di scorte più bassa per valutare la necessità di riordino.

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;
    }
}

Questo codice individua il prodotto con la quantità di magazzino più bassa utilizzando il metodo min() e Comparator.comparing(Product::getStock).

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 8