Comment utiliser les expressions lambda en Java8

La fonctionnalité d'apprentissage la plus intéressante de Java8 est les expressions Lambda. L'article suivant vous présente principalement les informations pertinentes sur l'utilisation des expressions lambda dans le didacticiel d'apprentissage Java8. L'article le présente en détail à travers un exemple de code. utile pour votre apprentissage ou Le travail a une certaine valeur de référence et d'apprentissage. Les amis qui en ont besoin peuvent suivre l'éditeur pour apprendre ensemble.

Préface

Dans l'article précédent, nous avons présenté la syntaxe des expressions lambda, présenté les scénarios d'utilisation des expressions lambda et les avantages de l'utilisation expressions lambda. Dans cet article, nous expliquerons avec des exemples comment définir et utiliser les expressions lambda, ainsi que les spécifications particulières des expressions lambda en Java par rapport à d'autres langages.

Exemple d'utilisation de classes internes anonymes

Tout d'abord, précisons qu'avant l'avènement de Java8, ce que pouvaient faire les expressions lambda était d'utiliser des classes internes. Cela peut être fait, les expressions lambda simplifient simplement la programmation.
L'exemple suivant sélectionne les lecteurs dans une liste en fonction de conditions.

Définir TantanitReader :

public class TantanitReader {
 private int age;
 private String loginName;
 private String realName;
 private String career;

 public TantanitReader() {
 }

 public TantanitReader(int age, String loginName, String realName, String career) {
 this.age = age;
 this.loginName = loginName;
 this.realName = realName;
 this.career = career;
 }

 public int getAge() {
 return age;
 }

 public void setAge(int age) {
 this.age = age;
 }

 public String getLoginName() {
 return loginName;
 }

 public void setLoginName(String loginName) {
 this.loginName = loginName;
 }

 public String getRealName() {
 return realName;
 }

 public void setRealName(String realName) {
 this.realName = realName;
 }

 public String getCareer() {
 return career;
 }

 public void setCareer(String career) {
 this.career = career;
 }

 @Override
 public String toString() {
 return "age:"+this.getAge()+",loginName:"+this.loginName
 +",realName:"+this.getRealName()+",career:"+this.getCareer();
 }
}

Définir l'interface de jugement :

public interface Predicate<T> {
 boolean test(T t);
}

Définir la fonction de sélection :

public class SelectService<T> {
 public List<T> select(Collection<T> source, Predicate<T> predicate){
 List result = new LinkedList();
 for(T element:source){
  if (predicate.test(element)) {
  result.add(element);
  }
 }
 return result;
 }

}

Écrire un exemple de test, de sélection de lecteurs adultes et de lecteurs adolescents (dont 10 ans) :

public class TantanitReaderPredicateTest {


 public static void main(String[] args) {
 SelectService tantanitReaderSelectSerive
 =new SelectService<TantanitReader>();
 List<TantanitReader> source = new LinkedList<>();
 source.add(new TantanitReader(10,"jack","张三","学生"));
 source.add(new TantanitReader(18,"rose","李四","学生"));
 source.add(new TantanitReader(19,"mike","王五","程序员"));
 source.add(new TantanitReader(20,"jack","赵六","作家"));

 List<TantanitReader> audultReaders
 =tantanitReaderSelectSerive.select(source, new Predicate() {
  @Override
  public boolean test(Object o) {
  TantanitReader tantanitReader=(TantanitReader)o;
  return tantanitReader.getAge()>=18;
  }
 });
 System.out.println("tantanit.com 成年读者名单如下：");
 printTantanitReaders(audultReaders);

 System.out.println("tantanit.com 十多岁（包含 10 岁）成员如下：");
 List<TantanitReader> teenReaders
 =tantanitReaderSelectSerive.select(source, new Predicate() {
  @Override
  public boolean test(Object o) {
  TantanitReader tantanitReader=(TantanitReader)o;
  return tantanitReader.getAge()>=10 && tantanitReader.getAge()<=19;
  }
 });
 printTantanitReaders(teenReaders);
 }


 public static void printTantanitReaders(List<TantanitReader> tantanitReaders) {
 for (TantanitReader tantanitReader : tantanitReaders) {
  System.out.println(tantanitReader.toString());
 }
 }


}

Après exécution, le résultat de l'impression est le suivant :

tantanit.com 成员读者名单如下：
age:18,loginName:rose,realName: 李四,career: 学生 
age:19,loginName:mike,realName: 王五,career: 程序员
age:20,loginName:jack,realName: 赵六,career: 作家
tantanit.com 十多岁（包含10 岁）成员如下：
age:10,loginName:jack,realName: 张三,career: 学生
age:18,loginName:rose,realName: 李四,career: 学生
age:19,loginName:mike,realName: 王五,career: 程序员

Comme vous pouvez le constater , il y a deux sélections. Les lecteurs ont besoin de new Predicate() et remplacent la méthode de test. La vraie différence réside en fait uniquement dans les déclarations de jugement :

tantanitReader.getAge()>=18

et

.

tantanitReader.getAge()>=10 && tantanitReader.getAge()<=19

