Expression lambda Java à nouveau

introduction

Cela fait un peu plus de deux ans que je me suis lancé dans l'industrie informatique. Pour être honnête, je travaille sérieusement sur le codage depuis seulement un peu plus d'un an. En même temps, du fait de l'exploitation et de la maintenance, il a vécu dans un monde positif pour valoriser les implémentations existantes afin de ne pas les polluer autant que possible. Et après tout, le JDK utilisé dans ce package est java 1.7! !! Dans le contexte ci-dessus, j'ai rarement abordé java8 ou une version ultérieure, je voulais donc le réapprendre. Tout en servant également de mémorandum, je voudrais commencer à écrire pour Qiita sérieusement à l'avenir, alors j'ai décidé d'écrire cette fois.

Dans un premier temps, ma compréhension de l'expression lambda était vague, je voudrais donc approfondir ma compréhension à travers l'article.

Qu'est-ce qu'un style lambda? ⇨ Qu'est-ce qu'une interface?

Avant de comprendre soudainement les expressions lambda, il semble que certaines connaissances préalables sur les interfaces fonctionnelles soient nécessaires. Alors qu'est-ce qu'une interface en premier lieu? Je ne peux pas répondre clairement à la question. N'ayez pas peur d'acquérir une solide compréhension des interfaces Java.

Qu'est-ce qu'une interface en Java?

Je pense que les articles suivants sont faciles à comprendre et utiles. https://www.internetacademy.jp/it/programming/java/difference-between-interface-and-abstract.html

Une interface ne prépare qu'une boîte de méthodes, et lorsque la boîte est effectivement utilisée (héritage), la classe héritée est obligée de l'implémenter. Par exemple, considérons une situation où ʻEmployeeService est implémenté en tant que classe de service pour une entité appelée ʻEmployee.

EmployeeService.java

interface EmployeeService {
     Employee getEmployee(String pk);
}

Une implémentation courante (cas utilisé) de la classe Service consiste à implémenter l'interface Service et à exposer uniquement les méthodes au monde extérieur. Créez ʻEmployeeServiceImpl comme une autre classe comme classe d'implémentation de ʻEmployeeService.

EmployeeServiceImpl.java

public class EmployeeServiceImpl implements EmployeeService {
     Employee getEmployee(String pk) {
          //Allez à Dao et obtenez l'employé qui correspond à pk.
          return employeeDao.find(pk); 
     }
}

L'important ici est que ce ʻEmployeeServiceImpl hérite de ʻEmployeeService. Cela signifie que vous devez implémenter getEmployee déclaré dans ʻEmployeeService`. En faisant cela, la classe d'implémentation qui hérite de l'interface doit implémenter la méthode déclarée dans l'interface, ce qui entraîne une erreur de compilation, et l'implémentation peut être forcée.

La plus grande différence entre une classe abstraite et une interface est qu'elle peut être héritée plusieurs fois. Je n'entrerai pas dans les détails sur l'héritage multiple, mais le fait est que vous pouvez utiliser un mécanisme qui force plusieurs implémentations dans une interface. (Une classe peut hériter de plusieurs interfaces.)

Qu'est-ce qu'un style lambda? ⇨ Qu'est-ce qu'une interface fonctionnelle? ⇨ Qu'est-ce qu'une fonction?

Je comprends l'interface. Je comprends, mais j'ai encore suffisamment de connaissances pour comprendre la formule lambda. Qu'est-ce qu'une interface fonctionnelle? Hmm, qu'est-ce qu'un «type de fonction»? Hmm, qu'est-ce qu'une «fonction»?

Qu'est-ce qu'une fonction en Java?

L'URL suivante sera utile pour ce qu'est une fonction. https://stackoverflow.com/questions/155609/whats-the-difference-between-a-method-and-a-function

En bref, une fonction est `Celui qui reçoit un certain paramètre (argument), effectue un traitement basé sur l'argument et renvoie la valeur du résultat (retour). ''

Il y a quelques points à prendre en compte lors de l'implémentation d'une fonction, je vais donc les présenter ici. Si vous programmez dans un langage comme Java, vous entendrez tôt ou tard le mot «effets secondaires». Les effets secondaires sont super simples et à peu près ... Je comprends qu'il s'agit d'une implémentation dans laquelle le résultat d'exécution d'une fonction n'est pas toujours constant.

Voici quelques éléments à garder à l'esprit pour implémenter une fonction sans effets secondaires:

1. La fonction n'est affectée par rien d'autre que la valeur de l'argument.
2. Si les valeurs du même argument sont utilisées, la même valeur est toujours renvoyée.

Veuillez vérifier séparément les exemples de mise en œuvre spécifiques. (Il y a 50000 articles qui expliquent mieux que moi.)

Pour revenir à l'histoire, une fonction est, après tout, une valeur qui renvoie une valeur d'entrée.

Qu'est-ce qu'une fonction? ⇨ Qu'est-ce qu'une interface fonctionnelle?

J'ai eu une idée approximative des fonctions. Alors, qu'est-ce qu'une interface fonctionnelle? Déplaçons le sujet vers l'histoire. Les articles suivants sont très utiles, je vais donc les décrire. http://www.ne.jp/asahi/hishidama/home/tech/java/functionalinterface.html#h_outline

Comme mentionné dans cet article, qu'est-ce qu'une interface fonctionnelle?

Une interface avec une seule méthode abstraite définie.

à propos de ça.

Le «Service des employés» présenté dans cet article peut être appelé une interface fonctionnelle. Une classe Service qui récupère et retourne uniquement ʻEmployee qui correspond à pk`.

