[Introduction à Java] À propos des expressions lambda

Objectif

Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen Cette fois, j'écris pour en savoir plus sur ** expression lambda **.

[Introduction à Java]

• Variations et types ・ Conversion de type ・ Portée des variables
• Opération de chaîne ・ Arrangement ・ Opérateur ・ Branche conditionnelle (en préparation) ・ Répéter le traitement (en préparation) ・ À propos de la classe (en préparation) ・ Classe abstraite (en préparation) ・ Interface (en préparation) ・ Encapsulation (en préparation) ・ À propos du module (en préparation) ・ À propos de la gestion des exceptions ・ À propos de l'expression lambda ← Maintenant ici ・ À propos de l'API Stream

Qu'est-ce qu'une expression lambda?

L'interface de type de fonction a été implémentée en utilisant une classe anonyme (classe anonyme), Le code source n'était pas lisible et avait tendance à être redondant.

La ** formule lambda ** résout ces problèmes. C'est une syntaxe introduite à partir de Java8, et la même implémentation que l'utilisation d'une classe anonyme (classe anonyme) est devenue possible dans un état simple et hautement lisible.

** Syntaxe de l'expression Lambda ** (Argument de la méthode à implémenter) -> {Traitement};

Exemple d'expression Lambda

Comparons avec un exemple simple à quel point il est devenu simple et lisible.

Tout d'abord, l'implémentation dans une classe anonyme (classe anonyme).

Classe anonyme (classe anonyme)

//Interface de type de fonction personnalisée
interface Greet {
  String sayHello(String name);
}

public class Lambda {
  public static void main(String[] args) {

    //Créer une instance d'une classe anonyme qui implémente l'interface Greet
    Greet case1 = new Greet(){

      //Remplacer la méthode abstraite sayHello
      public String sayHello(String name) {
        return name + "San, bonjour!";
      }

    };

    //Passez la chaîne à la méthode sayHello implémentée
    String tanaka = case1.sayHello("tanaka");
    System.out.println(tanaka); //M. tanaka, bonjour! Est sortie

  }
}

Ensuite, implémentez un processus similaire avec l'expression lambda.

Style Lambda

//Interface de type de fonction personnalisée
interface Greet {
  String sayHello(String name);
}

public class Lambda {
  public static void main(String[] args) {

    //Implémenter l'interface Greet avec une expression lambda et générer une instance
    Greet case2 = (String name) -> { return name + "San, bonjour!"; };

    //Passez la chaîne à la méthode sayHello implémentée
    String suzuki = case2.sayHello("suzuki");
    System.out.println(suzuki); //M. suzuki, bonjour! Est sortie
  }
}

Il peut être remplacé en écrivant new Greet () et le nom de la méthode abstraite qu'il contient sans l'écrire à nouveau. Cela est dû au fait que l'interface fonctionnelle n'a qu'une seule méthode abstraite, donc les ** expressions lambda peuvent déterminer la méthode à implémenter **.

Description omise de l'expression lambda

De plus, il n'est possible de l'omettre davantage que dans des cas spécifiques.

1. Omission de type par inférence de type

before

Greet case2 = (String name) -> { return name + "San, bonjour!"; };

after

Greet case2 = (name) -> { return name + "San, bonjour!"; };

