JAVA 8

MainObjectiviesofJava1.8v
SimplifyJavaProgramming
Activer la programmation fonctionnelle

Écrivez un code plus lisible et concis.

Listesdesfonctionnalitésjava
8
Functionalinterface(Predicate,Consumer,Supplier,Function)
etméthodepardéfautinterface
Statique dans
Lambda expression
Streamapi ( Opérateur/méthodes intermédiaires et finales
Référence de méthode

Optionalclass
Datetimeapi
StringJoiner
méthode forEach()
Changements d'interface
L'interface signifie une collection de méthodes abstraites

1 ) MéthodesParDéfaut
2 ) MéthodesStatique
Remarque : La méthode qui ne contient pas de corps est appelée méthode abstraite

A une classe peut implémenter une interface en utilisant "implements"

Quanda classisimplementinginterfaceitsmandatorythatclassshould
implémentez toutes les méthodes abstraites de cette interface sinon la classe ne pourra pas être

compiler.
Ici, je jeprends une interface avec une méthode abstraite. Toutes les classes
ceux qui mettent en œuvre cette interface devraient remplacer l'interface
méthode(s).
 exemple
interfaceVéhicule
{
publicabstractvoidstartVechicle ( );
}
classeVoitureimplémenteVéhicule {
publicvoidstartVehicle( ) {
//logiquepourdémarrerla voiture

}}
classeBusimplémenteVéhicule {
public void démarrerVéhicule()
{
//logiquepourdémarrerlebus

}}
classBikeimplementsVehicle {
publicvoiddemarrerVéhicule(
{ )
//logiquePourDémarrerMoto

}}
Si nous ajoutons une nouvelle méthode dans l'interface, alors Car, Bike et Bus échoueront à la compilation.& Pour surmonter ce problème, nous utiliserons Default.
Statique
méthodes
1) Une interface peut avoir des méthodes concrètes depuis la version 1.8.

2) La méthode concrète de l'interface doit être par défaut ou statique

3) méthodes par défaut de l'interface que nous pouvons remplacer dans les classes d'implémentation

4) Les méthodes statiques d'interface que nous ne pouvons pas remplacer dans les classes d'implémentation

5) Nous pouvons écrire plusieurs par défaut

& staticmethodsininterface
6) Méthode statique
& par défaut introduite pour assurer la compatibilité ascendante.

la méthode forEach() ajoutée dans l'interface [Link] en tant que méthode par défaut dans

1,8v
[Link] ;
interfaceVehicle {
public void start();
publicdefaultvoidm1(){ }
publicdefaultvoidm2(){ }
publicstaticvoidclean() {
[Link]("nettoyage terminé...");
}}
classe publique Voiture implémente Véhicule {

public void start() {

[Link]("voiture démarrée...");
}
publicstaticvoidmain(String[]args) {
c = newCar();
Voiture
Vé[Link]();
c.démarrer();
}}
Expression lambda
Introduit dans Java 1.8
Java est appelé un langage de programmation orienté objet. Tout sera
représenté en utilisant des classes et des objets.

Depuis 1.8, Java est également appelé langage de programmation fonctionnelle.

ClassesLangageOO & Les objets sont des entités principales. Nous devons écrire
méthodes à l'intérieur de la classe seulement.

La programmation fonctionnelle signifie que tout sera représenté sous forme

Les fonctions peuvent exister en dehors de la classe. Les fonctions peuvent être stockées.
dansa variablede réfé[Link]êtrerepasséecommeparamètreàd'autres
un
méthodes.
Les expressions lambda introduites dans Java pour permettre la programmation fonctionnelle.
 utilisé pour obtenir une interface fonctionnelle

plus lisible, plus maintenable , concisecode

fonctionanonymee(noname,nomodifier,noreturntype)
Caractéristiques de l'expression lambda

ilfautunnombrequelconquedeparamètres

