Für diejenigen, die gerade angefangen haben, Programmieren einschließlich der Java-Sprache zu lernen, und diejenigen, die es bereits gelernt haben, zur Überprüfung Dieses Mal schreibe ich, um mehr über den Lambda-Ausdruck zu erfahren.
Die Funktionstypschnittstelle wurde unter Verwendung einer anonymen Klasse (anonyme Klasse) implementiert. Der Quellcode war nicht lesbar und tendenziell redundant.
Die ** Lambda-Formel ** löst solche Probleme. Es handelt sich um eine von Java8 eingeführte Syntax, und die gleiche Implementierung wie bei Verwendung einer anonymen Klasse (anonyme Klasse) ist in einem einfachen und gut lesbaren Zustand möglich geworden.
** Lambda-Ausdruckssyntax **
(Argument der zu implementierenden Methode) -> {Processing};
Vergleichen wir mit einem einfachen Beispiel, wie einfach und lesbar es tatsächlich wurde.
Zunächst die Implementierung in einer anonymen Klasse (anonyme Klasse).
Anonyme Klasse (anonyme Klasse)
//Selbstgemachte Funktionstyp-Schnittstelle
interface Greet {
String sayHello(String name);
}
public class Lambda {
public static void main(String[] args) {
//Erstellen Sie eine Instanz einer anonymen Klasse, die die Greet-Schnittstelle implementiert
Greet case1 = new Greet(){
//Überschreiben Sie die abstrakte Methode sayHello
public String sayHello(String name) {
return name + "San, hallo!";
}
};
//Übergeben Sie die Zeichenfolge an die implementierte sayHello-Methode
String tanaka = case1.sayHello("tanaka");
System.out.println(tanaka); //Herr Tanaka, hallo! Wird ausgegeben
}
}
Implementieren Sie dann einen ähnlichen Prozess mit dem Lambda-Ausdruck.
Lambda-Stil
//Selbstgemachte Funktionstyp-Schnittstelle
interface Greet {
String sayHello(String name);
}
public class Lambda {
public static void main(String[] args) {
//Implementieren Sie die Greet-Schnittstelle mit Lambda-Ausdruck und generieren Sie eine Instanz
Greet case2 = (String name) -> { return name + "San, hallo!"; };
//Übergeben Sie die Zeichenfolge an die implementierte sayHello-Methode
String suzuki = case2.sayHello("suzuki");
System.out.println(suzuki); //Herr Suzuki, Hallo! Wird ausgegeben
}
}
Es kann überschrieben werden, indem Sie neues Greet () und den Methodennamen der abstrakten Methode darin schreiben, ohne es erneut zu schreiben. Dies liegt daran, dass die "funktionale Schnittstelle nur eine abstrakte Methode" hat, sodass ** Lambda-Ausdrücke bestimmen können, welche Methode implementiert werden soll **.
Darüber hinaus kann es nur in bestimmten Fällen weiter weggelassen werden.
before
Greet case2 = (String name) -> { return name + "San, hallo!"; };
after
Greet case2 = (name) -> { return name + "San, hallo!"; };
Da der Typ des Arguments der Methode beim Deklarieren der Funktionstypschnittstelle bestimmt wird, kann er auf `weggelassen werden, ohne den Typ des Arguments zum Zeitpunkt der Implementierung anzugeben.
before
Greet case2 = (String name) -> { return name + "San, hallo!"; };
after
Greet case2 = name -> { return name + "San, hallo!"; };
Wenn es nur ein Argument gibt, kann () weggelassen werden. Es kann jedoch nicht weggelassen werden, wenn kein Argument vorhanden ist, wenn mehrere Argumente vorhanden sind oder wenn der Typ angegeben wird, auch wenn nur ein Argument vorhanden ist.
before
Greet case2 = (String name) -> { return name + "San, hallo!"; };
after
Greet case2 = name -> name + "San, hallo!";
Wenn der Prozess ein Satz ist, kann {} weggelassen werden. Wenn "{}" weggelassen wird, kann "return" weggelassen werden.
Sie können es einfach schreiben!
Im vorherigen Beispiel wurde eine selbst erstellte Funktionsschnittstelle verwendet. Hier sind einige Beispiele für Funktionsschnittstellen, die als Paket java.util.function bereitgestellt werden.
1.Function<T, R>
Nimmt ein Argument vom Typ T und gibt einen Wert vom Typ R zurück. Die Methode ist R anwenden (T t).
Funktionsbeispiel
Function<Integer, String> funcTest = number -> number + "ist";
String resutlt = funcTest.apply(19);
System.out.println(resutlt); //19
2.Consumer<T>
Erhält ein Argument vom Typ T. Die Methode ist void accept (T t).
Verbraucherbeispiel
Consumer<String> weather = str -> System.out.println("Wie ist das Wetter heute" + str);
weather.accept("Es regnet"); // 今日の天気はEs regnet
3.Predicate<T>
Erhält ein Argument vom Typ T. Die Methode ist der Boolesche Test (T t).
Prädikat Beispiel
Predicate<String> check = str -> 5 < str.length();
boolean result = check.test("Mitarashi Knödel");
System.out.println(result); // true
boolean result2 = check.test("Mame Daifuku");
System.out.println(result2); // false
4.Supplier<T>
Das Argument enthält nichts. Die Methode ist T get ().
Lieferantenbeispiel
Supplier<String> name = () -> "Ichiro Suzuki";
System.out.println(name.get()); //Ichiro Suzuki
5.UnaryOperator<T>
Eine Schnittstelle, die die Funktion erweitert. Sowohl der vom Argument empfangene Typ als auch der zurückgegebene Typ sind identisch. Die Methode ist T Apply (T t).
Beispiel für einen unären Operator
UnaryOperator<String> breakfast = food -> "Immerhin am Morgen" + food;
System.out.println(breakfast.apply("Curry")); // 朝はやっぱりCurry
Es ist auch möglich, die im Sammlungsframework bereitgestellten Methoden mithilfe von Lambda-Ausdrücken zu implementieren. (Mehrere Objekte können gespeichert, abgerufen und gelöscht werden.) Weil es eine funktionale Schnittstelle als Methodenargument erhält. Hier sind auch einige davon.
1.default boolean removeIf(Predicate<? super E> filter)
Diese Methode löscht alle Sammlungselemente, die die angegebene Verarbeitung erfüllen.
removeIf-Methode
List<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));
numbers.removeIf(number -> number % 2 == 0); //Teilen Sie durch 2 und löschen Sie diejenige, die 0 wird
System.out.println(numbers); // [1, 3, 5]
2.default void replaceAll(UnaryOperator<E> operator)
Eine Methode, die die angegebene Verarbeitung ausführt und die Elemente der Liste ersetzt.
replaceAll-Methode
List<String> names = Arrays.asList("tanaka", "suzuki", "yamada");
names.replaceAll(name -> name.toUpperCase()); //Ersetzen Sie alle durch Großbuchstaben
System.out.println(names); // [TANAKA, SUZUKI, YAMADA]
3.default void sort(Comparator<? super E> c)
Eine Methode, die die Liste nach der angegebenen Reihenfolge sortiert.
Sortiermethode
List<Integer> randomNum = Arrays.asList(30, 50, 10, 20, 40);
randomNum.sort((a, b) -> b.compareTo(a)); //In absteigender Reihenfolge sortieren
System.out.println(randomNum); // [50, 40, 30, 20, 10]
randomNum.sort((Integer a, Integer b) -> { return a.compareTo(b); } ); //In aufsteigender Reihenfolge sortieren
System.out.println(randomNum); // [10, 20, 30, 40, 50]
4.void forEach(Consumer<? super T> action)
Eine Methode, die die angegebene Aktion für alle Elemente ausführt.
für jede Methode
List<String> names = Arrays.asList("tanaka", "suzuki", "yamada");
//Name+Ich versuche, eins nach dem anderen auszugeben, getrennt durch Leerzeichen halber Breite
names.forEach(name -> System.out.print(name + " ")); // tanaka suzuki yamada
Ich habe die Syntax namens Lambda-Ausdruck angesprochen. Es ist praktisch, dass der Quellcode gekürzt wird und nur der Implementierungsteil beschrieben werden muss.
Ich werde die Stream-API in einem separaten Artikel zusammenfassen.
java.util.function ** [Für Anfänger] Kannst du jetzt nicht mehr hören? Erfahren Sie mehr über Java 8 Lambda-Ausdrücke! **
Recommended Posts