Mais avant Java8, comme il n'y avait pas d'expressions lambda, nous ne pouvions que tolérer cette redondance. Comment utiliser les expressions lambda pour simplifier le code ?

Afin de prendre en compte les habitudes de programmation existantes des développeurs Java, contrairement à d'autres langages, Java8 stipule que les interfaces doivent toujours être utilisées lors de la conception du mécanisme d'utilisation des expressions lambda, et l'interface utilisée doit être fonctionnelle interface , dans cet exemple, on peut toujours utiliser :

public interface Predicate<T> {
 boolean test(T t);
}

car cette interface n'a qu'une seule méthode abstraite (java8 a introduit la méthode par défaut, la méthode par défaut a une méthode spécifique implémentation, ne compte pas comme méthode abstraite), c'est donc une interface fonctionnelle. Les interfaces fonctionnelles peuvent être déclarées avec @FunctionalInterface ou non. Mais après l'avoir ajouté, le compilateur vérifiera si l'interface est conforme à la définition d'interface fonctionnelle lors de la phase de compilation, nous définissons donc ici une nouvelle interface et ajoutons la déclaration @FunctionalInterface :

@FunctionalInterface
public interface PredicateFunction<T> {
 boolean test(T t);
}

Et ajoutez une méthode avec PredicateFunction comme paramètre à SelectService :

public List<T> select(Collection<T> source, PredicateFunction<T> predicate){
 List result = new LinkedList();
 for(T element:source){
 if (predicate.test(element)) {
  result.add(element);
 }
 }
 return result;
}

Modifiez l'exemple de test :

public class TantanitReaderPredicateFunctionTest {

 public static void main(String[] args) {
 SelectService tantanitReaderSelectSerive
 =new SelectService();
 List source = new LinkedList<>();
 source.add(new TantanitReader(10,"jack","张三","学生"));
 source.add(new TantanitReader(18,"rose","李四","学生"));
 source.add(new TantanitReader(19,"mike","王五","程序员"));
 source.add(new TantanitReader(20,"jack","赵六","作家"));

 PredicateFunction predicateFunction
  = (TantanitReader tantanitReader) -> tantanitReader.getAge() >= 18;
 List audultReaders
 =tantanitReaderSelectSerive.select(source,predicateFunction);

 System.out.println("tantanit.com 成员读者名单如下：");
 printTantanitReaders(audultReaders);

 System.out.println("tantanit.com 十多岁（包含 10 岁）成员如下：");
 PredicateFunction predicateFunction2
 = (TantanitReader tantanitReader)
 -> tantanitReader.getAge()>=10 && tantanitReader.getAge()<=19;
 List teenReaders
 =tantanitReaderSelectSerive.select(source,predicateFunction2);
 printTantanitReaders(teenReaders);
 }


 public static void printTantanitReaders(List tantanitReaders) {
 for (TantanitReader tantanitReader : tantanitReaders) {
  System.out.println(tantanitReader.toString());
 }
 }

}

Analysons le fonctionnement de ce code :

PredicateFunction<TantanitReader> predicateFunction
 = (TantanitReader tantanitReader) -> tantanitReader.getAge() >= 18;
List<TantanitReader> audultReaders
=tantanitReaderSelectSerive.select(source,predicateFunction);

Ce code génère une instance de type PredicateFunction, et passe la référence de l'instance en tant que paramètre à la méthode select de tantanitReaderSelectSerive et exécutez la méthode select. Lors de l'exécution de select, la méthode de test de predicateFunction est appelée et le contenu de la méthode de test est l'expression lambda que nous avons transmise. Enfin, le lecteur est sélectionné en fonction de l'expression lambda.

Pour aller plus loin, vous ne pouvez généralement pas définir la variable predicateFunction, mais passer directement l'expression lambda en paramètre à la méthode select de tantanitReaderSelectSerive, comme ceci :

List<TantanitReader> audultReaders
=tantanitReaderSelectSerive.select(
 source,(TantanitReader tantanitReader) -> tantanitReader.getAge() >= 18
);

Mais dans cet exemple, une erreur de compilation sera en fait signalée, indiquant que les définitions des méthodes select de TantanitReader et tantanitReaderSelectSerive ne correspondent pas car la méthode select utilise des génériques. La documentation de Java 8 stipule que lors de l'utilisation de génériques, les expressions lambda ne peuvent pas être utilisées directement comme paramètres, ce qui est assez embarrassant. Si vous n’utilisez pas de génériques, il n’y aura pas ce problème.

Résumé

Ce qui suit résume comment utiliser les expressions lambda

• Tout d'abord, définissez une fonction Interface fonctionnelle et définir les méthodes abstraites à utiliser dans l'interface.

• Écrivez une méthode métier, prenez l'interface fonctionnelle comme paramètre et appelez la méthode définie par l'interface pour compléter la logique métier.

• Appelez la méthode métier et transmettez l'expression lambda en paramètre.

Si des génériques sont utilisés, la dernière étape consiste à définir d'abord une référence à une instance de l'interface fonctionnelle puis à la transmettre en paramètre à la méthode métier.

De plus, les expressions lambda peuvent continuer à être simplifiées en références de fonctions, ce qui sera expliqué dans un article ultérieur.

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!