s'il n'y a pas de paramètre dans la méthode, alors c'est() optionnel

Typeinterface->aucunbesoin de passer le type de données au paramètre basé sur

Le contexte peut donner le type automatiquement.
 Qu'est-ce que Lambda ?
-1
public void m1( ) {
s.o.p("salut");
}
( )-> { s.o.p("salut")}
Remarque : Lorsque nous avons une ligne unique dans le corps, les accolades sont optionnelles

( )->s.o.p("salut");
-2

publicvoidadd(inta,intb){

s.o.p(a+b);

ExpressionLambda : (a,b)->s.o.p(a+b);

-3

publicintgetLength(Stringname) {

[Link]);
(

(NomDeChaine){ [Link]( );

(NomDeChaine)->longueurNomRetourne()
;

(nom)->longueurdu_nom.renvoyer);
(

LambdaExpressionnom->[Link](
: ) ;
-4
publicDoublegetEmpSalary(Employeeemp ) {
.getSalary);(
retourneremployé

}
ExpressionLambda : emp->emp .getSalary);(
 Tâche: WAJPimprimerdesnombresàpartirde 1 à 5 utilisationDuFil
withthehelpofRunnableinterface.
//utiliserExpressionLambda
ClassePubliqueThreadDemo3
{
publicstaticvoidmain(String[]args ) {
Runnable r = ()-> {
pour(intje= 1; je<=5;i++) {
[Link](i);
} };
Fil t = newThread(r);
t.démarrer();
}}
Interface fonctionnelle
Une interface qui contient exactement une méthode abstraite est connue sous le nom de

interfacefonctionnelle.
Il peut avoir n'importe quel nombre de méthodes par défaut, de méthodes statiques mais peut contenir
seulement une méthode abstraite.

FunctionalInterface est également connu sous le nom de Single Abstract Method

InterfacesorSAMInterfaces.
Cela aide à atteindre une approche de programmation fonctionnelle.

L'annotation @FunctionalInterface est optionnelle mais peut être utilisée

pour indiquer que l'interface est destinée à des fonctions
programmation.
UsageofFunctionalInterfaces:
ExpressionsLambda
Les interfaces fonctionnelles sont utilisées en conjonction avec des lambdas

expressionstocreateconciseandexpressivecode.
MethodReferences:
Ils peuvent être utilisés avec des références de méthode, fournissant unsténographique
syntaxpourlesexpressionslambda.
r
StreamAPI:
Les interfaces fonctionnelles sont couramment utilisées avec l'API Stream pour
traitement des collections de données dans un
a style fonctionnel.
=========================================================
Predicate------>takesinputs---->returnstrueorfalse===>test( )
Supplier----->willnottakeanyinput--->returnsoutput===>get( )
Consumer---->willtakeinput---->willnotreturnanything===>
accepter()
Fonction----->prendraentrée--->renverraoutput===>appliquer( )
Runnable------------>méthode run( )
Appelable---------->méthode call( )
Comparable------->compareTo( )
Pour représenter une interface comme Interface Fonctionnelle, nous utiliserons
@FunctionalInterfaceannotation.
@InterfaceFonctionnelle
interface publique MyInterface{
public void m1();
}
Remarque : Lorsque nous écrivons @FunctionalInterface alors notre compilateur vérifiera l'interface
ne contient qu'une seule méthode abstraite ou non.
InterfaceFonctionnellePrédicat
C'est une interface fonctionnelle prédéfinie

Il est utilisé pour vérifier la condition et retourner une valeur vraie ou fausse.

Interface de prédicat ayant uniquement une méthode abstraite qui est test(Tt)

interfacePredicate{
booleantest(Tt);
}
 PredicateExample
//PredicateExample

[Link].java8;
importer [Link];
classepubliquePredicateDemo
{
publicstaticvoidmain(String[]args) {
Prédicat<Integer>10;
p = je-> je>
[Link]([Link](5));
[Link]([Link](15));
}
}
 Exemple
Tâche : Déclarez des noms dans un tableau et imprimez les noms qui commencent par 'A' en utilisant une expression lambda.

Chaîne[] names{"Anushka","Anupama","Deepika","Kajol","Sunny"};
=
[Link].java8;
import [Link];
publicclassPredicateDemo2 {

publicstaticvoidmain(String[]args) {
String[names"Anushka","Anupama","Deepika","Kajol","Sunny"};
] ={
Prédicat<String> p =nom -> [Link](0) == 'A';
: noms) {
pour(Stringname
if ( [Link](nom) ) {
[Link](nom);
} } } }
InterfaceFonctionnelleFournisseur

Fournisseur
-
Supplier est une
uninterface fonctionnelle prédéfinie introduite dans Java 1.8.
Il ne contient qu'une seule méthode abstraite qui est la méthode get( )

L'interface du fournisseur ne prendra aucune entrée, elle ne renverra que les

valeur.

Exemple : Génération de OTP

 ExempleDeFournisseur
[Link].java8;
importer [Link];
publicclassSupplierDemo {
publicstaticvoidmain(String[]args) {
Fournisseur<String>()
s= {
Stringotp = "";
je= 1 je<=6;i++) {
pour(int
otp = otp + (int)([Link]() * 10);
}
retournerotp
;
};
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
}}
 InterfaceFonctionnelleConsommateur
Remarque : la méthode
8 forEach() a été introduite en Java.

La méthode forEach(Consumer consumer) prendra Consumer comme paramètre.

[Link].java8;
[Link];
import [Link];
import [Link];
classepubliqueConsumerDemo {
publicstaticvoidmain(String[]args) {
Consumer<String> c = (nom)->[Link](nom, "Bonne
+ soirée");
[Link]("Ashok");
[Link]("John");
[Link]("Rani");
Liste<Integer> [Link](10,
= 20, 30, 40);
//bouclepour
//bouclePourChaque
//itérateur
//itérateurDeListe

[Link](i->[Link](i));
} }
 InterfaceFonctionnelle
Function est une interface fonctionnelle prédéfinie
Interface de fonction ayant une méthode abstraite, c'est-à-dire apply(Tr)

Exemple :
interfaceFunction<R,T>{
R appliquer(Tt);
}
Il prend une entrée et renvoie une sortie

paquetin.java8;
[Link];
publicclassFunctionDemo {
publicstaticvoidmain(String[]args ) {
Fonction<String,Integer>(nom)->[Link]();
f=
[Link]([Link]("ashok"));
[Link]([Link]("hyd"));
[Link]([Link]("sachin"));
}}
 Références de méthode
La référence de méthode signifie faire référence à une méthode d'une autre méthode.

Exemple :
@InterfaceFonctionnelle
interfaceMonInterface{
publicvoidm1();
}
méthode de référence publique{

publicstaticvoidm2() {
[Link]("Thisism2( ) méthode" );
}
publicstaticvoidmain(String[]args) {
MonInterface = MethodRef::m2;
mi.m1();
}}
//ClasseMédecinCréationObjet

classe publique Test

{

publicstaticvoidmain(String[]args) {
Médecin
d = newDoctor();
Fournisseur<Docteur>Docteur::nouveau;
s=

[Link]();
=

[Link]([Link]());

}}
médecin {

publicDoctor() {

[Link]("Constructeur de médecin....");

}}
 Streamapi
StreamAPI introduit dans java 1.8v
StreamAPI est utilisé pour traiter les données

Remarque : Les collections sont utilisées pour stocker les données

StreamAPIestl'unedesprincipalesfonctionnalitésajoutéesanjavav1.8

Le flux de javacan peut être défini comme une séquence d'éléments qui proviennent de

unsource.
La source de données pour le flux peut être un tableau ou une collection.
 Quelques points importants sur les flux
Streamn'estpasunestructurededonné[Link]éed'opérations
a
[Link]êtrecollectionoutableau.
Le flux ne changera pas la structure de données originale de la source (Il ne fera que
traiter les données fournies par la source.

Création de flux
En Java, nous pouvons créer un flux dans
2 manières
1)[Link](e1,e2, e3,e4.....)
méthode stream( )
Opérations de flux
StreamAPI fournit plusieurs méthodes pour effectuer des opérations sur les données

Nous pouvons diviser les méthodes de l'API Stream en

2 types
1) Méthodes opérationnelles intermédiaires

MéthodesOpérationnellesTerminales
Les méthodes opérationnelles intermédiaires effectueront des opérations sur le
streamandreturnsnewStream
a
Ex:filtrer( ) mapper(
, )etc....

Les méthodes opérationnelles terminales prendront en entrée et fourniront le résultat comme

sortie.
Ex:compt( )
 FiltrageAvecFlux
Le filtrage signifie obtenir les données requises à partir des données d'origine.

ex: obtenir uniquement les nombres pairs à partir des nombres donnés

Ex: obtenirempswhosesalaireis>=1,00,000

Ex: ObtenirMobilesdontleprixest<=15,000

Toapplyfilteronthedata,Streamapiprovidedfilter( )method
Ex : Filtre de flux(Predicatep)
Exemple - 1 : Filtre
[Link];
importer [Link];
importer [Link];
publicclassFirstDemo{
publicstaticvoidmain(String[]args) {
Liste<Integer>[Link](66,32,45,12,20);
=
je: liste){
/*pour(Integer
si(i> 20) {
[Link](i);
} }*/
= [Link]();
/*Flux<Integer>flux
Flux<Integer>filtré = [Link](i -> je> 20);
[Link](i->[Link](i));*/
[Link]().filter(i-> je> 20).forEach(i->[Link](i));
}}
 Opérations de Cartographie
Les opérations de mapping appartiennent aux opérations intermédiaires de l'API Stream.

Les opérations de mapping sont utilisées pour transformer les éléments du flux et retourner les éléments transformés
elementsasnewStream
Ex : CarteDesFlux(Fonctionfonction) ;
classpubliquePremierDémonstration
{
publicstaticvoidmain(String[]args ) {
List<String>[Link]("india","usa","uk","japan");
=
/*pour(Stringnom: noms) {
[Link]([Link]());
}*/
[Link]().map(nom->[Link]()).forEach(n->[Link](n));
[Link]().mapToInt(nom->[Link]()).forEach(i->[Link](i));
}}
 Méthode map(
: ) Exemple-2
publicclassPremierDémonstration
{
publicstaticvoidmain(String[]args) {
Liste<String>[Link]("Ashok",
= "Anil "Raju","Rani","John","Akash","Charles");

//imprimerle_nomavec_son_longueur_commençant_par'A'en_utilisant_StreamAPI

//Ashok - 5
Anil
-4
//Akash
-5
[Link]()
.filter(nom->[Link]("A"))
.map(nom->nom"-"+[Link]())
+
.forEach(name -> [Link](name));
}
}
 CollectionneursavecFlux
Les collecteurs sont utilisés pour collecter des données à partir de flux.

Exemple :
classePersonne{

NomDeChaine
Chaîne de pays;
publicPerson(Stringname,Stringcountry) {
[Link] = name;
[Link] = country;
}
@Override
publicStringtoString() {
+ name + ",country="+ country"]";
retourner "Person[name=" +
}}
[Link];
importer [Link];
importer [Link];
import [Link];
classpubliquetePremièreDémo
{
public static void main(String[] args) {
Personp1 = nouveauPersonne("John","USA");
Personp2 = newPerson("Steve","JAPAN");
Personp3 = newPerson("Ashok","INDIA");
Personp4 = newPerson("Ching","CHINA");
Personp5 = newPerson("Kumar","INDIA");
Liste<Person>personnes = [Link](p1, p2, p3, p4, p5);
Liste<Person>indiens = [Link]().filter(p->[Link]("INDE"))
.collect([Link]());
[Link](i
. -> [Link](i));
}}
UsageofFunctionalInterfaces:
ExpressionsLambda
Les interfaces fonctionnelles sont utilisées en conjonction avec des lambdas

expressionstocreateconciseandexpressivecode.
MethodReferences:
Ils peuvent être utilisés avec des références de méthode, fournissant unsténographique
syntaxpourlesexpressionslambda.
r
StreamAPI:
Les interfaces fonctionnelles sont couramment utilisées avec l'API Stream pour
traitement des collections de données dans un
a style fonctionnel.
 - 1 : OpérationsIntermédiaires(renverraFlux)
Définir
Filters---->filter( )
Mappings---->map( ) & flatMap()
Slicing---->distinct( ) & limit()skip(
& )

- 2 : TerminalOperations(willreturnresult)
Ensemble
Finding--->findFirst( ) & findAny( )
) allMatch( ) & aucuneCorrespondance( )
Correspondance ---> anyMatch( &
Collecting--->collect( )
 ClasseOptionnelle
[Link].Optionalclassintroduitdansjava1.8v
OptionalclasseestutiliséepouréviterlesNullPointerExceptionsdansleprogramme
Q) Qu'est-ce qu'une NullPointerException(NPE) ?
Lorsque nous effectuons une opération sur une valeur nulle, nous obtiendrons

NullPointerException
Chaines = null;
[Link](; )// NPE exceptiondeponteurnull
)
ToavoidNullPointerExceptionswehavetoimplementnullcheckbeforeperforming
operation sur l'objet comme ci-dessous.
Chaines = null;
si(s! = null ) {
[Link]([Link] ( ));
}
Remarque : Dans le projet, il n'y a aucune garantie que chaque programmeur mettra en œuvre des vérifications nulles.
quiconque a oublié d'implémenter une vérification de null alors le programme va rencontrer une NullPointerException.

Pour éviter ce problème, nous devons utiliser la classe Optional comme ci-dessous.
 Exemple
[Link].java8;
importer [Link];
importer [Link];
publicclassMsgService {
publicstaticvoidmain(String[]args) {
Scanner s = nouveauScanner([Link]);
[Link]("EntrezIdentifiantUtilisateur");

[Link]();
=
UtilisateurNouveauUtilisateur();
u=
/*StringuserName= [Link](userId);
Stringmsg = [Link]()",Bonjour";
+
[Link](msg);*/
Optional<String>nom d'utilisateur = [Link](userId);
{
si([Link]ésent())
[Link]();
=
[Link]([Link]()+", Bonjour");
}else {
[Link]("AucuneDonnéeTrouvée");

} } }
Date & TimeAPI
En Java, nous avons ci-dessous 2 classeStoreReprésenterDate
[Link]
[Link]
Remarque : Lorsque nous effectuons des opérations sur la base de données, nous utiliserons [Link]
class.
Pour les opérations liées aux dates normales, nous utiliserons la classe [Link]

Date d = newDate);(
Systè[Link](d);
Remarque : Lorsque nous créons un objet pour la classe Date, il représentera à la fois la date et l'heure.
Si nous voulons obtenir uniquement la date ou uniquement l'heure, alors nous devons le formater en utilisant
classe SimpleDateFormat.
[Link]
SimpleDateFormat est uneun
classe prédéfinie dans le paquet [Link]
Cette classe fournit des méthodes pour effectuer des conversions de date

DatetoStringconversion===>Stringformat(Dated)
StringtoDateconversion===>Dateparse(Stringstr)
 [Link].*;
importer
[Link];
importer

publicclass Date {
voidLocalDateTimeApi() {
public statique
DateLocale = // le actuel date
.maintenant();
println("le actuel date est"+ date);
Systè[Link].

HeureLocaletemps = HeureLocale // le currenttime

.maintenant();
[Link]("le ")l'heureactuelleesttemps);
"+

// volonté
LocalDateTime courant= [Link](); le currenttime etdate
donnez-nous
printlnactuel dateet tempsactuel);
Systè[Link]. : "+

DateTimeFormatter format = DateTimeFormatter. de modèle("dd-MM-yyyyHH:mm:ss // imprimer a formatparticulier

Chaî[Link](format);
=
println("in formaté manière"+ formatedDateTime);
Systè[Link].

[Link](1950,1,26);
= date spécifiée
// imprimer quelque
[Link]("lajourndelarepublique:" + date2);

LocalDateTimeDateSpecific = [Link](24).avecAnnée(2016); date avec

// impressionduheureactuelle.
println("datedéfinieavec +actuel
Systè[Link]. : "+specificDate);
temps
}

vide main(String[] arguments)

public statique code
//Conducteur
{
LocalDateTimeApi();
}}
 ExempleDeConversionsDeDate
[Link].java8;
import [Link];
importer [Link];
publicclassDateDemo {
public static void main(String[] args) throws Exception {
DatedatenewDate();
=
[Link](date);
// ConversionDesDonnéesEnChaîne
SimpleDateFormatsdf1newSimpleDateFormat("dd/MM/yyyy");
=
[Link](date);
=
[Link](format1);
SimpleDateFormat sdf2 == new SimpleDateFormat("MM/dd/yyyy");
[Link](date);
=
[Link](format2);
// ConvertirChaineEnDate
SimpleDateFormat sdf3 = newSimpleDateFormat("yyyy-MM-dd");
[Link]("2022-12-20");
=
[Link](parsedDate);
}
}
Pour surmonter les problèmes de la classe [Link] de java 1.8
introducedDateAPIchanges
LocalDate
14.2) HeureLocale
14.3)LocalDateTime
14.4) Période
14.5)Duration
Dans les versions Java 1.8, de nouvelles classes ont été introduites pour gérer les dates.
&
Fonctionnalités temporelles

