EXAMEN

Semestre : 1 2

Session : Principale Rattrapage

ETUDIANT(e)
Code :
Nom et Prénom : …………………………………………………...
Classe: …………………………………………………....................
Module : Conception orientée objet et programmation Java …………………………
Enseignant(s) : Equipe Java …………………………………
Classe(s) : 3INFO A, 3 SIGMA, 4INFINI ………………………………………
Documents autorisés : NON Nombre de pages : 8
Calculatrice autorisée : NON Internet autorisée : NON
Date : 07/01/2017 ………………… Heure . 9:00................ Durée :
1:30h..................

**

Nom et Signature Nom et Signature Observations

Code Note du Surveillant du Correcteur

/20

Module :………………………………………………………………………………

NB : Les parties réservées aux informations relatives à l’étudiant et à l’administration seront ajoutées au
cas où les réponses seront écrites sur les feuilles d’examen.

public class Joueur { public void setNationalite(String nationalite)

{ this.nationalite = nationalite; }
private int id;
public String toString() {
private String nom;
return "Joueur{" + "id=" + id + ", nom=" + nom
private String nationalite; + ", nationalite=" + nationalite '}'; }
public Joueur() { } public int hashCode() { return id; }
public int getId() { return id; } public boolean equals(Object obj) {
public void setId(int id) { this.id = id; } if (obj instanceof Joueur) {
public String getNom() { return nom; } final Joueur other = (Joueur) obj;
public void setNom(String nom) { this.nom = return this.id != other.id;
nom; }
}
public String getNationalite() { return
nationalite; } return false;

1
 }}

NE RIEN ECRIRE

public class Competition { private String nom; }

private int id;

public Competition() { } public int hashCode() { return id; }

