Aprenda Calculando Estatísticas de Stream com count(), max() e min()

Em programação, muitas vezes é necessário contar o número de elementos em uma coleção ou encontrar os valores mínimo e máximo entre eles.

No entanto, os programadores geralmente não escrevem algoritmos personalizados para essas tarefas, pois já existem métodos integrados. A Stream API oferece métodos convenientes para trabalhar com coleções, permitindo realizar cálculos sobre os elementos do stream.

Entre esses métodos estão count(), max() e min(), que ajudam a determinar o número de elementos e a encontrar os valores maior e menor.

O método count()

O método count() retorna o número de elementos em um stream. É frequentemente utilizado quando é necessário determinar o tamanho de uma coleção após filtrar os dados.

long count();

Não recebe nenhum parâmetro e retorna um tipo primitivo long.

Exemplo prático

Em uma loja online, é necessário contar o número de produtos com desconto superior a 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;
    }
}

Neste exemplo, o método filter() seleciona produtos com desconto superior a 20%, e count() determina sua quantidade.

O método max()

O método max() retorna o elemento máximo em um stream com base em um determinado Comparator. Se o stream estiver vazio, retorna Optional.empty().

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

Exemplo Prático

Encontrar o produto mais caro em uma loja online para promovê-lo como um produto 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;
    }
}

Neste código, Comparator.comparing(Product::getPrice) compara os produtos pelo preço, e max() seleciona o mais caro.

O método min()

O método min() é semelhante ao max(), mas retorna o menor elemento em um stream com base em um Comparator fornecido.

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

Exemplo prático

Identificação do produto com o menor estoque para avaliar a necessidade de reposição.

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 o produto com o menor estoque utilizando o método min() e Comparator.comparing(Product::getStock).

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 8

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Awesome!

Completion rate improved to 2.33

Deslize para mostrar o menu

Em programação, muitas vezes é necessário contar o número de elementos em uma coleção ou encontrar os valores mínimo e máximo entre eles.

Entre esses métodos estão count(), max() e min(), que ajudam a determinar o número de elementos e a encontrar os valores maior e menor.

O método count()

O método count() retorna o número de elementos em um stream. É frequentemente utilizado quando é necessário determinar o tamanho de uma coleção após filtrar os dados.

long count();

Não recebe nenhum parâmetro e retorna um tipo primitivo long.

Exemplo prático

Em uma loja online, é necessário contar o número de produtos com desconto superior a 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;
    }
}

Neste exemplo, o método filter() seleciona produtos com desconto superior a 20%, e count() determina sua quantidade.

O método max()

O método max() retorna o elemento máximo em um stream com base em um determinado Comparator. Se o stream estiver vazio, retorna Optional.empty().

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

Exemplo Prático

Encontrar o produto mais caro em uma loja online para promovê-lo como um produto 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;
    }
}

Neste código, Comparator.comparing(Product::getPrice) compara os produtos pelo preço, e max() seleciona o mais caro.

O método min()

O método min() é semelhante ao max(), mas retorna o menor elemento em um stream com base em um Comparator fornecido.

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

Exemplo prático

Identificação do produto com o menor estoque para avaliar a necessidade de reposição.

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 o produto com o menor estoque utilizando o método min() e Comparator.comparing(Product::getStock).

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 8