Les expressions lambda en Java sont des fonctions en ligne utilisées avec des interfaces fonctionnelles pour rendre le nettoyage de code. Introduits dans Java 8, ils permettent de traiter les fonctionnalités comme un argument de méthode. Ils simplifient les taches comme le tri, le filtrage et la gestion des événements. Pour les utiliser, faites correspondre le lambda à la signature de la méthode d'une interface fonctionnelle. Les interfaces intégrées comme le prédicat, la fonction, le consommateur, le fournisseur et le support unyopérateur prennent en charge les opérations communes. Les lambdas fonctionnent mieux pour la logique courte; La logique complexe doit être extraite ailleurs. 1. Utilisez des lambdas pour réduire le code du chaudron. 2. Appliquez-les principalement avec des collections et des flux. 3. Assurer la compatibilité avec les interfaces fonctionnelles. 4. Préférez les interfaces intégrées ou définissez celles personnalisées avec une méthode abstraite. 5. Gardez les expressions de lambda concises pour la lisibilité et la maintenabilité.

Les expressions de Lambda en Java peuvent sembler un peu déroutantes si vous avez l'habitude d'écrire du code de la manière traditionnelle, mais une fois que vous les avez compris, ils peuvent rendre votre code plus propre et plus expressif. Ils ont été introduits dans Java 8, et depuis lors, ils sont devenus une partie standard du développement de Java moderne.

Décomposons ce que vous devez vraiment savoir sur les expressions de lambda - pas seulement la syntaxe, mais comment et pourquoi vous les utiliseriez.

Que sont les expressions de lambda?

En termes simples, les expressions lambda sont un moyen d'écrire des fonctions en ligne sans avoir à définir une méthode ou une classe distincte. Ils sont particulièrement utiles pour travailler avec des interfaces fonctionnelles (interfaces qui n'ont qu'une seule méthode abstraite), comme Runnable , Comparator ou Custom que vous créez vous-même.

Par exemple, avant Java 8, si vous vouliez exécuter du code dans un nouveau fil, vous feriez quelque chose comme:

 nouveau thread (new Runnable () {
    public void run () {
        System.out.println ("Old Way");
    }
});

Avec Lambdas, vous pouvez raccourcir cela à:

 nouveau thread (() -> System.out.println ("new Way")). start ();

L'idée clé est:

• Les lambdas vous permettent de traiter la fonctionnalité comme un argument de méthode
• Vous pouvez transmettre un comportement comme des données
• Cela rend votre code plus court et plus facile à lire, en particulier avec les collections et les flux

Comment écrire une expression de Lambda de base

La structure générale ressemble à ceci:

 (paramètres) -> {corps}

Voici quelques variations:

• Aucun paramètre:

   () -> System.out.println ("No Args")

• Un paramètre:

   x -> x * x

  (Les parenthèses sont facultatives pour les paramètres uniques)

• Paramètres multiples:

   (a, b) -> ab

Ce qui est important est de faire correspondre le lambda à la signature de la méthode de l'interface. Par exemple, si vous avez une BiFunction<Integer, Integer, Integer> , le lambda doit accepter deux entiers et retourner un entier.

Quand utiliser les expressions lambda

Vous vous retrouverez à utiliser les Lambdas le plus souvent dans ces situations:

• Tri des listes avec logique personnalisée:

   List <string> names = arrays.aslist ("John", "Anna", "Mike");
  noms.sort ((a, b) -> a.compareto (b));

• Filtrage ou traitement des données avec les flux:

   List <Integer> nombres = arrays.aslist (1, 2, 3, 4);
  List <Integer> pair = nombres.stream ()
                               .filter (n -> n% 2 == 0)
                               .tolist ();

• Implémentation des auditeurs d'événements ou des rappels dans des applications GUI:

   Button.AddactionListener (e -> System.out.println ("Button cliquée"));

  Les lambdas fonctionnent mieux lorsque la logique est courte et autonome. S'il devient trop long ou complexe, envisagez de l'extraire en une méthode ou une classe distincte.

  ---

  Des interfaces fonctionnelles sont nécessaires

  Vous ne pouvez pas utiliser un lambda à moins qu'il ne correspond à une interface fonctionnelle. Cela signifie que l'interface doit avoir exactement une méthode abstraite.

  Java fournit plusieurs interfaces fonctionnelles intégrées dans le package java.util.function :

  • Predicate<t></t> - prend une entrée, renvoie Boolean
  • Function<t r></t> - prend une entrée, renvoie le résultat
  • Consumer<t></t> - prend une entrée, ne revient pas
  • Supplier<t></t> - Aucune entrée, renvoie la valeur
  • UnaryOperator<t></t> - prend une entrée, renvoie le même type

  Ainsi, lorsque vous écrivez un lambda comme x -> x > 10 , cela ne fonctionne que si le type attendu est quelque chose comme Predicate<integer></integer> .

  Si vous souhaitez définir votre propre interface fonctionnelle, assurez-vous simplement qu'il n'a qu'une seule méthode abstraite. L'ajout de l'annotation @FunctionalInterface est facultatif mais utile - il indique au compilateur de vérifier que vous n'ajoutez pas accidentellement des méthodes supplémentaires.

  ---

  C'est le c?ur des expressions de lambda à Java. Ils ne sont pas compliqués une fois que vous comprenez comment ils correspondent aux interfaces fonctionnelles et où ils s'intègrent naturellement dans votre code. Continuez à les utiliser dans des endroits comme le tri, le filtrage ou la manipulation des événements, et ils commenceront à se sentir comme une seconde nature.

  Fondamentalement, c'est tout ce dont vous avez besoin pour commencer.

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!