Cours CNAM par J. Laforgue

Exemple36_LambdaExpressionSyntaxe

Retour

Télécharger

Exemple de l'utilisation des lambda expressions
Cela ne fonctionne que avec au moins la version 8.0 de Java

Exemple36.java

// Exemple de l'utilisation des lambda expressions
// Cela ne fonctionne que avec au moins la version 8.0 de Java
//
import java.util.function.*;
import java.util.*;

//---- interfaces utilisees pour l'exemple des fonctions generiques
//
interface Func2Int { public int f(int x,int y); }
interface AfficherPersonne { public Object attr(Personne p); }
interface AfficherPersonne2 { public Object attr(Personne p,String s); }

// La classe de definition d'une personne
//
class Personne
{ 
    private String nom;
    private String prenom;
    private int age;
    private String adresse;
    private String telephone;

public Personne(String nom,String prenom,int age,
                    String adresse,String telephone)
    {
        this.nom=nom;
        this.prenom=prenom;
        this.age=age;
        this.adresse=adresse;
        this.telephone=telephone;
    }
    
    public int getAge(){return age;}
    public String getNom(){return nom;}
    public String getNom(String s){return s+" "+nom;}  // pour faire un test
    public String getNomPrefixe(String s){return s+" "+nom;}  // pour faire un test
    public String getPrenom(){return prenom;}
    public String getAdresse(){return adresse;}
    public String getTelephone(){return telephone;}
    public String toString(){return String.format("%15s %15s %3d %15s %12s",
                                                  nom,prenom,age,adresse,telephone);}

// Pour plus d'efficacite :
    public int compareAdresse(Personne p){return adresse.compareTo(p.getAdresse());}
    public int comparePrenom(Personne p){return prenom.compareTo(p.getPrenom());}
    public int compareAge(Personne p){return age - p.getAge();}
}

// ============== PROGRAMME PRINCIPAL
//
public class Exemple36
{

// Exemples de fonctions generiques

public static void generique(Func2Int func1,Func2Int func2,int x,int y)
    {
        System.out.println(func1.f(x,y) / func2.f(x,y));
    }

public static void generique2(Personne p,AfficherPersonne o)
    {
        System.out.println("****"+ o.attr(p)+"****");
    }

public static void generique3(Personne p,AfficherPersonne... os)
    {
        for(AfficherPersonne a : os)
            System.out.println("****"+a.attr(p)+"****");
    }

public static void generique4(Personne p,String s,AfficherPersonne2 o)
    {
        System.out.println("****"+ o.attr(p,s)+"****");
    }

// ---  Methode main
    //
    public static void main(String[] args) 
    {

System.out.println("------ Exemple 1  ----------------------");
        Func2Int f1 = (x,y)->(x * y);
        Func2Int f2 = (x,y)->(x + y);
        
        generique(f1,f2,20,30);

System.out.println("------ Exemple 2  ----------------------");
        Personne p1 = new Personne("LAFONT","Paul",35,"Toulouse","0655556789");
        generique2(p1,(p)->p.getNom());
        generique2(p1,(p)->p.getPrenom());
        generique2(p1,(p)->p.getNom(">>>>>"));
        System.out.println("---- Avec la syntaxe ::  (avec la classe)");
        generique2(p1,Personne :: getNom);
        generique2(p1,Personne::getPrenom);
        //generique2(p1,Personne :: getNom(">>>>>"));  // Ne se compile pas

System.out.println("------ Exemple 3  ----------------------");
        System.out.println("---- Afficher le nom et le prénom");
        generique3(p1,Personne::getNom,Personne::getPrenom);
        System.out.println("---- Afficher le nom et l'age");  
        generique3(p1,Personne::getNom,Personne::getAge);  //Autoboxing pour l'age (int)
        System.out.println("---- Afficher le nom, l'adresse et le telephone");
        generique3(p1,Personne::getNom,Personne::getAdresse,Personne::getTelephone);

System.out.println("------ Exemple 3 bis -------------------");
        System.out.println("---- Afficher le nom");
        generique4(p1,"XXXXXXX",(p,s)->p.getNom(s));
        generique4(p1,"XXXXXXX",Personne::getNomPrefixe);
        //Comme la methode getNom sans arg existe, pour utiliser la syntaxe ::,
        //   il faut definir la methode getNomPrefixe

System.out.println("------ Exemple 4  ---------------------");
        // Tris en fonction de différents critères

Personne p2 = new Personne("ZOE","Andre",25,"Paris","0177889911");
        Personne p3 = new Personne("DURAND","Roger",75,"Bordeaux","0545778899");
        Personne p4 = new Personne("MONTANA","Eric",35,"Toulouse","0655556789");
        Personne p5 = new Personne("VULONG","Yang",35,"Marseille","0455556789");
        ArrayList<Personne> l = new ArrayList<Personne>();
        l.add(p1);
        l.add(p2);
        l.add(p3);
        l.add(p4);
        l.add(p5);

System.out.println("----- Tri sur le nom avec une classe anonyme");
        //
        ArrayList<Personne> l2 = (ArrayList<Personne>)l.clone();
        // On travaille sur une copie de l car la methode de tri modifie la liste
        // afin de comparer avec l'execution suivante avec une lambda expression
        Collections.sort(l2,new Comparator<Personne>()
                         { public int compare(Personne p1,
                                              Personne p2)
                             {
                                 return p1.getNom().compareTo(p2.getNom());
                             }});
        for(Personne p:l2)System.out.println(p.toString());

System.out.println("----- Tri sur le nom avec une lambda expression");
        //
        Collections.sort(l,(e1, e2)->(e1.getNom().compareTo(e2.getNom())));
        for(Personne p:l)System.out.println(p.toString());

// Si on veut utiliser la syntaxe simplifie, il faut
        //   definir dans la classe Personne la methode de tri pour chaque attribut
        // 
        System.out.println("----- Tri sur l'adresse avec une lambda expression");
        Collections.sort(l,Personne::compareAdresse);
        for(Personne p:l)System.out.println(p.toString());

System.out.println("----- Tri sur le prenom avec une lambda expression");
        Collections.sort(l,Personne::comparePrenom);
        for(Personne p:l)System.out.println(p.toString());

System.out.println("----- Tri sur l'age avec une lambda expression");
        Collections.sort(l,Personne::compareAge);
        for(Personne p:l)System.out.println(p.toString());

}

compil.bat
run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE