Aprende Cálculo de Estadísticas de Flujos con count(), max() y min()

En programación, a menudo es necesario contar el número de elementos en una colección o encontrar los valores mínimo y máximo entre ellos.

Sin embargo, los programadores generalmente no escriben algoritmos personalizados para estas tareas, ya que existen métodos integrados. La Stream API proporciona métodos convenientes para trabajar con colecciones, permitiendo realizar cálculos sobre los elementos del stream.

Entre estos métodos se encuentran count(), max() y min(), que ayudan a determinar el número de elementos y a encontrar los valores mayor y menor.

El método count()

El método count() devuelve el número de elementos en un stream. Se utiliza frecuentemente cuando es necesario determinar el tamaño de una colección después de filtrar datos.

long count();

No recibe parámetros y devuelve un tipo primitivo long.

Ejemplo práctico

En una tienda en línea, es necesario contar la cantidad de productos con un descuento superior 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;
    }
}

En este ejemplo, el método filter() selecciona productos con un descuento superior al 20%, y count() determina su cantidad.

El método max()

El método max() devuelve el elemento máximo de un stream según un Comparator dado. Si el stream está vacío, retorna Optional.empty().

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

Ejemplo práctico

Buscar el producto más caro en una tienda en línea para promocionarlo como un producto 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;
    }
}

En este código, Comparator.comparing(Product::getPrice) compara productos por precio, y max() selecciona el más caro.

El método min()

El método min() es similar a max(), pero devuelve el elemento más pequeño en un stream basado en un Comparator dado.

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

Ejemplo práctico

Encontrar el producto con el stock más bajo para evaluar la necesidad de reabastecimiento.

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

Este código identifica el producto con el menor stock utilizando el método min() y Comparator.comparing(Product::getStock).

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 8

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

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

Desliza para mostrar el menú

En programación, a menudo es necesario contar el número de elementos en una colección o encontrar los valores mínimo y máximo entre ellos.

Entre estos métodos se encuentran count(), max() y min(), que ayudan a determinar el número de elementos y a encontrar los valores mayor y menor.

El método count()

long count();

No recibe parámetros y devuelve un tipo primitivo long.

Ejemplo práctico

En una tienda en línea, es necesario contar la cantidad de productos con un descuento superior 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;
    }
}

En este ejemplo, el método filter() selecciona productos con un descuento superior al 20%, y count() determina su cantidad.

El método max()

El método max() devuelve el elemento máximo de un stream según un Comparator dado. Si el stream está vacío, retorna Optional.empty().

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

Ejemplo práctico

Buscar el producto más caro en una tienda en línea para promocionarlo como un producto 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;
    }
}

En este código, Comparator.comparing(Product::getPrice) compara productos por precio, y max() selecciona el más caro.

El método min()

El método min() es similar a max(), pero devuelve el elemento más pequeño en un stream basado en un Comparator dado.

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

Ejemplo práctico

Encontrar el producto con el stock más bajo para evaluar la necesidad de reabastecimiento.

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

Este código identifica el producto con el menor stock utilizando el método min() y Comparator.comparing(Product::getStock).

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 8