Ce document vise à présenter java 8 et lambda expression.
Les points abordés sont les interfaces fonctionnelles, fonction d'ordre supérieur, lambda expression, référence de méthode et méthode par défaut. Chaque notion est accompagnée par des exemples. Les codes sources seront disponibles sur git.
Support formation vidéo : OCA Java SE 8 Programmer (1Z0-808) (1)SmartnSkilled
Préparez-vous à l'examen 1Z0-808 et obtenez la certification OCA Java SE 8 Programmer.
Cette formation vidéo va vous permettre de :
- Réussir la certification Java SE 8 Oracle Certified Associate (OCA), en passant l'examen 1Z0-808.
- Comprendre et appliquer les concepts objets au langage Java (classes, méthodes, encapsulation, héritage, constructeur, polymorphisme, classe abstraite, etc.)
- Connaître et savoir utiliser les types de données du langage Java,
- Maîtriser la syntaxe Java (boucle, test, types, opérateurs, etc.),
- Gérer les exceptions en Java,
- Créer des packages Java et les déployer.
Suivez la formation vidéo par ici : https://www.smartnskilled.com/tutoriel/formation-en-ligne-oca-java-se-8-programmer-1z0-808
Les primitives java, conditions, boucles..
Object, classes, Carcatéristiques...
Héritage et accessibilité (package, visibilité)
polymorphisme
Tableau et collections
Connexion base de données via JDBC
Spring Web MVC is the original web framework built on the Servlet API and has been included in the Spring Framework from the very beginning. The formal name, “Spring Web MVC,” comes from the name of its source module (spring-webmvc), but it is more commonly known as “Spring MVC”.
Parallel to Spring Web MVC, Spring Framework 5.0 introduced a reactive-stack web framework whose name, “Spring WebFlux,” is also based on its source module (spring-webflux). This section covers Spring Web MVC.
Support formation vidéo : OCA Java SE 8 Programmer (1Z0-808) (1)SmartnSkilled
Préparez-vous à l'examen 1Z0-808 et obtenez la certification OCA Java SE 8 Programmer.
Cette formation vidéo va vous permettre de :
- Réussir la certification Java SE 8 Oracle Certified Associate (OCA), en passant l'examen 1Z0-808.
- Comprendre et appliquer les concepts objets au langage Java (classes, méthodes, encapsulation, héritage, constructeur, polymorphisme, classe abstraite, etc.)
- Connaître et savoir utiliser les types de données du langage Java,
- Maîtriser la syntaxe Java (boucle, test, types, opérateurs, etc.),
- Gérer les exceptions en Java,
- Créer des packages Java et les déployer.
Suivez la formation vidéo par ici : https://www.smartnskilled.com/tutoriel/formation-en-ligne-oca-java-se-8-programmer-1z0-808
Les primitives java, conditions, boucles..
Object, classes, Carcatéristiques...
Héritage et accessibilité (package, visibilité)
polymorphisme
Tableau et collections
Connexion base de données via JDBC
Spring Web MVC is the original web framework built on the Servlet API and has been included in the Spring Framework from the very beginning. The formal name, “Spring Web MVC,” comes from the name of its source module (spring-webmvc), but it is more commonly known as “Spring MVC”.
Parallel to Spring Web MVC, Spring Framework 5.0 introduced a reactive-stack web framework whose name, “Spring WebFlux,” is also based on its source module (spring-webflux). This section covers Spring Web MVC.
Voici le chapitre 6 sur les classes et les interfaces en Java.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Découvrez le framework web Spring Boot qui a la cote !
Apprenez comment son système d'auto-configuration fonctionne.
Live coding et exemple de migration vers Spring Boot sont de la partie.
Les slides de ma présentation à Devoxx France 2017.
Introduite en Java 8, l'API Collector vit dans l'ombre de l'API Stream, ce qui est logique puisqu'un collecteur doit se connecter à un stream pour fonctionner. Le JDK est organisé de sorte que l'on utilise surtout les collectors sur étagère : groupingBy, counting et quelques autres. Ces deux éléments masquent non seulement le modèle de traitement de données des collectors, mais aussi sa puissance et ses performances.
Ces présentation parle des collectors qui existent et qu'il faut connaître, ceux que l'on peut créer, ceux dont on se doute que l'on peut les créer une fois que l'on comprend un peu les choses, et les autres, tant les possibilités offertes par cette API sont illimitées.
The Spring IoC container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.
Ce Support de cours Spring contient :
- Architecture JEE (Over view)
- Spring Overview
- Spring IOC
- Spring MVC
- Spring Integration (RMI, JaxWS, JaxRS, JMS, JMX,...)
- Spring Security
Bon apprentissage à tous
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Ce étude vise à présenter la platforme Spark et les opérations (Transformation et Action) d'une RDD. Les points abordés sont Spark motivation, Positionnement de Spark dans l'écosystème BigData, Composants de Spark, Drivers et Workers, RDD & caractéristiques, vue logique de spark, vue globale sur les APIs Spark (dépendance et interaction), les différentes opérations de spark. Chaque opération est sur une fiche (objectif, signature, "à retenir" et exemple de code).
Cette étude porte sur la brique Spark SQL de la plateforme Apache Spark.
L'objectif est de présenter les concepts et les fonctionnalités de spark SQL.
Les points abordés sont :
- Architecture
- API de Spark SQL
- Opérations sur DataFrames/DataSets
- Opérations relatives au nettoyage de données
- Opérations de conversion (DataFrame, DataSet, Collection, RDD)
- Opérations relationnelles
Voici le chapitre 6 sur les classes et les interfaces en Java.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Découvrez le framework web Spring Boot qui a la cote !
Apprenez comment son système d'auto-configuration fonctionne.
Live coding et exemple de migration vers Spring Boot sont de la partie.
Les slides de ma présentation à Devoxx France 2017.
Introduite en Java 8, l'API Collector vit dans l'ombre de l'API Stream, ce qui est logique puisqu'un collecteur doit se connecter à un stream pour fonctionner. Le JDK est organisé de sorte que l'on utilise surtout les collectors sur étagère : groupingBy, counting et quelques autres. Ces deux éléments masquent non seulement le modèle de traitement de données des collectors, mais aussi sa puissance et ses performances.
Ces présentation parle des collectors qui existent et qu'il faut connaître, ceux que l'on peut créer, ceux dont on se doute que l'on peut les créer une fois que l'on comprend un peu les choses, et les autres, tant les possibilités offertes par cette API sont illimitées.
The Spring IoC container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.
Ce Support de cours Spring contient :
- Architecture JEE (Over view)
- Spring Overview
- Spring IOC
- Spring MVC
- Spring Integration (RMI, JaxWS, JaxRS, JMS, JMX,...)
- Spring Security
Bon apprentissage à tous
Ce Support explique quelques concepts de base de NodeJS et montre comment mettre en oeuvre la technologie NodeJS pour développer la partie Backend d'une application.
Les vidéos des démonstrations sont publiées sur les adresse suivantes :
- https://www.youtube.com/watch?v=-X_C1tS5-9Y
- https://www.youtube.com/watch?v=rE-xRH28m0s
- https://www.youtube.com/watch?v=tnxjkTvWoKA
Cette série explique les éléments suivants :
- Architecture Web
- Modèles Multi-Threads avec les entrées sorties bloquantes
- Modèles Single Thread avec les entrées sortie non bloquantes
-Technologie Node JS
- Comment créer une simple application Node JS avec java Script
- Architecture du Framwork Express
- Comment créer une application NodeJS avec Type Script
- Comment écrire des tests unitaires avec Jest
- Quelques concepts sur MongoDb
- Comment Créer une API Rest avec NodeJS, Express et MongoDb
- Comment tester l'API Rest
- Comment Créer la partie FrontEnd avec Angular.
Même si la qualité audio n'est pas bonne, ses vidéos peuvent aider ceux qui débutent dans NodeJS en attendant d'autres vidéos avec plus qualité audio et de contenu.
Bonne lecture
Ce étude vise à présenter la platforme Spark et les opérations (Transformation et Action) d'une RDD. Les points abordés sont Spark motivation, Positionnement de Spark dans l'écosystème BigData, Composants de Spark, Drivers et Workers, RDD & caractéristiques, vue logique de spark, vue globale sur les APIs Spark (dépendance et interaction), les différentes opérations de spark. Chaque opération est sur une fiche (objectif, signature, "à retenir" et exemple de code).
Cette étude porte sur la brique Spark SQL de la plateforme Apache Spark.
L'objectif est de présenter les concepts et les fonctionnalités de spark SQL.
Les points abordés sont :
- Architecture
- API de Spark SQL
- Opérations sur DataFrames/DataSets
- Opérations relatives au nettoyage de données
- Opérations de conversion (DataFrame, DataSet, Collection, RDD)
- Opérations relationnelles
Scala: Pattern matching, Concepts and ImplementationsMICHRAFY MUSTAFA
In the following slides, we attempt to present the pattern matching and its implementation in Scala.
The concepts introduced are: Basic pattern matching, Pattern alternative, Pattern guards, Pattern matching and recursive function, Typed patterns, Tuple patterns, Matching on option, Matching on immutable collection, Matching on List, Matching on case class, Nested pattern matching in case classes, and
Matching on regular expression.
Apache SPARK ML : principes, concepts et mise en œuvre MICHRAFY MUSTAFA
Cette étude vise à présenter les concepts et les étapes pour la mise en œuvre d’une méthode d’apprentissage dans le cadre de Spark ML (API de méthodes d'apprentissage en SPARK) :
1. Spark ML : motivations
2. Transformateurs et estimateurs
3. Concepts de Pipeline
4. Évaluation d’une méthode d’apprentissage
5. Validation croisée et sélection des variables
6. Mise en œuvre des concepts sous Spark ML
Ce document vise à présenter la programmation fonctionnelle sous Scala.
Les points abordés sont le paradigme fonctionnel, fonction anonyme, fonction d’ordre supérieur, Clôture, fonction partielle, la récursivité, Curryfication. Chaque notion est accompagnée par des exemples.
Base de données graphe, Noe4j concepts et mise en oeuvreMICHRAFY MUSTAFA
Cette étude vise à présenter les concepts clés d’une base de données orientée graphe. La modélisation et la mise en œuvre des cas d’utilisation seront réalisées avec la base de données NEO4J, version 3.1.
Les fondements de la Programmation neurolinguistique (PNL)khalil michrafy
Cette étude porte sur les fondements de la Programmation neurolinguistique (PNL).
Les points abordés sont :
- Qu’est ce que la PNL ?
- Les quatre piliers de la PNL
- Le modèle des niveaux logiques
- Les présupposés de la PNL
Big Data: Concepts, techniques et démonstration de Apache Hadoophajlaoui jaleleddine
C'est une initiation au Big Data, qui est présenté dans un workshop organisé en 12 Décembre 2015 par un club TB3C (Tunisian Big Data Cloud Computing Community) au sein de ISSAT de Sousse
Paco Nathan has received certification as an Apache Spark 1.1.0 developer from Databricks and O'Reilly Media. The certification verifies that Paco Nathan has successfully completed the requirements to be considered a certified Apache Spark developer. The certification is valid and was issued on November 4, 2016.
Structured Streaming in Apache Spark 2.0 introduces a continuous data flow programming model. It processes live data streams using a streaming query that is expressed similarly to batch queries on static data. The streaming query continuously appends incoming data to an unbounded table and performs incremental aggregations. This allows for exactly-once processing semantics without users needing to handle micro-batching or fault tolerance. Structured Streaming queries can be written using the Spark SQL DataFrame/Dataset API and output to sinks like files, databases, and dashboards. It is still experimental but provides an alternative to the micro-batch model of earlier Spark Streaming.
Structuring Spark: DataFrames, Datasets, and Streaming by Michael ArmbrustSpark Summit
This document summarizes Spark's structured APIs including SQL, DataFrames, and Datasets. It discusses how structuring computation in Spark enables optimizations by limiting what can be expressed. The structured APIs provide type safety, avoid errors, and share an optimization and execution pipeline. Functions allow expressing complex logic on columns. Encoders map between objects and Spark's internal data format. Structured streaming provides a high-level API to continuously query streaming data similar to batch queries.
http://flink-forward.org/kb_sessions/declarative-stream-processing-with-streamsql-and-cep/
Complex event processing (CEP) and stream analytics are commonly treated as distinct classes of stream processing applications. While CEP workloads identify patterns from event streams in near real-time, stream analytics queries ingest and aggregate high-volume streams. Both types of use cases have very different requirements which resulted in diverging system designs. CEP systems excel at low-latency processing whereas engines for stream analytics achieve high throughput. Recent advances in open source stream processing yielded systems that can process several millions of events per second at sub-second latency. Systems like Apache Flink enable applications that include typical CEP features as well as heavy aggregations. In this talk we will show how Apache Flink unifies CEP and stream analytics workloads. Guided by examples, we introduce Flink’s CEP-enriched StreamSQL interface and discuss how queries are compiled, optimized, and executed on Flink.
Big Data, Hadoop, Hortonworks and Microsoft HDInsightHortonworks
Big Data is everywhere. And at the center of the big data discussion is Apache Hadoop, a next-generation enterprise data platform that allows you to capture, process and share the enormous amounts of new, multi-structured data that doesn’t fit into transitional systems.
With Microsoft HDInsight, powered by Hortonworks Data Platform, you can bridge this new world of unstructured content with the structured data we manage today. Together, we bring Hadoop to the masses as an addition to your current enterprise data architectures so that you can amass net new insight without net new headache.
The document discusses lessons learned from building a real-time data processing platform using Spark and microservices. Key aspects include:
- A microservices-inspired architecture was used with Spark Streaming jobs processing data in parallel and communicating via Kafka.
- This modular approach allowed for independent development and deployment of new features without disrupting existing jobs.
- While Spark provided batch and streaming capabilities, managing resources across jobs and achieving low latency proved challenging.
- Alternative technologies like Kafka Streams and Confluent's Schema Registry were identified to improve resilience, schemas, and processing latency.
- Overall the platform demonstrated strengths in modularity, A/B testing, and empowering data scientists, but faced challenges around
The document is a presentation on Apache Spark and Scala. It introduces key concepts like Big Data, Spark, and Spark's features. It describes Spark's ecosystem including Spark Streaming, MLlib, and GraphX. It also provides an overview of Scala, why it is used with Spark, and demonstrates a Spark Streaming program to count lines with the word "FATAL". The presentation aims to explain Spark and Scala concepts and their use in Big Data applications.
Spark, ou comment traiter des données à la vitesse de l'éclairAlexis Seigneurin
Spark fait partie de la nouvelle génération de frameworks de manipulation de données basés sur Hadoop. L’outil utilise agressivement la mémoire pour offrir des temps de traitement jusqu’à 100 fois plus rapides qu'Hadoop. Dans cette session, nous découvrirons les principes de traitement de données (notamment MapReduce) et les options mises à disposition pour monter un cluster (Zookeper, Mesos…). Nous ferons un point sur les différents modules proposés par le framework, et notamment sur Spark Streaming pour le traitement de données en flux continu.
Présentation jouée chez Ippon le 11 décembre 2014.
Kerberos is the system which underpins the vast majority of strong authentication across the Apache HBase/Hadoop application stack. Kerberos errors have brought many to their knees and it is often referred to as “black magic” or “the dark arts”; a long-standing joke that there are so few who understand how it works. This talk will cover the types of problems that Kerberos solves and doesn’t solve for HBase, decrypt some jargon on related libraries and technology that enable Kerberos authentication in HBase and Hadoop, and distill some basic takeaways designed to ease users in developing an application that can securely communicate with a “kerberized” HBase installation.
Présentation des nouveautés apportées par la version 7 du langage C# : Méthodes locales, Tuples, Déconstructeurs, Pattern matching, Variables de sortie, Membres sous forme d’expression, Amélioration de la levée des exceptions, ...
Chapitre 11: Expression Lambda et Référence de méthode en JavaAziz Darouichi
Voici le chapitre 11 sur les expressions lambda et les références de méthodes en Java.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Durant cette session, on va vous montrer les différentes fonctions de la Tooling API avec des cas d'utilisations concrets.
Et vous présentera quelques requêtes SOQL en Tooling API utilisable au quotidien ( Dev ou Admin)
Dans un contexte où la transmission et l'installation d'agriculteurs sont des enjeux cruciaux pour la profession agricole, de nouveaux agriculteurs s'installent chaque année et, parmi eux, certains Bac+5 ou plus. Les cursus des écoles d'ingénieurs n'ont pas vocation à former de futurs agriculteurs. Pourtant, certains apprenants ayant suivi ces cursus BAC + 5, qu'ils soient ou non issus du milieu agricole, tentent l'aventure de l'entrepreneuriat agricole. Qui sont-ils ? Quelles sont leurs motivations et visions ? Comment travaillent-ils ?
Interface fonctionnelle, Lambda expression, méthode par défaut, référence de méthode, avec des exemples
1. JAVA8
INTERFACES FONCTIONNELLES, LAMBDAEXPRESSION, MÉTHODE
PAR DÉFAUTET RÉFÉRENCES DE MÉTHODE,
AVEC DES EXEMPLES
Dr Mustapha Michrafy
M. MICHRAFY
Contact de l’auteur :
datascience.km@gmail.com
datascience.km@gmail.com1
2. Contexte
Cette étude a été présentée dans le cadre
du séminaire « Data Science principes,
méthodes, outils et applications » au
laboratoire Cermsem.
datascience.km@gmail.comM. MICHRAFY 2
3. Plan
• Objectif
• Pré-requis
• Méthode par défaut
• Interface fonctionnelle
• Lambda expression
• API des interfaces fonctionnelles standards
• Référence de méthode
• Références bibliographiques
datascience.km@gmail.comM. MICHRAFY 3
4. Objectif
Cette étude vise à présenter les interfaces
fonctionnelles introduites par Java 8 ainsi
que leur utilisation via les lambda
expressions, les références de méthode et
les méthodes par défaut
datascience.km@gmail.comM. MICHRAFY 4
5. Prérequis
• Connaissance du langage Java
• Connaissance de l’approche objet
• Notions de programmation fonctionnelle
datascience.km@gmail.comM. MICHRAFY 5
6. Motivations
• Java a introduit les interfaces fonctionnelles et les
lambda expressions depuis la version 8.
• Ces nouvelles possibilités du langage permettent :
• de produire du code compact et concis,
• de produire du code lisible et facile à maintenir,
• de dégager la logique applicative (métier) d’un programme.
datascience.km@gmail.comM. MICHRAFY 6
7. Méthode par défaut : principe
• Java 8 offre la possibilité de définir une ou plusieurs
méthodes par défaut dans une interface.
• La méthode par défaut sera appelée ssi la classe
implémentant l’interface ne l’implémente pas.
• Les méthodes par défaut remplacent avantageusement
les classes abstraites en fournissant une implémentation
par défaut de la logique de traitement.
• Les méthodes par défaut permettent au développeur de
librairies de fournir des implémentations par défaut.
• Une méthode par défaut est aussi utile pour partager la
même implémentation entre classes similaires.
datascience.km@gmail.comM. MICHRAFY 7
8. Méthode par défaut : syntaxe (1)
• Pour déclarer une méthode par défaut, il suffit de faire
précéder son nom par « default » et d’en fournir une
implémentation dans l’interface.
Syntaxe :
default typeRetour nomMethode([arguments]) {
Corps
}
Exemples :
• public default boolean check(String x) { … }
• public default int addition(int a, int b) { ... }
datascience.km@gmail.comM. MICHRAFY 8
9. Méthode par défaut : syntaxe (2)
// déclaration d une interface avec méthode par défaut
public Interface nomInterface {
public default valeurRetour nomMethodeParDefaut ([arguments]){ // traitement }
public valeurRetour nomMethode([arguments])
}
// Exemple d’une interfaceavec une méthode par défaut
public interface OperationMath {
// signaturede la méthode operation avec une implémentation par défaut
public default boolean operation(intx, int y){ return x+y; }
}
datascience.km@gmail.comM. MICHRAFY 9
10. Méthode par défaut : utilisation
// déclarationd’une classeA utilisantla méthode par défaut
public classA implements OperationMath{ }
// déclaration d’une classe A qui surcharge la méthode check de l’interface A
public class B implements OperationMath{
public default int operation(nt x, int y){ return x-y ;} // soustraction
}
public static void main(String[] args) { // Appel dans une fonctionmain
A a = new A(); A b = new B(); // créationdes instances de A et B
a.operation(21, 11) ; // appel de la méthode par défaut déclarée dans OperationMath
b.operation(21,11) ; // appel le la méthode de la classe B
}
datascience.km@gmail.comM. MICHRAFY
public interface OperationMath {
// signaturede la méthode operation avec une implémentation par défaut
public default boolean operation(intx, int y){ return x+y; } // addition
}
10
11. Étendre les méthodes par défaut
• La méthode par defaut est considérée comme une methode par
défaut dans l’interface étendue si elle n’a pas été surchargée.
• Il est aussi possible redéfinir la méthode par défaut dans l’interface
fille. Dans ce cas, le qualifiquatif “default” est nécessaire lors de la
déclaration dans l’interface fille.
• Pour annuler le comportement par défaut d’une méthode dans
l’interface fille, il suffit de redéclarer la méthode avec le qualificatif
“abstract”. Dans ce cas la méthode devient une méthode abstraite
et qui nécessite une implémentation dans les classes filles.
datascience.km@gmail.comM. MICHRAFY 11
12. Méthode par défaut : utilisation
public interface A { public defaultboolean check(String x){ return (x!=null && !x.isEmpty()) ; }}
public interface B extends A{ }
public interface C extends A {
public default boolean check(Stringx){
return (x!=null && !x.isEmpty()) && x.matches("[0-9]{5}"); }}
public interface D extends A { public abstract boolean check(String x); }
L’interface D ne dispose pas de méthode par défaut
L’interface C a redéfinit la méthode par défaut
L’interface B a la méthode par défaut celle qui est dans l’interface A
datascience.km@gmail.comM. MICHRAFY 12
13. Méthode par défaut : duplication non
autorisée
• L'implémentation par une classe de deux interfaces
possédant une méthode par défaut portant même
signature n'est pas autorisée, sauf si la classe
surcharge la méthode par défaut en question.
• En effet, la classe se trouve, dans le premier cas, dans
l'incapacité de déterminer quelle interface doit fournir
l'implémentation de la méthode par défaut à exploiter.
• Le cas échéant, une erreur se produira à la compilation.
datascience.km@gmail.comM. MICHRAFY 13
14. Méthodes statiques dans les interfaces
• Java 8 offre la possibilité de créer des méthodes statiques
dans une interface.
• Une méthode statique d’une interface est considérée
comme méthode de toutes les classes implémentant
l’interface en question.
• Les méthodes statiques sont utiles pour proposer des
méthodes utilitaires liées à une interface.
• La majorité des interfaces fonctionnelles standards
possèdent des méthodes statiques.
datascience.km@gmail.comM. MICHRAFY 14
15. Interface fonctionnelle
• Java permet de définir une interface fonctionnelle qui
représente une signature d’une méthode et ne disposant que
d’une seule méthode abstraite.
• Une interface fonctionnelle doit disposer d’une et une seule
méthode abstraite et 0, 1 ou plusieurs méthodes par défaut.
• La méthode abstraite de l’interface fonctionnelle ne doit pas
avoir d’implémentation par défaut.
• L’interface fonctionnelle permet de passer en paramètre une
méthode comme :
• référence vers une méthode statique
• référence vers une méthode d’une instance
• référence vers un constructeur
• lambda expression
datascience.km@gmail.comM. MICHRAFY 15
16. Interface fonctionnelle : étapes
• Déclarer une interface fonctionnelle.
• Utiliser l’interface fonctionnelle dans la signature ou dans
le corps d’une méthode.
• Instancier l’interface fonctionnelle par l’intermédiaire d’une
lambda expression.
• Faire appel à une méthode utilisant l’interface
fonctionnelle.
datascience.km@gmail.comM. MICHRAFY 16
17. Interface fonctionnelle : Déclaration
public interface NomInterface {
public valeurRetour nomMethode([Arguments]);
}
// Exemple1 d’une déclarationd’une interface fonctionnelle
public interface OperationCheck{
// signaturede la méthode check l interfacefonctionnelleOperationCheck
public boolean check(Stringa);
}
// Exemple2 d’une déclarationd’une interface fonctionnelle
public interface OperationMath {
// signaturede la méthode operation de l interface fonctionnelleOperationMath
public int operation(inta, int b);
}
datascience.km@gmail.comM. MICHRAFY 17
18. Lambda expression (1)
• Les lambda expressions permettent d’instancier les interfaces
fonctionnelles, c.-à-d. de leur fournir une implémentation.
• La déclaration d’une lambda expression nécessite de préciser
l’interface fonctionnelle associée.
• Les arguments d’entrée et la valeur de retour de la lambda
expression doivent respecter la signature de la méthode de l’interface
fonctionnelle associée.
• Le symbole « -> » sépare les arguments d’entrée et le corps du
traitement proposé par la lambda expression.
Syntaxe :
NomInterface nomLambdaExpression = ([arguments]) -> {
// traitement
};
datascience.km@gmail.comM. MICHRAFY 18
19. Lambda expression (2)
// Exemple 2 d’une déclarationd’une interfacefonctionnelle
public interface OperationMath {
// signaturede la méthode operation de l’interface fonctionnelleOperationMath
public int operation(inta, int b);
}
OperationMath addition = (int a, int b) -> a + b; // avec le type des arguments d’entrée
OperationMath produit = (a, b) -> a * b; // sans déclaration des types
OperationMath soustration = (int a, int b) -> {return a - b;}; // avec typage et return
Nom de
l’interface
Nom du lambda
expression
Arguments
d’entrée
Corps du lambda
expression
Signature de la
méthode
datascience.km@gmail.comM. MICHRAFY 19
20. Lambda expression : exemple
public interface OperationMath {// déclaration d’une interface fonctionnelle
public int operation(int a, int b); // la méthode à implémenter
}
public static void main(String[] args) {
A pf = new A();
OperationMath addition = (int a, int b) -> a + b;
OperationMath produit = (a, b) -> a * b;
int s = pf.apply(a, b, addition); // utilisation du lambda expression addition
int p = pf.apply(a, b, produit); // utilisation du lambda expression produit
}
public class A {// appliquer prend en un entrée l’interface fonctionnelle OperationMath
public int apply(int a, int b, OperationMath op){ return op.operation(a,b); }}
datascience.km@gmail.comM. MICHRAFY 20
21. Interface fonctionnelle : fonction d’ordre
supérieur (1)
• Avec Java 8, grâce aux interfaces fonctionnelles, une
fonction peut être un argument d’une autre fonction.
• On peut aussi affecter une fonction à une variable via une
interface fonctionnelle ou une lambda expression.
• De même, il est possible d’utiliser une fonction – une
interface fonctionnelle - comme valeur de retour d’une
fonction.
• Plus généralement, il devient possible de définir une
fonction qui prend en entrée une fonction et renvoie une
fonction.
datascience.km@gmail.comM. MICHRAFY 21
22. Interface fonctionnelle : fonction d’ordre
supérieur (2)
public interface PolynomePD {
public abstract double donnerY(double x);
}
public interface FabriquePolynomePremierDegre {
public abstract PolynomePD donnerPolynome(double a, double b);
}
public static void main(String[] args) {
FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;};
FabriquePolynomePremierDegre fppd1 = (a,b) -> ((x) -> (a*x+b));
PolynomePD p1 = fppd.donnerPolynome(1,1);
PolynomePD p2 = fppd.donnerPolynome(2,5);
double x = 1;
double p1_x = p1.donnerY(x); // retourne 2
double p2_x = p2.donnerY(x); // retourne 7
}
Fonction en valeur de retour
Interface fonctionnelle
2 façons de déclarer
une fonction en valeur
de retour
Construire 2 polynômes :
P1(x) : x + 1
P2(x) : 2x + 5
datascience.km@gmail.comM. MICHRAFY 22
23. Interface fonctionnelle : fonction composée
public interface ComposeFonction {
public PolynomePD compose(PolynomePD x, PolynomePD y);
}
public static void main(String[] args) {
FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;};
PolynomePD p1 = fppd.donnerPolynome(1,1);
PolynomePD p2 = fppd.donnerPolynome(2,5);
// cf est le composé de f et g
ComposeFonction cf = (f,g) -> ((x)->(f.donnerY(g.donnerY(x))));
double x=1;
// calculer p1op2(x) et cf(p1,p2)(x) et comparer
double p2_x=p2.donnerY(x),p1p2x = p1.donnerY(p2_x);
double cf_x = cf.compose(p1, p2).donnerY(x);
System.out.println("p1p2x = " + p1p2x + " | cf_x = " + cf_x);
} // sortie : p1p2x = 8.0 | cf_x = 8.0
2 fonctions en entréeretour est une fonction
Expression de la
fonction composée
Appel de la fonction
composé, passage
deux fonctions
datascience.km@gmail.comM. MICHRAFY 23
24. Interface fonctionnel standard (1)
• Java 8 a introduit l’API relative aux interfaces
fonctionnelles dans le package java.util.function
• Cette API est exploitée par l’API STREAM.
• Cette API propose 44 interfaces fonctionnelles.
• La connaissance de cette API favorise la communication
entre les différents membres du projet.
datascience.km@gmail.comM. MICHRAFY 24
25. Interface fonctionnel standard (2)
• Function - prend un T en entrée et retourne un R
• Predicate - prend un T en entrée et retourne un
booléen
• Consumer - prend un T en entrée et pas de valeur
de retour
• Supplier - ne prend rien en entrée et retourne un T
• BinaryOperator - prend deux T en entrée et
retourne un T
datascience.km@gmail.comM. MICHRAFY 25
26. Interface fonctionnelle Function (1)
• Cette interface déclare quatre méthodes :
1. apply : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et retourne un R.
2. identity : méthode par défaut statique qui renvoie la fonction
Identité : T ⇒ T.
3. compose : méthode par défaut qui renvoie la composée de la
fonction F (implémentée dans apply) et G : FoG. Prend en
entrée un argument de type Function et renvoie une valeur de
type Function.
4. andThen : méthode par défaut, similaire à la méthode compose,
qui retourne la composée GoF de la fonction G donnée en
entrée et de F (implémentée dans apply).
datascience.km@gmail.comM. MICHRAFY 26
27. Interface fonctionnelle Function (2)
public interface Function<T, R> {
// fonction abstraite apply
R apply(T t);
// fonction compose pour l’opérateur o qui retourne une fonction
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// fonction andThen qui compose deux fonctions et retourne une fonction
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
// la fonction identité.
static <T> Function<T, T> identity() {return t -> t;}
}
datascience.km@gmail.comM. MICHRAFY 27
28. Interface Functionnelle Function (3)
public class MainFunction {
public static void main(String[] args) {
Function<String, String> toUpper = (x) -> (x.toUpperCase());
Function<String, String> after = (x) -> (x.split("-")[0]);
Function<String, String> before = (x) -> (x.split("-")[1]);
String nomC = "Dupond-Pascal";
String nomC_format = toUpper.apply(nomC); // renvoie DUPOND-PASCAL
String nom = toUpper.andThen(after).apply(nomComplet); // renvoie DUPOND
String prenom = toUpper.compose(before).apply(nomComplet); // renvoie PASCAL
} Appel à apply de toUpper
Appel à la fonction andThen pour toUpper o after
Appel à la fonction compose before o toUpper
3 interfaces Function
datascience.km@gmail.comM. MICHRAFY 28
29. Interface fonctionnelle Predicat (1)
• Cette interface offre cinq méthodes :
1. test : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et retourne un booléen.
2. and: méthode par défaut qui représente le ET logique. Prend en
entrée un prédicat et renvoie un prédicat.
3. negate : méthode par défaut qui représente la négation logique.
Renvoie le prédicat Non P.
4. or : méthode par défaut qui implémente le OU logique.
5. isEqual : méthode par défaut statique, qui implémente
l’opérateur logique « = ». Prend entrée un T et renvoie un
prédicat.
datascience.km@gmail.comM. MICHRAFY 29
31. Interface fonctionnelle Predicate (3)
public static void main(String[] args) {
Predicate<String> isNull = (x) -> (x!=null);
Predicate<String> isEmpty = (x) -> (x.isEmpty()==false);
Predicate<String> isCP = (x) -> (x.matches("[0-9]{5}"));
// fonctions sont composées à partir de deux predicats
Predicate<String> isNullAndEmpty = isNull.and(isEmpty);
Predicate<String> isCPValide = isNullAndEmpty.and(isCP);
String x = "75", y="75009";
boolean rx= isNullAndEmpty.test(x);
boolean ry = isCPValide.test(y);
System.out.println("rx = " + rx + " | ry = " + ry); // retourne rx = true | ry = true
}
Création d’un nouveau prédicat en utilisant And pour les
prédicats isNull , isEmpty
Appel à la méthode test des deux prédicats
datascience.km@gmail.comM. MICHRAFY 31
32. Interface fonctionnelle Consumer (1)
• Cette interface propose 2 méthodes :
1. accept : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et ne retourne pas de valeur. Cette
méthode sert à effectuer une opération à effet de bord sur son
argument d’entrée.
1. andThen : méthode par défaut qui effectue le traitement d’un
consumer G après le consumer F implémenté dans la méthode
accept. Prend en entrée un Consumer et renvoie un Consumer.
Utilisée si l’on souhaite appliquer plusieurs opérations à effet de
bord dans un ordre prédéfini..
datascience.km@gmail.comM. MICHRAFY 32
33. Interface fonctionnelle : Consumer(2)
public interface Consumer<T> {
// Cette méthode un traitement sur l’objet T
void accept(T t);
// Cette méthode applique deux block de traitement sur l’objet T
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t);
after.accept(t);
};
}
}
Observer l’ordre du traitement de chaque Consumer
datascience.km@gmail.comM. MICHRAFY 33
34. Interface fonctionnelle : Consumer (3)
public class Climat {
double temp, lon, lat;
public Climat(double temp, double lon, double lat) {
super();
this.temp = temp; this.lon = lon; this.lat = lat;
}
public String toTemperature(){return "Climat [temp=" + temp + "]";}
public String toLonLat() {return "Climat [lon=" + lon + ", lat=" + lat + "]";}
}
public static void main(String[] args) {
Consumer<Climat> toTemp = (x) -> System.out.println(x.toTemperature());
Consumer<Climat> toXY = (x) -> System.out.println(x.toLonLat());
Consumer<Climat> toTempXY = toTemp.andThen(toXY);
Climat climat = new Climat(18, 2.3488000, 48.8534100);
toTemp.accept(climat); // Climat [temp=18.0]
toXY.accept(climat); // Climat [lon=2.3488, lat=48.85341]
toTempXY.accept(climat); // affiche les résultats donnés par toTemp et toXY
}
Deux consumers
Consumer composé à l’aide de andThen
Appel des 3 consumers
datascience.km@gmail.comM. MICHRAFY 34
35. Références de méthode : motivation
• Les lambda expressions permettent de créer des
méthodes anonymes. Or, souvent, une lambda
expression pointe ou utilise des méthodes existantes.
• Java 8 a introduit les références de méthode pour
répondre au besoin de faire référence dans une lambda
expression à une méthode existante via son nom.
• Une référence de méthode associe une « instance »
d’une interface fonctionnelle à un code existant.
• Les références de méthode favorisent la réutilisabilité du
code existant ainsi que sa lisibilité.
datascience.km@gmail.comM. MICHRAFY 35
36. Références de méthode : typologie
• Quatre types de référence possibles :
• Référence vers une méthode statique
• Référence vers un constructeur
• Référence vers une méthode d’instance
• Référence vers une méthode d’un objet arbitraire de type particulier
• La syntaxe d’une référence de méthode consiste à utiliser le nom
de la classe ou de l’instance de la classe, suivi de l'opérateur « :: »
et du nom de la méthode à référencer
datascience.km@gmail.comM. MICHRAFY 36
37. Référence vers une méthode d’instance
interface Distancier { public double distance (Mesure m1, Mesure m2 ) ; }
classMesure{
private double x;
public Mesure (double x){ this.x = x }
public double distance1(Mesure m) { return this.x - m.x; }
public double distance2(Mesure m) { return Math.abs(this.x- m.x) ; }
}
public staticvoid main (String [] args){
Mesure m1 = new Mesure(12), m2 = new Mesure(25) ;
Distancier d1 = Mesure::distance1; // référence vers la méthode distance1
Distancier d2 = Mesure::distance2; // référence vers la méthode distance2
System.out.println("distance1 entre m1 et m2 = " + d1.distance(m1, m2)) ;
System.out.println("distance2 entre m1 et m2 = " + d2.distance(m1, m2)) ;
}
Méthode d’interface
Méthodes d’instance
Références vers des méthodes d’instance
datascience.km@gmail.comM. MICHRAFY 37
38. Référence vers un constructeur
interface Fabrique<T> { public T getInstance(double x); }
classMesure{
private double x;
public Mesure (double x){ this.x = x }
public String toString() { return "Mesure [x=" + x + "]"; }
}
public staticvoid main (String [] args){
Fabrique<Mesure> fm = Mesure::new;
Mesure m = fm.getInstance(17);
System.out.println ("dm = " + d1.toString();
}
Méthode d’interface
Constructeur
Référence vers un constructeur
datascience.km@gmail.comM. MICHRAFY 38
39. Référence vers une méthode statique
interface ICompteur { public T getCompteur(); }
classMesure{
private int compteur=0;
private double x;
public Mesure (double x){ this.x = x; compteur++;}
public staticint getNbInstance(){ return compteur; }
}
public static void main (String [] args){
ICompteur compt = Mesure::getNbInstance ;
Mesure m1 = new Mesure(3), m2=new Mesure(7);
System.out.println ("nombre d instance = " + compt.getCompteur()) ;
}
Méthode d’interface
Méthode statique
Référence vers une méthode statique
datascience.km@gmail.comM. MICHRAFY 39