Avec la sortie de Java 8, une nouvelle fonctionnalité connue sous le nom d'opérateur de flèche a été ajoutée au langage. L'opérateur '->' ou l'opérateur lambda sont d'autres noms pour cela. Les développeurs peuvent définir et utiliser des expressions lambda, une nouvelle fonctionnalité Java permettant de définir des fonctions anonymes, grâce à cet opérateur.

Les développeurs peuvent désormais écrire du code à la fois plus court et plus expressif grâce à l'inclusion d'expressions lambda dans le langage de programmation Java. À la place des classes internes anonymes, qui étaient auparavant utilisées pour implémenter des interfaces avec une méthode abstraite solitaire, elles peuvent être utilisées.

La syntaxe d'une expression lambda est la suivante :

 (parameter1, parameter2, ...) -> { // body of lambda expression } 

La liste des paramètres et le corps de l'expression lambda sont séparés à l'aide de l'opérateur flèche. Des parenthèses sont utilisées pour entourer les paramètres, tandis que des accolades sont utilisées pour encapsuler le corps de l'expression.

Linux renommer le répertoire

L'opérateur flèche est utilisé pour montrer que les paramètres de l'expression lambda sont transmis au corps de l'expression. Il est également utilisé pour désigner le type de retour de l'expression. Si le corps d'une expression ne contient qu'une seule expression, le type de retour peut être déduit de cette expression. Le type de retour doit être spécifiquement indiqué si le corps de l'expression contient plusieurs expressions.

np.sum

Voici un exemple d'expression lambda qui prend deux paramètres entiers et renvoie leur somme :

 (int a, int b) -> a + b 

L'expression lambda peut être utilisée de la manière suivante :

 IntBinaryOperator sum = (int a, int b) -> a + b; int result = sum.applyAsInt(10, 20); // result = 30 

L'expression lambda dans cette illustration est appliquée à une variable de type IntBinaryOperator. L'expression lambda est ensuite appliquée à deux valeurs entières à l'aide de la méthode applyAsInt() de l'interface IntBinaryOperator, ce qui donne une somme de 30.

L'opérateur flèche peut également être utilisé pour définir des expressions lambda qui ne prennent aucun paramètre :

raccourci tout en majuscules excel

 () -> { // body of lambda expression } 

En Java, il existe plusieurs circonstances dans lesquelles les expressions lambda peuvent être utilisées, telles que les interfaces fonctionnelles, les flux et le traitement parallèle. Ils permettent aux programmeurs de créer des lignes de code plus courtes et plus expressives, ce qui peut améliorer la lisibilité et la maintenabilité.

Une illustration du code Java qui utilise l'opérateur flèche pour définir et appliquer une expression lambda à une liste d'entiers est présentée ci-dessous :

ArrowOperatorExample.java

 import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class ArrowOperatorExample { public static void main(String[] args) { List numbers = new ArrayList(); numbers.add(1); numbers.add(2); numbers.add(3); numbers.add(4); numbers.add(5); System.out.println('Original list: ' + numbers); List evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); System.out.println('Even numbers: ' + evenNumbers); } } 

Sortir:

initialiseur de dictionnaire c#

 Original list: [1, 2, 3, 4, 5] Even numbers: [2, 4] 

Dans ce code, une liste d'entiers appelés nombres est d'abord créée, puis certaines valeurs y sont ajoutées. Ensuite, nous définissons une expression lambda avec l'opérateur flèche pour limiter la liste à n'inclure que des nombres pairs.

Un paramètre, n, est requis pour l'expression lambda (n -> n% 2 == 0), qui renvoie une valeur booléenne indiquant si n est pair ou non. La fonction filter() de l'interface Stream reçoit cette expression et génère un nouveau flux qui ne contient que des nombres pairs.

Les nombres pairs sont ensuite collectés dans une nouvelle liste appelée evenNumbers à l'aide de la méthode collect(), et cette liste est ensuite imprimée sur la console.

Ceci n'est qu'un exemple simple de la façon dont l'opérateur de flèche Java pourrait être utilisé. Bien que sa véritable puissance réside dans les paradigmes de programmation fonctionnelle qui permettent la définition et l'utilisation d'expressions lambda plus complexes, cet exemple devrait vous donner une bonne idée de son fonctionnement.

L'opérateur flèche en Java est une nouvelle fonctionnalité puissante qui permet aux programmeurs de créer et d'utiliser des expressions lambda, résumons-le donc. Il donne aux développeurs Java un vocabulaire clair et expressif pour définir des fonctions anonymes, ce qui peut améliorer la lisibilité et la maintenabilité. Les développeurs peuvent concevoir du code Java plus efficace et plus expressif en utilisant des expressions lambda.