public int getId() { return id; } public boolean equals(Object obj) {

public void setId(int id) { this.id = id } if (obj instanceof Competition) {

public String getNom() { return nom; } final Competition other = (Competition) obj;

public void setNom(String nom) { return this.id != other.id;

this.nom = nom; }

} return false;

public String toString() { }

return "Competition{" + "id=" + id + ", nom=" +

nom + '}';

public class Equipe {

private int id;
private String nom;
private String pays;
private List<Joueur> joueurs;

2
 public Equipe() { joueurs = new ArrayList<>() ; }

NE RIEN ECRIRE


public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getNom() { return nom; }
public void setNom(String nom) { this.nom = nom; }
public String getPays() { return pays; }
public void setPays(String pays) { this.pays = pays; }
public List<Joueur> getJoueurs() { return joueurs; }
public void setJoueurs(List<Joueur> joueurs) { this.joueurs = joueurs; }
public String toString() {
return "Equipe{" + "id=" + id + ", nom=" + nom + ", pays=" + pays + ", joueurs=" + joueurs + '}'; }
public int hashCode() { return id; }
public boolean equals(Object obj) {
if (obj instanceof Equipe) {
final Equipe other = (Equipe) obj;
return this.id != other.id;
} return false; }

public void addJoueur(Joueur j) { joueurs.add(j); }

public void supprimerJoueur(Joueur j) { joueurs.remove(j); }

3
 NE RIEN ECRIRE


/* TODO 1 : Avec l’api Stream */ (1 point)
public boolean rechercherJoueurParNationalite(String nationalite) {

return joueurs.stream() .anyMatch(joueur -> joueur.getNationalite().equals(nationalite));

}
/* TODO 2 : Avec l’api Stream */(1 point)
public Map<String, List<Joueur>> regrouperParNationalite() {
return joueurs.stream()

.collect(Collectors.groupingBy(Joueur::getNationalite));

public class EnsembleEquipe {

public Set<Equipe> equipes;

public Set<Equipe> getEquipes() { return equipes; }
public void ajouterEquipe(Equipe e) { equipes.add(e); }
public void supprimerEquipe(Equipe e) { equipes.remove(e); }
/* TODO 3 */ (0,5 point)
public boolean rechercherEquipe(Equipe e) {
return equipes.stream.anyMatch(e -> e.equals(equipe));

4
 EXAMEN
Semestre : 1 2

Session : Principale Rattrapage

ETUDIANT(e)
Code :
Nom et Prénom : …………………………………………………...
Classe: …………………………………………………....................
Module : Conception orientée objet et programmation Java …………………………
Enseignant(s) : Equipe Java …………………………………
Classe(s) : 3INFO A, 3 SIGMA, 4INFINI ………………………………………
Documents autorisés : NON Nombre de pages : 8
Calculatrice autorisée : NON Internet autorisée : NON
Date : 07/01/2017 ………………… Heure . 9:00................ Durée :
1:30h..................

**
/* TODO 4 : Avec une méthode de référence ou une expression lambda */ (1 point)
public void afficherEquipes() {
equipes.forEach(System.out::println);

/* TODO 5 : Avec lambda Expression ou l’api Stream */ (2 points)

public Set<Equipe> trierEquipesParNom() {
return equipes.stream()

.sorted((e1, e2) -> e1.getNom().compareTo(e2.getNom()))

.collect(Collectors.toSet());

public class Fifa {

private Map<Competition, EnsembleEquipe> mapFifa;
public Fifa() { mapFifa = new HashMap<>(); }
/* TODO 6 */ (0,5 point)
public void ajouterCompetition(Competition c) {
mapFifa.put(c, new EnsembleEquipe());

5
 NE RIEN ECRIRE


/* TODO 7 */ public void ajouterEquipe(Competition c, Equipe e) { (2 points)
if (mapFifa.containsKey(c)) {
EnsembleEquipe ensembleEquipe = mapFifa.get(c);
ensembleEquipe.ajouterEquipe(e);
} else {
EnsembleEquipe ensembleEquipe=new EnsembleEquipe() ;
ensembleEquipe.ajouterEquipe(e);
mapFifa.put(c, ensembleEquipe) ;
}

}
/* TODO 8 Avec lambda expression*/ (2 points)
public void afficherFifa() {

mapFifa.forEach((competition, ensembleEquipe) -> {

System.out.println("--------------------");
System.out.println("Compétition : " + competition);
System.out.println("Équipes : " + ensembleEquipe);
System.out.println("--------------------");
}

6
 /* TODO 9 Avec l’api Stream*/ (2 points)
public List<Equipe> retournerEquipesParPays(String nom) {

return mapFifa.values().stream()

.flatMap(ensembleEquipe -> ensembleEquipe.getEquipes().stream())

.filter(equipe -> equipe.getPays().equals(pays));

"Remarque : On utilise `flatMap` pour transformer les ensembles d'équipes en une seule liste d'équipes,
en aplatissant la structure hiérarchique des données."

.collect(Collectors.toList());

NE RIEN ECRIRE


/* TODO 10 Avec l’api Stream*/ (3 points)
public void afficherEquipesPersonnalisees(Competition c, String nationalite) {
//M1 :
if (mapFifa.containsKey(c)) {
EnsembleEquipe ensembleEquipe = mapFifa.get(c);
ensembleEquipe.getEquipes().stream()
.filter(equipe -> equipe.rechercherJoueurParNationalite(nationalite))
.forEach(System.out::println);
}

7
//M2 : 100% STREAM:
mapFifa.entrySet().stream()
.filter(entry -> entry.getKey().equals(c))
.map(Map.Entry::getValue)
.findFirst()
.ifPresent(ensembleEquipe ->
ensembleEquipe.getEquipes().stream()
.filter(equipe -> equipe.rechercherJoueurParNationalite(nationalite))
.forEach(System.out::println)
);
}

/* TODO 11 */ public List<Competition> retournerCompetitionParJoueurTunisien() { (3 points)

return mapFifa.entrySet().stream()
.filter(entry ->
entry.getValue().getEquipes().stream()
.anyMatch(equipe -> equipe.rechercherJoueurParNationalite("Tunisien"))
)
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}

NE RIEN ECRIRE

8

/* TODO 12 */ (3 points)
public boolean returnSiUneEquipeParticpeEnPlusieursCompetitions() {
//M1 : (itérative)
Set<Equipe> equipesDejaVues = new HashSet<>();

for (EnsembleEquipe ensembleEquipe : mapFifa.values()) {

for (Equipe equipe : ensembleEquipe.getEquipes()) {
if (equipesDejaVues.contains(equipe)) {
// L'équipe a déjà été vue, ce qui signifie qu'elle participe à plusieurs compétitions
return true;
} else {
// Ajouter l'équipe à l'ensemble des équipes déjà vues
equipesDejaVues.add(equipe);
}
}
}

// Aucune équipe n'a été trouvée participant à plusieurs compétitions

return false;

M2 : (Stream)
Set<Equipe> equipesDejaVues = new HashSet<>();

return mapFifa.values().stream()
.flatMap(ensembleEquipe -> ensembleEquipe.getEquipes().stream())
.anyMatch(equipe -> !equipesDejaVues.add(equipe));

// Remarque :
equipesDejaVues.add(equipe) renvoie un boolean indiquant si l'ajout de l'équipe à l'ensemble
a réussi.
Cela signifie que si add retourne true, l'équipe n'était pas présente dans l'ensemble, et si
add retourne false, cela signifie que l'équipe était déjà présente.
En ajoutant (!) devant la condition, anyMatch retournera true si add retourne false,
Indiquant ainsi qu'une équipe participe à plusieurs compétitions.

9
}

Bon travail

10