L'opération de réduction de Stream en Java

1. Qu’est-ce que la réduction en Java
2. Stream reduce() Opération en Java 8
3. Trouver la somme à l’aide de l’opération reduce() en Java
4. Trouver la somme à l’aide de reduce() et de la référence de méthode en Java
5. Trouver Min et Max à l’aide de l’opération reduce() en Java
6. Conclusion

Ce tutoriel discutera des détails de l’opération reduce() et discutera de certains de ses exemples. Avant de parler de l’opération reduce(). Parlons d’abord de la réduction.

Qu’est-ce que la réduction en Java

De nombreuses opérations de terminal (telles que la moyenne, la somme, le minimum, le maximum et le comptage) dans le JDK combinent le contenu d’un Stream pour générer une valeur unique. L’opération de réduction fait de même et renvoie un seul Stream.

De plus, le JDK inclut des opérations de réduction qui renvoient une collection plutôt qu’une valeur unique. De nombreux processus de réduction accomplissent une tâche spécifique, comme le calcul de la moyenne des valeurs ou la catégorisation des éléments.

Le JDK, d’autre part, a des opérations de réduction à usage général appelées réduction et collecte.

Stream reduce() Opération en Java 8

L’opération reduce() est une opération de réduction à usage général. La syntaxe de l’opération reduce() est :

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

Il y a deux arguments à l’opération de réduction :

• identity : l’élément identity est à la fois la valeur de début de la réduction et le résultat par défaut si le Stream ne contient aucun élément.
• accumulator : La fonction accumulator accepte deux arguments : un résultat de réduction partielle et l’élément suivant du Stream. Cela nous donne un nouveau résultat partiel.

L’opération reduce() est un type d’opération de terminal.

Trouver la somme à l’aide de l’opération reduce() en Java

Calculons la somme de tous les éléments d’un tableau à l’aide de l’API Stream en Java. Regardez le code ci-dessous :

import java.util.Arrays;
public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    int sum = Arrays.stream(numbers).reduce(0, (a, b) -> a + b);

    System.out.print("sum: " + sum);
  }
}

Production :

sum: 2422

Si nous n’utilisons pas la fonction reduce(), nous devrons écrire le code ci-dessous pour obtenir la somme de tous les éléments. Voir l’exemple ci-dessous.

import java.util.Arrays;
public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    int sum = 0;
    for (int i : numbers) {
      sum += i;
    }
    System.out.println("sum : " + sum);
  }
}

Production :

sum : 2422

Trouver la somme à l’aide de reduce() et de la référence de méthode en Java

Nous pouvons également passer la référence de méthode sum() Integer::sum comme suit pour obtenir la somme de tous les éléments. Regardez le code ci-dessous :

import java.util.Arrays;
public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    int sum = Arrays.stream(numbers).reduce(0, Integer::sum);

    System.out.print("sum: " + sum);
  }
}

Production :

sum: 2422

Si le tableau est vide et que nous le passons pour obtenir la somme des éléments, il ne lève aucune exception à la place et donne un résultat nul. Voir l’exemple ci-dessous.

import java.util.Arrays;
public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {};
    int sum = Arrays.stream(numbers).reduce(0, Integer::sum);

    System.out.print("sum: " + sum);
  }
}

Production :

sum: 0

Comme nous pouvons le voir, l’élément d’identité est renvoyé si le tableau est vide.

Trouver Min et Max à l’aide de l’opération reduce() en Java

Généralement, pour trouver l’élément min et max dans un tableau, nous utilisons une combinaison de boucles for et d’instructions if-else telles que :

public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    // finding the min element
    int min = numbers[0];
    for (int i : numbers) {
      if (min > i) {
        min = i;
      }
    }
    // finding the max element
    int max = numbers[0];
    for (int i : numbers) {
      if (max < i) {
        max = i;
      }
    }
    // printing the max and min value
    System.out.println("max: " + max);
    System.out.println("min: " + min);
  }
}

Production :

max: 985
min: 20

Nous pouvons trouver l’élément min et max dans un tableau en utilisant l’opération reduce() qui rend notre code plus concis. Voir l’exemple ci-dessous.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    // finding the min element
    int min = Arrays.stream(numbers).reduce(Integer.MAX_VALUE, (a, b) -> a < b ? a : b);
    // finding the max element
    int max = Arrays.stream(numbers).reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);
    // printing the max and min value
    System.out.println("max: " + max);
    System.out.println("min: " + min);
  }
}

Production :

max: 985
min: 20

Nous pouvons également utiliser des références de méthode pour le calcul de l’élément min et max à partir d’un tableau. Regardez le code ci-dessous :

import java.util.Arrays;
public class SimpleTesting {
  public static void main(String args[]) {
    int[] numbers = {45, 56, 87, 323, 47, 20, 658, 985, 78, 123};
    // finding the min element
    int min = Arrays.stream(numbers).reduce(Integer.MAX_VALUE, Integer::min);
    // finding the max element
    int max = Arrays.stream(numbers).reduce(Integer.MIN_VALUE, Integer::max);
    // printing the max and min value
    System.out.println("max: " + max);
    System.out.println("min: " + min);
  }
}

Production :

max: 985
min: 20

Conclusion

Dans ce tutoriel, nous avons appris l’opération de réduction. Nous avons ensuite approfondi le sujet de l’opération reduce(). Enfin, nous avons vu plusieurs exemples de la manière dont nous exécutons avec concision des fonctions arithmétiques de base.