[Java] Interface fonctionnelle / expression lambda

Qu'est-ce qu'une expression lambda?

• ** Syntaxe pour passer des méthodes **

Lorsque vous n'utilisez pas l'expression lambda

• Lorsque vous souhaitez extraire des éléments individuels d'une chaîne de caractères donnée et ajouter des crochets avant et après la sortie

public class MethodRefUnuse {
//Contenu de la chaîne de caractères de sortie avec crochet
  public void walkArray(String[] data) {
    for (var value : data) {
      System.out.printf("[%s]\n", value);
    }
  }
}

//Sortir le contenu des données du tableau de chaînes de caractères dans l'ordre
public class MethodRefUnuseBasic {

  public static void main(String[] args) {
    var data = new String[] { "Le printemps est Akebono", "L'été est la nuit", "L'automne est le crépuscule" };
    var un = new MethodRefUnuse();
    un.walkArray(data); //[Le printemps est Akebono][L'été est la nuit][L'automne est le crépuscule]
  }
}

• Il est difficile de préparer plusieurs méthodes walkArray lorsque vous souhaitez insérer les cinq premiers caractères de la chaîne de caractères, au lieu de crochets.
• ** → Rendre possible d'extraire uniquement le traitement du traitement des chaînes de caractères de l'extérieur **
• Il est inutile de créer une méthode similaire! Cela signifie

Référence de la méthode

• Découpons uniquement le code qui traite l'élément du tableau

MethodRefUnuse.java

public class MethodRefUse {

//Rendre possible de recevoir la méthode de traitement des éléments du tableau par référence de méthode
  //Dans la sortie d'argument"Faites référence à une méthode qui reçoit un argument de type String et dont la valeur de retour est void"Passer

  public void walkArray(String[] data, Output output) {
    for (var value : data) {
      output.print(value);
    }
  }
//Méthode correspondant au type de sortie (entourer la chaîne de caractères entre crochets)
  //L'état réel de la méthode d'impression définie dans l'interface fonctionnelle est la méthode addQuote.
  static void addQuote(String value) {
    System.out.printf("[%s]\n", value);
  }
}

• Le type de méthode est représenté par ** interface fonctionnelle **
• ** Une interface avec une méthode abstraite en dessous ** (interface SAM)
• Le nombre / type d'arguments et le type de valeur de retour doivent être déterminés
• Le nom n'est pas pertinent et ** le type de retour ** est la clé à déterminer
• cf: La signature de la méthode est saisie par nom de méthode, nombre d'arguments / type
• Déclarez que l'interface cible est fonctionnelle en ajoutant l'annotation @ FunctionalInterface.

Output.java

//Un type de méthode qui prend un argument de type String et retourne un type de méthode void
@FunctionalInterface
public interface Output {
  void print(String str);
}

• Passer la référence de méthode à la méthode
• ** Méthode de classe **: Nom de classe :: Nom de méthode
• ** Méthode Stance **: Variable objet :: Nom de la méthode
• ** Constructeur **: Nom de classe :: nouveau

MethodRefUnuseBasic.java

public class MethodRefUseBasic {

  public static void main(String[] args) {
    var data = new String[] {"Le printemps est Akebono", "L'été est la nuit", "L'automne est le crépuscule"};
    var u = new MethodRefUse();
    //Passer une référence de méthode à la méthode walkArray
    u.walkArray(data, MethodRefUse::addQuote);
  }
}

Remplacer la méthode

• La méthode passée à la sortie de l'argument est ** librement modifiable avec le type déclaré dans l'interface fonctionnelle **
• Vous pouvez implémenter la fonction de cadre en vous référant à la méthode sans réécrire la méthode walkAttar, et concevoir les détails à décider par l'utilisateur!
• production
• addOuote (String value) Puis placez-le entre crochets
• Après addLength (String value), affiche la valeur totale de la longueur de chaîne du tableau.

//Classe de compteur qui compte les chaînes
public class Counter {
  private int result = 0;

