[Java] Funktionsschnittstelle / Lambda-Ausdruck

Was ist ein Lambda-Ausdruck?

• ** Syntax zum Übergeben von Methoden **

Wenn Sie den Lambda-Ausdruck nicht verwenden

• Wenn Sie einzelne Elemente aus einer bestimmten Zeichenfolge extrahieren und vor und nach der Ausgabe Klammern hinzufügen möchten

public class MethodRefUnuse {
//Inhalt der Zeichenkette mit Klammer ausgeben
  public void walkArray(String[] data) {
    for (var value : data) {
      System.out.printf("[%s]\n", value);
    }
  }
}

//Geben Sie den Inhalt der Zeichenfolgenarray-Daten der Reihe nach aus
public class MethodRefUnuseBasic {

  public static void main(String[] args) {
    var data = new String[] { "Der Frühling ist Akebono", "Sommer ist Nacht", "Der Herbst ist Abenddämmerung" };
    var un = new MethodRefUnuse();
    un.walkArray(data); //[Der Frühling ist Akebono][Sommer ist Nacht][Der Herbst ist Abenddämmerung]
  }
}

• Es ist schwierig, mehrere walkArray-Methoden vorzubereiten, wenn Sie die ersten fünf Zeichen der Zeichenfolge anstelle von Klammern ausgeben möchten.
• ** → Ermöglicht es, nur den Prozess der Verarbeitung von Zeichenketten von außen zu extrahieren **
• Es ist sinnlos, eine ähnliche Methode zu erstellen! Das bedeutet

Methodenreferenz

• Lassen Sie uns nur den Code ausschneiden, der das Array-Element verarbeitet

MethodRefUnuse.java

public class MethodRefUse {

//Ermöglichen Sie den Empfang der Verarbeitungsmethode von Array-Elementen per Methodenreferenz
  //In der Argumentausgabe"Verweisen Sie auf eine Methode, die ein Argument als String-Typ empfängt und den Rückgabewert void hat"Bestehen

  public void walkArray(String[] data, Output output) {
    for (var value : data) {
      output.print(value);
    }
  }
//Methode entsprechend dem Ausgabetyp (Zeichenkette in Klammer einschließen)
  //Der tatsächliche Status der in der Funktionsschnittstelle definierten Druckmethode ist die addQuote-Methode.
  static void addQuote(String value) {
    System.out.printf("[%s]\n", value);
  }
}

• Der Typ der Methode wird durch ** Funktionsschnittstelle ** dargestellt
• ** Eine Schnittstelle mit einer abstrakten Methode darunter ** (SAM-Schnittstelle)
• Die Anzahl / Art der Argumente und die Art des Rückgabewerts müssen bestimmt werden
• Der Name ist irrelevant und ** der Rückgabetyp ** ist der zu bestimmende Schlüssel
• cf: Die Methodensignatur wird durch den Methodennamen, die Anzahl der Argumente / den Typ verschlüsselt
• Erklären Sie, dass die Zielschnittstelle funktionsfähig ist, indem Sie die Annotation @ FunctionalInterface hinzufügen.

Output.java

//Ein Methodentyp, der ein Argument vom Typ String verwendet und einen ungültigen Methodentyp zurückgibt
@FunctionalInterface
public interface Output {
  void print(String str);
}

• Übergeben Sie den Methodenverweis an die Methode
• ** Klassenmethode **: Klassenname :: Methodenname
• ** Standmethode **: Objektvariable :: Methodenname
• ** Konstruktor **: Klassenname :: neu

MethodRefUnuseBasic.java

public class MethodRefUseBasic {

  public static void main(String[] args) {
    var data = new String[] {"Der Frühling ist Akebono", "Sommer ist Nacht", "Der Herbst ist Abenddämmerung"};
    var u = new MethodRefUse();
    //Übergeben Sie einen Methodenverweis auf die walkArray-Methode
    u.walkArray(data, MethodRefUse::addQuote);
  }
}

Methode ersetzen

• Die an die Argumentausgabe übergebene Methode kann ** mit dem in der Funktionstypschnittstelle deklarierten Typ frei geändert werden **
• Sie können die Framework-Funktion implementieren, indem Sie auf die Methode verweisen, ohne die walkAttar-Methode neu zu schreiben, und die vom Benutzer zu bestimmenden Details entwerfen!
• Ausgabe
• addOuote (String value) Dann in Klammern setzen
• Geben Sie nach "addLength (String value)" den Gesamtwert der Stringlänge des Arrays aus.

//Zählerklasse, die Zeichenfolgen zählt
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[] {"Der Frühling ist Akebono", "Sommer ist Nacht", "Der Herbst ist Abenddämmerung"};
    var u = new MethodRefUse();
    var c = new Counter();
    //Die addLength-Methode der Counter-Klasse fügt dem Ergebnisfeld die Zeichenfolgenlänge des Werts hinzu
    u.walkArray(data, c::addLength);
    System.out.println(c.getResult());
  }
}

Hier erscheint der Lambda-Stil

• Es ist mühsam, addQuote und addLength zu definieren, indem Sie es einfach an die walkArray-Methode übergeben.
• Methoden, deren Zweck darin besteht, die Verarbeitung zu bestehen, sind verfügbar
• Es ist ärgerlich, jeden einzelnen zu nennen. .. ..
• → ** Lambda-Ausdruck verwenden **!
• Wenn Sie die Methodendefinition als Ausdruck (Literal) schreiben, können Sie sie direkt in die Methodenaufrufanweisung schreiben, und der Code wird aktualisiert!
• ** (Argumenttyp formales Argument) -> {Methodenkörper} **
• Es gibt eine Funktionsoberfläche wie "java.util.function", so dass Sie sie nicht selbst vorbereiten müssen!

