Apprendre Agrégation des Éléments avec la Méthode reduce() | Opérations Terminales dans l'API Stream

Lors de la manipulation de collections en Java, il est souvent nécessaire de réduire tous les éléments à un seul résultat, tel qu'une somme, un produit ou une autre valeur agrégée.

Il existe trois variantes de la méthode reduce(), chacune conçue pour différents scénarios. Examinons chacune d'elles en détail.

reduce() avec un seul paramètre

Si vous devez agréger des éléments sans valeur initiale, vous pouvez utiliser cette version de reduce(). Cependant, comme le flux peut être vide, la méthode retourne un Optional<T>.

Optional<T> reduce(BinaryOperator<T> accumulator);

Cette méthode applique la fonction accumulator à tous les éléments du flux et retourne un Optional<T>.

Exemple pratique

Considérer une boutique en ligne avec une liste de produits et leurs prix. L'objectif est de calculer le chiffre d'affaires total de tous les produits de la boutique.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        Optional<Double> totalRevenue = products.stream()
                .map(Product::getPrice)
                .reduce(Double::sum);

        totalRevenue.ifPresent(revenue -> System.out.println("Total revenue: " + revenue));
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

Ce code crée une liste de produits, puis utilise reduce() pour additionner les prix. La méthode map(Product::getPrice) extrait le prix de chaque produit, tandis que Double::sum effectue la sommation. Si le résultat est présent, il est affiché.

reduce() avec deux paramètres

Pour garantir une valeur de retour même lorsque le flux est vide, utiliser la méthode reduce() avec un paramètre d'identité. La valeur initiale assure un calcul stable.

T reduce(T identity, BinaryOperator<T> accumulator);

Cette version de reduce() commence avec la valeur identity fournie, garantissant qu'un résultat est toujours retourné, même pour un flux vide.

Exemple pratique

Supposons qu'un magasin dispose d'une caisse avec un solde initial, et qu'il soit nécessaire d'ajouter le prix total de tous les produits pour déterminer le montant total potentiel en caisse.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        double totalRevenue = products.stream()
                .map(Product::getPrice)
                .reduce(500.0, Double::sum);

        System.out.println("Total revenue with initial balance: " + totalRevenue);
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

Ici, le code extrait les prix avec map(Product::getPrice) et applique reduce(500.0, Double::sum), où 500.0 représente le solde initial, et Double::sum additionne les valeurs.

reduce() pour le traitement parallèle

Cette version de reduce() est conçue pour les cas nécessitant des transformations plus complexes, et où les résultats doivent être agrégés en parallèle.

<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

Cette méthode prend trois paramètres :

identity – la valeur initiale ;
accumulator – une fonction qui transforme chaque élément ;
combiner – une fonction qui fusionne les résultats partiels.

Exemple pratique

Dans une boutique en ligne, il est nécessaire de calculer le nombre total de caractères dans tous les noms de produits. Cela peut être utile pour définir des limites sur la longueur des reçus.

Main.java


              123456789101112131415161718192021222324252627282930313233343536
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        int totalLength = products.stream()
                .reduce(0, (sum, product) -> sum + product.getName().length(), Integer::sum);

        System.out.println("Total name length: " + totalLength);
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

Le code parcourt la liste de produits en utilisant reduce(), où 0 est la valeur initiale, (sum, product) -> sum + product.getName().length() définit la logique pour additionner les longueurs des noms des produits, et Integer::sum combine les résultats dans un environnement de traitement parallèle.

1. Quel type de données la méthode `reduce(BinaryOperator<T> accumulator)` retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser `reduce(T identity, BinaryOperator<T> accumulator)` ?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 6

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you show me code examples for each reduce() variation?

What are some common use cases for each reduce() method?

Can you explain the difference between Optional<T> and T in the reduce() results?

Awesome!

Completion rate improved to 2.33

Glissez pour afficher le menu

Il existe trois variantes de la méthode reduce(), chacune conçue pour différents scénarios. Examinons chacune d'elles en détail.

reduce() avec un seul paramètre

Optional<T> reduce(BinaryOperator<T> accumulator);

Cette méthode applique la fonction accumulator à tous les éléments du flux et retourne un Optional<T>.

Exemple pratique

Considérer une boutique en ligne avec une liste de produits et leurs prix. L'objectif est de calculer le chiffre d'affaires total de tous les produits de la boutique.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        Optional<Double> totalRevenue = products.stream()
                .map(Product::getPrice)
                .reduce(Double::sum);

        totalRevenue.ifPresent(revenue -> System.out.println("Total revenue: " + revenue));
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

reduce() avec deux paramètres

T reduce(T identity, BinaryOperator<T> accumulator);

Cette version de reduce() commence avec la valeur identity fournie, garantissant qu'un résultat est toujours retourné, même pour un flux vide.

Exemple pratique

Main.java


              12345678910111213141516171819202122232425262728293031323334353637
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        double totalRevenue = products.stream()
                .map(Product::getPrice)
                .reduce(500.0, Double::sum);

        System.out.println("Total revenue with initial balance: " + totalRevenue);
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

reduce() pour le traitement parallèle

Cette version de reduce() est conçue pour les cas nécessitant des transformations plus complexes, et où les résultats doivent être agrégés en parallèle.

<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

Cette méthode prend trois paramètres :

identity – la valeur initiale ;
accumulator – une fonction qui transforme chaque élément ;
combiner – une fonction qui fusionne les résultats partiels.

Exemple pratique

Main.java


              123456789101112131415161718192021222324252627282930313233343536
            
package com.example;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Laptop", 1200.0),
                new Product("Mouse", 25.0),
                new Product("Keyboard", 75.0)
        );

        int totalLength = products.stream()
                .reduce(0, (sum, product) -> sum + product.getName().length(), Integer::sum);

        System.out.println("Total name length: " + totalLength);
    }
}

class Product {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

1. Quel type de données la méthode `reduce(BinaryOperator<T> accumulator)` retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser `reduce(T identity, BinaryOperator<T> accumulator)` ?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 6

Agrégation des Éléments avec la Méthode reduce()

reduce() avec un seul paramètre

Exemple pratique

reduce() avec deux paramètres

Exemple pratique

reduce() pour le traitement parallèle

Exemple pratique

1. Quel type de données la méthode reduce(BinaryOperator<T> accumulator) retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser reduce(T identity, BinaryOperator<T> accumulator) ?

Awesome!

Agrégation des Éléments avec la Méthode reduce()

reduce() avec un seul paramètre

Exemple pratique

reduce() avec deux paramètres

Exemple pratique

reduce() pour le traitement parallèle

Exemple pratique

1. Quel type de données la méthode reduce(BinaryOperator<T> accumulator) retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser reduce(T identity, BinaryOperator<T> accumulator) ?

1. Quel type de données la méthode `reduce(BinaryOperator<T> accumulator)` retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser `reduce(T identity, BinaryOperator<T> accumulator)` ?

1. Quel type de données la méthode `reduce(BinaryOperator<T> accumulator)` retourne-t-elle si le flux peut être vide ?

2. Quand faut-il utiliser `reduce(T identity, BinaryOperator<T> accumulator)` ?