EmployeeService.java

@FunctionalInterface
public interface EmployeeService {
	Employee getEmployee(String pk);
}

Le point de définir une interface fonctionnelle est l'annotation «@ FunctionalInterface». En ajoutant cette annotation, il est possible de déclarer explicitement qu'il s'agit d'une interface fonctionnelle, et une erreur se produira si les conditions ne sont pas remplies même au moment de la compilation. Aussi, en ajoutant cette annotation même en suivant l'implémentation, il sera plus facile pour les autres de comprendre qu'il s'agit d'une interface fonctionnelle.

• Même si les méthodes "default" et "static" sont définies, elles semblent exclues des conditions de l'interface fonctionnelle.

Qu'est-ce qu'une interface fonctionnelle? ⇨ Qu'est-ce qu'une expression lambda?

À partir de JDK1.8, les interfaces fonctionnelles (interfaces qui ne contiennent qu'une seule méthode abstraite) sont traitées comme spéciales. Eh bien, je suis enfin revenu sur le sujet principal de cet article. Quel est le type lambda après tout à partir d'ici? Je vais essayer de découvrir.

L'article suivant est très facile à comprendre et est utile car il illustre l'expression lambda. http://masatoshitada.hatenadiary.jp/entry/2015/02/09/190150

Après tout, afin de comprendre les expressions lambda, je pense qu'il est préférable de comprendre "l'inférence de type" en utilisant "Function" comme exemple.

Qu'est-ce qu'un style lambda? ⇨ Qu'est-ce que la fonction? Qu'est-ce que l'inférence de type?

Function est un package introduit dans Java 8. Le type est défini par Function <T, R>, T est le type qui est l'argument et R est le type qui est retourné comme valeur de retour. Donc, cette Fonction est définie comme une interface fonctionnelle et n'a qu'une méthode appelée ʻapply`.

Vous pouvez utiliser des expressions lambda pour implémenter Function. Un exemple de mise en œuvre simple est présenté ci-dessous. Exemple) Obtenez le Nom de ʻEmployee en utilisant Function`.

Employee.java

@Getter
@Setter
@AllArgsConstructor(staticName = "of")
public class Employee {
	/** Id */
	private int id;
	
	/** Name */
	private String name;
}

Main.java

pubic class Main {
	public static void main(String args[]){
		Employee emp = Employee.of(1, "Échantillon de taro")
		Function<Employee, String> getEmployeeName = employee -> employee.getName();
		String empName = getEmployeeName.apply(emp);
		System.out.println(empName); //"Sample Taro" est sorti.
	}
} 

• Veuillez aimer la voix que vous pouvez utiliser Getter si vous supprimez Nom.

Voici le point important de l'exemple ci-dessus.

Function<Employee, String> getEmployeeName = employee -> employee.getName();

Function a le processus de retour du type de chaîne ( String) qui est le résultat de ʻemployee.getName () comme valeur de retour du type (ʻEmployee) qui est l'argument de Function. Implémentez-le dans une méthode appelée ʻapply`. Cela se fait en utilisant la formule lambda.

Java interprète «employé» comme «Employé», qui est «T» dans l'inférence de type », et Java interprète que la valeur à« retourner »dans« l'inférence de type »est« String ». (C'est intelligent ...)

String empName = getEmployeeName.apply(emp);

Et en fait, dans la partie ci-dessus, appliquez ʻapply of Function à ʻempName of String.

Les expressions lambda ont l'avantage de simplifier la description des interfaces fonctionnelles.

Qu'est-ce qu'un style lambda?

Après tout, l'expression lambda que j'ai comprise est une expression pratique qui utilise pleinement l'inférence de type pour simplifier la mise en œuvre lors de la mise en œuvre d'une interface fonctionnelle. Les scènes d'utilisation du type lambda seul sont limitées, et je me demande si le type lambda montre vraiment tout son potentiel lorsqu'il est combiné avec Function et stream. Il n'est pas toujours nécessaire de connaître cette expression lambda lors de l'utilisation de stream, mais il serait intéressant de la comprendre.

en conclusion

Je pense ré-apprendre ʻOptional, mais il semble que l'expression lambda (ou plutôtConsumer`) soit impliquée. Ecrire un article améliorera votre compréhension + ce sera un rappel, donc j'aimerais continuer à écrire activement à l'avenir.

Si vous avez des erreurs ou des conseils, laissez un commentaire ...!

La prochaine fois, j'aimerais écrire un article sur «Optionnel». A bientôt ~