//Argument der walkArray-Methode Consumer-Schnittstelle
//Consumer ist eine No-Return-Methode, die ein Argument vom Typ T verwendet und einige Verarbeitungsschritte ausführt
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[] { "Der Frühling ist Akebono", "Sommer ist Nacht", "Der Herbst ist Abenddämmerung" };
    var ml = new MethodLambda();
    ml.walkArray(data, (String value) -> {
      System.out.printf("[%s]\n", value);
    });
  }
}

Lambda-Stil einfacher

• Wenn es sich um einen Satz des Textes handelt, kann {} weggelassen werden
• Rückgabe optional
  • (String value) -> System.out.printf("[%s]\n", value)
• Typinferenz
  • (value) -> System.out.printf("[%s]\n", value)
• Mit einem Argument
  • value -> System.out.printf("[%s]\n", value)

Ordnungsgemäße Verwendung mit anonymer Klasse

• Mit anonymer Klasse umschreiben
• Das zweite Argument der walkArray-Methode ist ein Objekt vom Typ Consumer.
• Entfernt, was abgeleitet werden kann, wenn es sich um einen Lambda-Ausdruck handelt

import java.util.function.Consumer;

public class MethodLambdaBasic {

  public static void main(String[] args) {
    var data = new String[] { "Der Frühling ist Akebono", "Sommer ist Nacht", "Der Herbst ist Abenddämmerung" };
    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));
  }
}

Beispielmethode für das Lambda-Expressionssammlungsframework

** replaceAll-Methode **

• public void replaceAll(UnaryOperator<E> operator)
• ** Argumente / Rückgabewerte müssen denselben Typ zurückgeben **, daher kann keine Zeichenfolgenliste empfangen und keine Zeichenfolgenlängenliste (int) zurückgegeben werden

//Extrahieren Sie nur die ersten 3 Zeichen und geben Sie 2 oder weniger Zeichen so aus, wie sie sind
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]
  }
}

• ** Durch die in der Karte angegebenen Regeln ersetzen **
• Die Argumentfunktion empfängt einzelne Schlüssel / Werte als Argumente und gibt das Ergebnis der Konvertierung zurück

//Fügen Sie dem Kartenwert das Schlüsselakronym hinzu
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", "Katze", "dog", "Inu", "bird", "Tori"));
    map.replaceAll((k, v) -> k.charAt(0) + v);
    System.out.println(map); //{cat=c Katze, dog=d Inu, bird=b Tori}
  }
}

** removeIf Methode **

• ** Elemente, die den Bedingungen entsprechen, aus der Liste entfernen **
• Löschen Sie nur die Elemente, die die Empfangsbedingungen jedes Elements mit dem Argumentfilter erfüllen

//Löschen Sie alle Zeichenfolgen mit 5 oder mehr Zeichen
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", "Tulpe", "Asagao", "Hyazinthe"));
    list.removeIf(v -> v.length() > 4);
    System.out.println(list); //[Rose",Asagao]
  }
}

** Berechnungsmethode **

• Stellen Sie das Verarbeitungsergebnis auf der Karte ein
• ** compute **: Setzt das unbedingt angegebene Verarbeitungsergebnis
• ** computeIfPresent **: Legen Sie fest, ob der angegebene Schlüssel vorhanden ist
• ** computeIfAbsent **: Festlegen, ob der angegebene Schlüssel nicht vorhanden ist
• Wenn Sie eine Methode von mehreren Stellen aus aufrufen, ist die Methodenreferenz sauberer.

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

//Fügen Sie dem Wert das erste Zeichen des Schlüssels hinzu (berechnen/computeIfPresent）
public class CollCompute {
  public static String trans(String key, String value) {
    return key.charAt(0) + value;
  }
//Setzen Sie den Schlüssel selbst auf den Wert (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 m o mikan, melon=mnull}

/*
computeIfPresent: Nur verarbeiten, wenn der Schlüssel vorhanden ist
    map.computeIfPresent("orange", CollCompute::trans);
    map.computeIfPresent("melon", CollCompute::trans);
    System.out.println(map); //{orange m o mikan}
*/

/*computeIfAbsent: Verarbeitet nur diejenigen, die keinen Schlüssel haben
    map.computeIfAbsent("orange", CollCompute::trans);
    map.computeIfAbsent("melon", CollCompute::trans);
    System.out.println(map); //{orange = orange, melon=melon}
*/
  }
}

Zusammenführungsmethode

• ** Doppelte Schlüsselwerte verarbeiten **
• Setzen Sie einen neuen Wert, wenn der Schlüssel nicht vorhanden ist
• public V merge(K key, V value, BiFunction<? super V,? super V,? extends V>remap)

//Verketten Sie durch doppelte Werte durch Kommas getrennte Werte
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", "dreifarbige Katze"));
        map.merge("dog", "Pomera An", CollMerge::concat);
        map.merge("cat", "Persha", CollMerge::concat);
        map.merge("dog", "Pudel", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Pudel, cat=dreifarbige Katze,Persha}

        //Join-Funktion(remap)Verwirft den Schlüssel selbst, wenn null zurückgegeben wird
        map.merge("cat", "", CollMerge::concat);
        System.out.println(map); //{dog=Pomera An,Pudel}
    }
}