  public int getResult() {
    return this.result;
  }

  public void addLength(String value) {
    this.result += value.length();
  }
}

public class CounterBasic {

  public static void main(String[] args) {
    var data = new String[] {"Le printemps est Akebono", "L'été est la nuit", "L'automne est le crépuscule"};
    var u = new MethodRefUse();
    var c = new Counter();
    //La méthode addLength de la classe Counter ajoute la longueur de chaîne de valeur au champ de résultat
    u.walkArray(data, c::addLength);
    System.out.println(c.getResult());
  }
}

Le style Lambda apparaît ici

• Il est fastidieux de définir addQuote et addLength simplement en le passant à la méthode walkArray.
• Les méthodes dont le but est de réussir le traitement sont jetables
• C'est ennuyeux de nommer chacun d'eux. .. ..
• → ** Utilisez l'expression lambda **!
• En écrivant la définition de méthode sous forme d'expression (littérale), vous pouvez l'écrire directement dans l'instruction d'appel de méthode et le code est rafraîchissant!
• ** (type d'argument argument formel) -> {corps de la méthode} **
• Il existe une interface de fonction comme java.util.function, vous n'avez donc pas à la préparer vous-même!

//Argument de la méthode walkArray Interface consommateur
//Consumer est une méthode sans retour qui prend un argument de type T et effectue un certain traitement
import java.util.function.Consumer;

public class MethodLambda {

  public void walkArray(String[] data, Consumer<String> output) {
    for (var value : data) {
      output.accept(value);
    }
  }
}

public class MethodLambdaBasic {

  public static void main(String[] args) {
    var data = new String[] { "Le printemps est Akebono", "L'été est la nuit", "L'automne est le crépuscule" };
    var ml = new MethodLambda();
    ml.walkArray(data, (String value) -> {
      System.out.printf("[%s]\n", value);
    });
  }
}

Style Lambda plus facile

• S'il s'agit d'une phrase du texte, {} peut être omis
• retour facultatif
  • (String value) -> System.out.printf("[%s]\n", value)
• Inférence de type
  • (value) -> System.out.printf("[%s]\n", value)
• Avec un argument
  • value -> System.out.printf("[%s]\n", value)

Utilisation correcte avec une classe anonyme

• Réécrire avec une classe anonyme
• Le deuxième argument de la méthode walkArray est un objet de type Consumer.
• Supprime ce qui peut être déduit s'il s'agit d'une expression lambda

import java.util.function.Consumer;

public class MethodLambdaBasic {

  public static void main(String[] args) {
    var data = new String[] { "Le printemps est Akebono", "L'été est la nuit", "L'automne est le crépuscule" };
    var ml = new MethodLambda();

    ml.walkArray(data, new Consumer<String>() {
      @Override
      public void accept(String value) {
        System.out.printf("[%s]\n", value);
      }
    });

     ml.walkArray(data, (String value) -> System.out.printf("[%s]\n", value));
     ml.walkArray(data, (value) -> System.out.printf("[%s]\n", value));
     ml.walkArray(data, value -> System.out.printf("[%s]\n", value));
  }
}

Exemple de méthode de framework de collecte d'expressions lambda

** Méthode replaceAll **

• public void replaceAll(UnaryOperator<E> operator)
• ** Les arguments / valeurs de retour doivent renvoyer le même type **, il ne peut donc pas recevoir de liste de chaînes et renvoyer une liste de longueur de chaîne (int)

//Extraire uniquement les 3 premiers caractères et afficher 2 caractères ou moins tels quels
import java.util.ArrayList;
import java.util.Arrays;

public class CollReplace {

  public static void main(String[] args) {
    var list = new ArrayList<String>(
        Arrays.asList("Neko", "Inu", "Niwatori"));
    list.replaceAll(v -> {
      if (v.length() < 3) {
        return v;
      } else {
        return v.substring(0, 3);
      }
    });
    System.out.println(list); //[Nek, Inu, Niw]
  }
}

• ** Remplacez par les règles spécifiées dans la carte **
• La fonction d'argument reçoit des clés / valeurs individuelles comme arguments et renvoie le résultat de la conversion

//Ajouter un acronyme clé à la valeur de la carte
import java.util.HashMap;
import java.util.Map;

public class CollReplaceMap {

  public static void main(String[] args) {
    var map = new HashMap<String, String>(
      Map.of("cat", "Chat", "dog", "Inu", "bird", "Tori"));
    map.replaceAll((k, v) -> k.charAt(0) + v);
    System.out.println(map); //{cat=chat c, dog=d Inu, bird=b Tori}
  }
}

** méthode removeIf **

• ** Supprimer les éléments qui correspondent aux conditions de la liste **
• Supprimer uniquement les éléments qui remplissent les conditions de réception de chaque élément avec l'argument filtre

//Supprimer toutes les chaînes de 5 caractères ou plus
import java.util.ArrayList;
import java.util.Arrays;

public class CollRemove {

  public static void main(String[] args) {
    var list = new ArrayList<String>(
      Arrays.asList("Rose", "Tulipe", "Asagao", "Jacinthe"));
    list.removeIf(v -> v.length() > 4);
    System.out.println(list); //[Rose",Asagao]
  }
}

** méthode de calcul **

• Définissez le résultat du traitement sur la carte
• ** compute **: définit le résultat du traitement spécifié de manière inconditionnelle
• ** computeIfPresent **: Défini si la clé spécifiée existe
• ** computeIfAbsent **: Défini si la clé spécifiée n'existe pas
• Lors de l'appel d'une méthode à partir de plusieurs endroits, la référence de méthode est plus propre.

import java.util.HashMap;
import java.util.Map;

//Ajoutez le premier caractère de la clé à la valeur (calculez/computeIfPresent）
public class CollCompute {
  public static String trans(String key, String value) {
    return key.charAt(0) + value;
  }
//Définissez la clé elle-même sur la valeur (computeIfAbsent)
  public static String trans(String key) {
    return key;
  }

  public static void main(String[] args) {
    var map = new HashMap<String, String>(Map.of("orange", "Mandarine"));

//compute
      map.compute("orange", CollCompute::trans);
      map.compute("melon", CollCompute::trans);
      System.out.println(map); //{orange ＝ o mikan, melon=mnull}

/*
computeIfPresent: traiter uniquement si la clé existe
    map.computeIfPresent("orange", CollCompute::trans);
    map.computeIfPresent("melon", CollCompute::trans);
    System.out.println(map); //{orange ＝ o mikan}
*/

/*computeIfAbsent: ne traite que ceux qui n'ont pas de clé
    map.computeIfAbsent("orange", CollCompute::trans);
    map.computeIfAbsent("melon", CollCompute::trans);
    System.out.println(map); //{orange = orange, melon=melon}
*/
  }
}

méthode de fusion

• ** Traiter les valeurs de clé en double **
• Définir une nouvelle valeur si la clé n'existe pas
• public V merge(K key, V value, BiFunction<? super V,? super V,? extends V>remap)

//Concaténer les valeurs séparées par des virgules lors de la duplication des valeurs
import java.util.HashMap;
import java.util.Map;

public class CollMerge {
    public static String concat(String v1, String v2) {
        if(v2 == "") {return null;}
        return v1 + "," + v2;
    }
    public static void main(String[] args) {
        var map = new HashMap<String, String>(Map.of("cat", "chat trois couleurs"));
        map.merge("dog", "Pomera An", CollMerge::concat);
        map.merge("cat", "Persha", CollMerge::concat);
        map.merge("dog", "Caniche", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Caniche, cat=chat trois couleurs,Persha}

        //Fonction de jointure(remap)Ignore la clé elle-même si renvoie null
        map.merge("cat", "", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Caniche}
    }
}