1) [Link] (il ne traitera que la date)

2)[Link](ce ne va traiter que le temps)3)
[Link](cela traitera à la fois la date & temps)
méthode forEach(Consumerc)
méthode forEach(Consumerc) introduite dans java 1.8
méthode forEach() ajoutée dans l'interface Iterable

la méthode forEach() est une méthode par défaut (elle a un corps)

a
Cette méthode est utilisée pour accéder à chaque élément de la collection
traverser_l_collection_de_début_en_fin
 Exemple :
[Link].java8;
importer [Link]
;
publicclassNumbersSort1 {
publicstaticvoidmain(String[]args) {
ListeArrayListe<Integer>al
= nouvelleListe<>();
[Link](3);
[Link](4);
[Link](1);
[Link](2);
[Link](i -> [Link](i));
}}
 StringJoiner
[Link].StringJoinerclasseintroduiteenja1.8v
Il est utilisé pour joindre plus d'une chaîne avec un délimiteur spécifié

Nous pouvons concaténer des préfixes et des suffixes tout en joignant des chaînes en utilisant

StringJoiner
StringJoinersj = newStringJoiner (CharSéquenceédelim);
StringJoinersj = newStringJoiner (CharSequencedelimCharSequence
,
préfixe,CharSequencesuffix);
 Exemple :
[Link].java8;
import [Link];
démonstrationStringJoinerpublique{
publicstaticvoidmain(String[]args) {
StringJoinersj1 = newStringJoiner("-");
[Link]("as");
[Link]("it");
[Link]("java");
[Link](sj1); //as-it-java
StringJoinersj2 = newStringJoiner("-","(",")");
[Link]("as");
[Link]("it");
[Link]("java");
[Link](sj2); //(en-java)
}}