Il s'agit de la méthode de description introduite dans Java 8. L'API Stream [^ 1], également introduite dans Java 8, est basée sur l'utilisation d'expressions lambda, il semble donc avantageux d'apprendre les expressions lambda.
[^ 1]: Une API pour gérer des collections telles que des tableaux et des listes, qui vous permet d'implémenter l'agrégation de valeurs et le traitement des données avec un code facile à comprendre.
Un autre avantage de l'utilisation d'expressions lambda est que vous pouvez simplifier «l'écriture d'une interface fonctionnelle à l'aide de classes anonymes».
La méthode de base pour écrire une expression lambda est la suivante.
Nom de l'interface Nom de l'objet=Argument (peut recevoir plusieurs)->En traitement;
Vous n'avez pas besoin de spécifier le type de l'argument car le compilateur fera l'inférence de type. ~~ Lorsqu'il n'y a qu'un seul argument, il n'est pas nécessaire de retourner, de mettre l'argument (), d'écrire le processus {}, etc. ~~ ※correction {} Et return peut être omis s'il n'y a qu'une seule instruction dans {} qui est return ~. Le nombre d'arguments n'a pas d'importance.
Une classe anonyme est une classe locale qui implémente une interface, en omettant la partie déclaration. Les expressions Lambda vous permettent d'écrire de manière concise et claire sans utiliser de classes anonymes.
Par exemple, si vous avez la classe anonyme suivante:
main.java
interface InterfaceTest{
//Méthode abstraite
public String name(String name);
}
public class Main {
public static void main(String[] args) {
//Comment écrire en utilisant une classe anonyme
InterfaceTest greeting = new InterfaceTest() {
//passer outre
public String name(String name) {
return "Hello " + name;
}
};
System.out.println(greeting.name("momoji"));
}
}
Dans ce qui précède, il semble que vous créez une instance d'une interface, mais que vous créez en fait une instance d'une classe anonyme avec une interface.
Résultat de l'exécution ↓
Hello momoji
Réécrivons cela avec une expression lambda.
main.java
interface InterfaceTest{
//Méthode abstraite
public String name(String name);
}
public class Main {
public static void main(String[] args) {
//Comment écrire à l'aide d'une expression lambda
InterfaceTest greeting = (name) -> {
return "Hello " + name;
};
System.out.println(greeting.name("momoji"));
}
}
Le traitement du contenu à effectuer par la méthode de salutation est décrit dans {}. C'est plus court et il est plus facile de voir ce que vous faites. De plus, vous n'avez plus à spécifier le type d'argument.
Résultat de l'exécution ↓
Hello momoji
Java a les mêmes propriétés que l'instruction for-each et il existe une instruction for étendue. Il a la propriété d'effectuer le traitement spécifié pour tous les éléments d'un tableau ou d'une liste.
Comment écrire une instruction for étendue
for (Nom de la variable de type de données:liste et tableau){
En traitement;
...
}
Pour afficher tous les éléments de la liste dans l'ordre, écrivez l'instruction for étendue comme suit.
main.java
main.java
class Main {
public static void main (String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//Étendu pour déclaration
for(String l : list) {
System.out.println(l);
}
}
}
Dans l'exemple ci-dessus ① Définissez une liste de type String "list" (2) Utilisez la méthode add pour remplir la liste avec les éléments "a", "b" et "c" un par un. (3) Sortez les éléments de la liste un par un en utilisant l'instruction for étendue.
Je fais ça.
Le résultat de l'exécution est le suivant.
a
b
c
Cela peut être rendu encore plus court avec les expressions lambda et les instructions forEach.
main.java
class Main {
public static void main (String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//Étendu pour déclaration
// for(String l : list) {
// System.out.println(l);
// }
//Pour chaque instruction utilisant l'expression lambda
list.forEach(l -> System.out.println(l));
}
}
Résultat de l'exécution ↓
a
b
c
J'ai pu adapter ce que j'écrivais en exerçant 3 sur une ligne. Cela peut être rendu encore plus court en utilisant des "références de méthode".
Il s'agit également d'une notation introduite à partir de Java 8. Une référence de méthode est un mécanisme qui vous permet de faire référence à une méthode en tant qu'argument de la méthode. Vous pouvez appeler des méthodes prédéfinies sans arguments.
La référence de la méthode est écrite comme suit.
nom de la classe::Nom de la méthode
Après le nom de la classe, écrivez "::" et le nom de la méthode que vous souhaitez appeler. Aucun () n'est requis dans le nom de la méthode.
Je vais essayer de le combiner avec le type lambda à la fois.
main.java
//Expression Lambda avec référence de méthode
list.forEach(System.out::println);
Résultat de l'exécution ↓
a
b
c
La combinaison des expressions lambda et des références de méthodes a permis d'écrire beaucoup plus court.
Recommended Posts