Puisque le type de l'argument de la méthode est déterminé lors de la déclaration de l'interface du type de fonction, il peut être omis à `sans spécifier le type de l'argument au moment de l'implémentation.

2. Omission de ()

before

Greet case2 = (String name) -> { return name + "San, bonjour!"; };

after

Greet case2 = name -> { return name + "San, bonjour!"; };

S'il n'y a qu'un seul argument, () peut être omis. Cependant, il ne peut pas être omis s'il n'y a pas d'argument, s'il y a plusieurs arguments ou si le type est spécifié même s'il n'y a qu'un seul argument.

3. Omission de {}

before

Greet case2 = (String name) -> { return name + "San, bonjour!"; };

after

Greet case2 = name -> name + "San, bonjour!";

Si le processus est une phrase, «{}» peut être omis. De plus, si «{}» est omis, «return» peut être omis.

Vous pouvez l'écrire simplement!

Introduction de l'interface fonctionnelle

L'exemple précédent utilisait une interface de fonction personnalisée, Voici quelques exemples d'interfaces fonctionnelles fournies dans le package java.util.function.

1.Function<T, R>

Prend un argument de type T et renvoie une valeur de type R. La méthode est R appliquer (T t).

Exemple de fonction

Function<Integer, String> funcTest = number -> number + "est";
String resutlt = funcTest.apply(19);
System.out.println(resutlt); //19

2.Consumer<T>

Reçoit un argument de type T. La méthode est vide accept (T t).

Exemple de consommateur

Consumer<String> weather = str -> System.out.println("Quel temps fait-il aujourd'hui" + str);
weather.accept("C'est la pluie"); // 今日の天気はC'est la pluie

3.Predicate<T>

Reçoit un argument de type T. La méthode est le test booléen (T t).

Exemple de prédicat

Predicate<String> check = str -> 5 < str.length();
boolean result = check.test("Dumpling Mitarashi");
System.out.println(result); // true

boolean result2 = check.test("Mame Daifuku");
System.out.println(result2); // false

4.Supplier<T>

Il ne reçoit rien dans l'argumentation. La méthode est T get ().

Exemple de fournisseur

Supplier<String> name = () -> "Ichiro Suzuki";
System.out.println(name.get()); //Ichiro Suzuki

5.UnaryOperator<T>

Une interface qui étend Function. Le type reçu par l'argument et le type renvoyé sont identiques. La méthode est T appliquer (T t).

Exemple d'opérateur unaire

UnaryOperator<String> breakfast = food -> "Après tout le matin" + food;
System.out.println(breakfast.apply("curry")); // 朝はやっぱりcurry

Utiliser des expressions lambda dans d'autres méthodes

Il est également possible d'implémenter les méthodes fournies autour du framework de collecte à l'aide d'expressions lambda. (Plusieurs objets peuvent être stockés, récupérés et supprimés) Parce qu'il reçoit une interface fonctionnelle comme argument de méthode. En voici également quelques-uns.

1.default boolean removeIf(Predicate<? super E> filter)

Cette méthode supprime tous les éléments de collection qui satisfont le traitement spécifié.

removeIf, méthode

List<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));
numbers.removeIf(number -> number % 2 == 0); //Divisez par 2 et supprimez celui qui devient 0
System.out.println(numbers); // [1, 3, 5]

2.default void replaceAll(UnaryOperator<E> operator)

Une méthode qui effectue le traitement spécifié et remplace les éléments de la liste.

replaceAll, méthode

List<String> names = Arrays.asList("tanaka", "suzuki", "yamada");
names.replaceAll(name -> name.toUpperCase()); //Tout remplacer par des majuscules
System.out.println(names); // [TANAKA, SUZUKI, YAMADA]

3.default void sort(Comparator<? super E> c)

Une méthode qui trie la liste selon l'ordre spécifié.

méthode de tri

List<Integer> randomNum = Arrays.asList(30, 50, 10, 20, 40);
randomNum.sort((a, b) -> b.compareTo(a)); //Trier par ordre décroissant
System.out.println(randomNum); // [50, 40, 30, 20, 10]

randomNum.sort((Integer a, Integer b) -> { return a.compareTo(b); } ); //Trier par ordre croissant
System.out.println(randomNum); // [10, 20, 30, 40, 50]

4.void forEach(Consumer<? super T> action)

Une méthode qui exécute l'action spécifiée sur tous les éléments.

forEach, méthode

List<String> names = Arrays.asList("tanaka", "suzuki", "yamada");

//Nom+J'essaie de sortir un par un, séparés par des espaces demi-largeur
names.forEach(name -> System.out.print(name + " ")); // tanaka suzuki yamada

À la fin

J'ai abordé la syntaxe appelée expression lambda. Il est pratique que le code source soit raccourci et seule la partie implémentation doit être décrite.

Je vais résumer l'API Stream dans un article séparé.

Site de référence

java.util.function ** [Pour les débutants] Vous n'en entendez plus maintenant? Découvrez les expressions lambda Java 8! **