Bonjour Java Lambda

En écrivant du code qui répond à des exigences simples, comparons le cas sans Lambda avec le cas avec lui. Préparez une liste de nombres comme celle ci-dessous et considérez le processus consistant à doubler les nombres pour 100 ou plus et à les additionner. Spécifications: Additionnez les doubles pour 100 ou plus

`number-list`


final List<Integer> numbers = Arrays.asList(50, 100, 10, 400, 120, 30, 220);

Boîtier sans Lambda

Par exemple, vous pouvez vérifier les valeurs de la liste une par une, et si elle est de 100 ou plus, doublez la valeur et ajoutez-la au total. Avec ce genre de calcul, c'est simple et facile à comprendre, et il ne semble pas y avoir de problème majeur. Cependant, parce que l'idée de l'ingénieur de "vérifier les nombres un par un" est prise en sandwich entre les spécifications (en ajoutant les doublées pour 100 ou plus) comme moyen de le réaliser, Il peut s'agir d'un code trompeur.

`without-lambda.java`


int total = 0;
for (Integer number : numbers) {
  if (number >= 100) {
    total += number * 2;
  }
}
System.out.println("Total is " + total);

Cas utilisant Lambda

Le montant total du code n'est pas si différent de ce qui précède. Cependant, la façon de lire le flux de traitement qui peut être vu à partir du code changera. "Filtrez 100 nombres ou plus de la liste, doublez-les et additionnez-les." Je n'ai écrit aucun code qui vérifie un par un dans une boucle. Cela peut être exprimé comme si les spécifications (doublées de 100 ou plus) étaient décrites telles quelles. Je ne pense pas que ce soit le cas dans tous les cas, mais je pense que vous pouvez écrire du code dans cet exemple qui soit moins trompeur par rapport aux spécifications requises.

`with-lambda.java`


int total = 0;
total = numbers.stream()
  .filter(num -> num >= 100)
  .map(num -> num * 2)
  .reduce(0, (base, value) -> base + value);
System.out.println("Total is " + total);