Plan exhaustif et détaillé pour réussir le développement

de l'application Java

1. Préparation et planification
a. Compréhension du sujet
• Lire attentivement les consignes.
• Identifier toutes les fonctionnalités obligatoires et facultatives.

b. Définition des objectifs

• Objectifs de base : fonctionnalités minimum requises.
• Objectifs avancés : fonctionnalités personnalisées (popularité, avis, export, etc.).

c. Organisation des tâches

• Découper le projet en sous-tâches : design, codage, tests, documentation.

2. Conception du système
a. Diagrammes UML
• Diagramme de classes : Visualiser les relations entre les entités (Livre, Utilisateur,
etc.).
• Diagramme de séquence : Modéliser les interactions entre l'utilisateur et le système.
• Diagramme de cas d'utilisation : Définir les actions possibles pour l'utilisateur.

b. Définition des classes et attributs

• Classe Livre : titre, auteur, année, genre, disponibilité.
• Classe Utilisateur : nom, ID, historique.
• Classe Bibliotheque : gestion des livres et utilisateurs.
• Classe GestionBibliotheque : menu principal et navigation.

c. Choix des structures de données

• Utiliser des collections comme ArrayList, HashMap, ou LinkedList.

3. Initialisation du projet
a. Création du projet Java
• Utiliser un IDE (IntelliJ, Eclipse, NetBeans).
• Organiser les fichiers source dans des packages (models, services, main).

b. Installation des outils nécessaires

• JDK (Java Development Kit).
 • Librairies supplémentaires si besoin (e.g., pour l'export CSV).

4. Implémentation des fonctionnalités de base

a. Ajout de livres
• Méthode pour saisir et ajouter un livre dans une liste.

b. Recherche de livres
• Recherche par titre, auteur, ou genre.

c. Emprunt et retour de livres

• Vérification de la disponibilité.
• Mise à jour des statuts de disponibilité et historique.

d. Affichage des statistiques

• Liste des livres disponibles/empruntés.
• Historique des emprunts pour chaque utilisateur.

e. Suppression de livres
• Supprimer un livre par titre ou ID.

5. Ajout de fonctionnalités avancées

a. Classement des livres par popularité
• Compter le nombre d'emprunts pour chaque livre.

b. Notation et avis des utilisateurs

• Permettre aux utilisateurs de noter et commenter les livres.

c. Gestion des retards

• Ajouter une date d’échéance pour les emprunts.
• Calculer et notifier les retards.

d. Exportation des données

• Générer un fichier texte ou CSV des statistiques et historiques.

e. Interface utilisateur améliorée

• Utiliser des couleurs et une structure claire dans la console.
• Ajouter des animations simples pour améliorer l’expérience.
6. Tests unitaires et validation
a. Tests unitaires
• Tester chaque méthode individuellement (ajout, recherche, emprunt).

b. Tests d'intégration
• Tester le fonctionnement global en simulant plusieurs scénarios.

c. Gestion des erreurs

• Prévoir des exceptions personnalisées pour les cas d’erreur.

7. Optimisation et amélioration
a. Optimisation du code
• Refactorer les méthodes longues.
• Utiliser les bonnes pratiques Java (noms explicites, encapsulation).

b. Performance
• Vérifier la rapidité des recherches et des mises à jour.

8. Documentation
a. Documentation technique
• Description des classes, méthodes, et structures utilisées.

b. Documentation utilisateur
• Guide pour utiliser le programme.
• Instructions pour installer et exécuter l'application.

9. Présentation finale
a. Préparer des exemples d'exécution
• Captures d’écran ou démonstration en direct.

b. Préparer une explication orale

• Décrire les choix techniques, les difficultés rencontrées, et les solutions.

10. Maintenance et évolutivité

a. Prévoir des améliorations futures
• Ajouter une base de données pour la persistance.
 • Migrer vers une application graphique ou web.

b. Gestion des retours utilisateurs

• Corriger les bugs signalés.
• Ajouter des fonctionnalités demandées.

2.b. Définition des classes et attributs

Ce point est crucial pour établir une base solide de votre application. Voici une définition claire et
détaillée des classes principales et de leurs attributs, ainsi que des méthodes essentielles associées.

1. Classe Livre
Description :
Cette classe représente un livre dans la bibliothèque.

Attributs :
• titre : (String) Le titre du livre.
• auteur : (String) Le nom de l'auteur.
• anneePublication : (int) L'année de publication.
• genre : (String) Le genre du livre (e.g., Roman, Science-Fiction).
• estDisponible : (boolean) Indique si le livre est disponible pour emprunt.

Méthodes :
• afficherDetails() : Affiche les informations du livre.
• changerDisponibilite(boolean disponibilite) : Met à jour la disponibilité
du livre.

2. Classe Utilisateur
Description :
Cette classe représente un utilisateur qui peut emprunter des livres.

Attributs :
• nom : (String) Le nom complet de l'utilisateur.
• idUtilisateur : (int) Un identifiant unique pour l'utilisateur.
• historiqueEmprunts : (ArrayList) Liste des livres empruntés par l'utilisateur.

Méthodes :
• emprunterLivre(Livre livre) : Ajoute un livre à l'historique d'emprunts.
• retournerLivre(Livre livre) : Retire un livre de l'historique d'emprunts.
 • afficherHistorique() : Affiche tous les livres empruntés.

3. Classe Bibliotheque
Description :
Cette classe gère l’ensemble des livres et des utilisateurs de la bibliothèque.

Attributs :
• listeLivres : (ArrayList) Liste des livres dans la bibliothèque.
• listeUtilisateurs : (HashMap<Integer, Utilisateur>) Liste des utilisateurs, indexée
par leurs identifiants.

Méthodes :
• ajouterLivre(Livre livre) : Ajoute un livre à la bibliothèque.
• supprimerLivre(String titre) : Supprime un livre par son titre.
• rechercherLivre(String critere, String valeur) : Recherche un livre
par titre, auteur, ou genre.
• afficherStatistiques() : Affiche les statistiques des livres disponibles et
empruntés.
• emprunterLivre(int idUtilisateur, String titre) : Permet à un
utilisateur d’emprunter un livre.
• retournerLivre(int idUtilisateur, String titre) : Gère le retour d'un
livre par un utilisateur.

4. Classe GestionBibliotheque
Description :
Cette classe contient le menu interactif principal permettant à l'utilisateur d'interagir avec
l'application.

Attributs :
• bibliotheque : (Bibliotheque) Une instance de la bibliothèque.

Méthodes :
• afficherMenu() : Affiche le menu principal.
• traiterChoixUtilisateur() : Gère les choix de l’utilisateur (ajout, recherche,
emprunt, etc.).
• demarrerApplication() : Point d'entrée pour lancer l’application.

Relations entre les classes :

• Bibliotheque gère plusieurs objets Livre et Utilisateur.
• Utilisateur peut emprunter plusieurs objets Livre.
 • Les interactions avec l’utilisateur sont gérées dans GestionBibliotheque.

LinkedList en Java : Informations essentielles

La classe LinkedList fait partie de la bibliothèque Collections Framework de Java. Elle représente
une liste chaînée qui peut stocker des éléments dans un ordre séquentiel tout en offrant une gestion
dynamique de la mémoire.

Caractéristiques principales :
1. Structure de données dynamique : Contrairement à un tableau, une LinkedList peut
grandir ou diminuer sans besoin de redimensionnement.
2. Doublement chaînée : Chaque élément (appelé nœud) contient :
• Une référence à l'élément précédent.
• Une référence à l'élément suivant.
3. Ordre des éléments : Les éléments sont maintenus dans l'ordre dans lequel ils sont ajoutés.
4. Non synchronisée : Pas thread-safe sans synchronisation explicite.
5. Performances :
• Accès aléatoire lent : L'accès à un élément par son index est plus lent que dans un
ArrayList.
• Insertion et suppression rapides : Plus efficaces que dans un ArrayList, surtout
en début ou milieu de liste.

Importation :
Pour utiliser une LinkedList, vous devez importer son package :

import java.util.LinkedList;
Elle s’utilise de la même manière qu’une ArrayList.

1. Qu'est-ce qu'un package en Java ?

Un package est un regroupement logique de classes et d’interfaces. Il permet de :
• Organiser les fichiers source.
• Fournir un espace de noms pour éviter les conflits entre classes.
• Faciliter la gestion des droits d'accès (public, private, protected).

2. Structure recommandée pour votre projet

Pour un projet comme le système de gestion d'une bibliothèque virtuelle, voici une structure
courante :
src/
│
├── models/ // Contient les classes représentant les entités principales
│ ├── Livre.java
│ ├── Utilisateur.java
│
├── services/ // Contient les classes responsables de la logique métier
│ ├── Bibliotheque.java
│
├── main/ // Contient la classe principale pour lancer l'application
│ ├── GestionBibliotheque.java

3. Description des packages

a. models : Entités du système
Ce package contient les classes représentant les données ou objets métier. Chaque classe dans ce
package modélise une entité.
• Exemple de classes dans models :
• Livre : Représente un livre (titre, auteur, année, genre).
• Utilisateur : Représente un utilisateur de la bibliothèque (nom, ID, historique).

b. services : Logique métier

Ce package contient les classes responsables des opérations et de la gestion des données.
• Exemple de classe dans services :
• Bibliotheque : Contient les méthodes pour ajouter, supprimer, rechercher des
livres, gérer les emprunts, etc.

c. main : Point d’entrée du programme

Ce package contient la classe principale qui lance l'application et gère les interactions utilisateur.
• Exemple de classe dans main :
• GestionBibliotheque : Fournit un menu interactif en console pour naviguer
dans les différentes fonctionnalités.

Classe Livre : Implémentation simple, claire et bien documentée

Voici un exemple d'implémentation de la classe Livre en Java. Cette classe est conçue pour être
simple à comprendre, tout en étant riche en fonctionnalités.
package models;

/**
* Représente un livre dans la bibliothèque virtuelle.
* Chaque livre possède un titre, un auteur, une année de publication, un genre,
* et un statut indiquant s'il est disponible ou emprunté.
*/
public class Livre {

// Attributs privés pour garantir l'encapsulation

private String titre; // Titre du livre
private String auteur; // Auteur du livre
private int anneePublication; // Année de publication
private String genre; // Genre du livre (e.g., Roman, Science-
Fiction)
private boolean estDisponible; // Statut de disponibilité (true =
disponible, false = emprunté)

/**
* Constructeur pour initialiser un livre avec ses informations principales.
*
 * @param titre Le titre du livre.
* @param auteur L'auteur du livre.
* @param anneePublication L'année de publication du livre.
* @param genre Le genre du livre.
*/
public Livre(String titre, String auteur, int anneePublication, String
genre) {
this.titre = titre;
this.auteur = auteur;
this.anneePublication = anneePublication;
this.genre = genre;
this.estDisponible = true; // Par défaut, un livre est disponible lors
de son ajout.
}

// Méthodes getters pour accéder aux informations du livre

public String getTitre() {
return titre;
}

public String getAuteur() {

return auteur;
}

public int getAnneePublication() {

return anneePublication;
}

public String getGenre() {

return genre;
}

public boolean isDisponible() {

return estDisponible;
}

/**
* Change le statut de disponibilité du livre.
*
* @param disponible True si le livre est disponible, false s'il est
emprunté.
*/
public void setDisponible(boolean disponible) {
this.estDisponible = disponible;
}

/**
* Affiche les détails complets du livre.
*/
public void afficherDetails() {
System.out.println("Titre : " + titre);
System.out.println("Auteur : " + auteur);
System.out.println("Année de publication : " + anneePublication);
System.out.println("Genre : " + genre);
System.out.println("Disponibilité : " + (estDisponible ? "Disponible" :
"Emprunté"));
}

@Override
public String toString() {
return titre + " par " + auteur + " (" + anneePublication + ") - " +
genre;
}
}
Explications et points clés :
1. Attributs privés :
Utilisés pour garantir l'encapsulation. L'accès aux informations se fait via des getters.
2. Constructeur :
Permet d'initialiser les détails du livre lors de sa création. Le statut estDisponible est
par défaut true.

3. Méthodes principales :
• afficherDetails() : Affiche toutes les informations du livre de manière
lisible.
• setDisponible() : Change le statut de disponibilité, utile lors d'emprunts ou de
retours.
4. Surcharge de toString() :
Fournit une représentation succincte et lisible du livre, utile lors d'affichages rapides (e.g.,
dans des listes).

Exemple d'utilisation de la classe Livre :

public class TestLivre {
public static void main(String[] args) {
// Création d'un livre
Livre livre = new Livre("1984", "George Orwell", 1949, "Dystopie");

// Affichage des détails du livre

livre.afficherDetails();

// Vérification de la disponibilité
System.out.println("Le livre est-il disponible ? " +
(livre.isDisponible() ? "Oui" : "Non"));

// Modification du statut de disponibilité

livre.setDisponible(false);
System.out.println("Statut après emprunt : " + (livre.isDisponible() ?
"Disponible" : "Emprunté"));
}
}

Exemple de sortie console :

Titre : 1984
Auteur : George Orwell
Année de publication : 1949
Genre : Dystopie
Disponibilité : Disponible
Le livre est-il disponible ? Oui
Statut après emprunt : Emprunté

Implémentation de la classe Utilisateur

Voici une version claire, simple et bien structurée de la classe Utilisateur en Java, conforme
aux exigences du sujet. Cette classe est conçue pour gérer les emprunteurs et leurs interactions avec
la bibliothèque.
package models;

import java.util.ArrayList;

/**
* Représente un utilisateur de la bibliothèque virtuelle.
* Chaque utilisateur a un nom, un identifiant unique et un historique de livres
empruntés.
*/
public class Utilisateur {

// Attributs privés pour l'encapsulation

private String nom; // Nom complet de l'utilisateur
private int idUtilisateur; // Identifiant unique de
l'utilisateur
private ArrayList<String> historiqueEmprunts; // Historique des titres de
livres empruntés

/**
* Constructeur pour initialiser un utilisateur avec un nom et un
identifiant.
*
* @param nom Le nom de l'utilisateur.
* @param idUtilisateur L'identifiant unique de l'utilisateur.
*/
public Utilisateur(String nom, int idUtilisateur) {
this.nom = nom;
this.idUtilisateur = idUtilisateur;
this.historiqueEmprunts = new ArrayList<>(); // Initialisation de
l'historique d'emprunts
}

// Getters pour accéder aux attributs privés

public String getNom() {
return nom;
}

public int getIdUtilisateur() {

return idUtilisateur;
}

public ArrayList<String> getHistoriqueEmprunts() {

return historiqueEmprunts;
}

/**
* Ajoute un titre de livre à l'historique des emprunts.
*
* @param titreLivre Le titre du livre emprunté.
*/
public void emprunterLivre(String titreLivre) {
historiqueEmprunts.add(titreLivre);
System.out.println("Le livre '" + titreLivre + "' a été emprunté par " +
nom + ".");
}

/**
* Supprime un titre de livre de l'historique des emprunts (lors d'un
retour).
*
* @param titreLivre Le titre du livre à retourner.
*/
public void retournerLivre(String titreLivre) {
if (historiqueEmprunts.remove(titreLivre)) {
 System.out.println("Le livre '" + titreLivre + "' a été retourné par
" + nom + ".");
} else {
System.out.println("Erreur : Le livre '" + titreLivre + "' n'est pas
dans l'historique d'emprunts de " + nom + ".");
}
}

/**
* Affiche l'historique des livres empruntés par l'utilisateur.
*/
public void afficherHistorique() {
System.out.println("Historique des emprunts de " + nom + " :");
if (historiqueEmprunts.isEmpty()) {
System.out.println("Aucun livre emprunté.");
} else {
for (String titre : historiqueEmprunts) {
System.out.println("- " + titre);
}
}
}

@Override
public String toString() {
return "Utilisateur [Nom=" + nom + ", ID=" + idUtilisateur + "]";
}
}

Points clés de cette implémentation :

1. Encapsulation : Les attributs sont privés et accessibles uniquement via des getters.
2. Gestion des emprunts :
• La méthode emprunterLivre ajoute un livre à l'historique.
• La méthode retournerLivre gère le retour d'un livre, avec un message en cas
d'erreur.
3. Affichage : La méthode afficherHistorique liste les livres empruntés par
l'utilisateur.
4. Surcharge de toString() : Fournit une représentation lisible de l'objet utilisateur, utile
pour des affichages rapides.

Exemple d'utilisation :
public class TestUtilisateur {
public static void main(String[] args) {
// Création d'un utilisateur
Utilisateur utilisateur = new Utilisateur("Jean Dupont", 101);

// Emprunt de livres
utilisateur.emprunterLivre("1984");
utilisateur.emprunterLivre("Le Petit Prince");

// Affichage de l'historique des emprunts

utilisateur.afficherHistorique();
 // Retour d'un livre
utilisateur.retournerLivre("1984");

// Affichage de l'historique après le retour

utilisateur.afficherHistorique();
}
}

Sortie console pour le test :

Le livre '1984' a été emprunté par Jean Dupont.
Le livre 'Le Petit Prince' a été emprunté par Jean Dupont.
Historique des emprunts de Jean Dupont :
- 1984
- Le Petit Prince
Le livre '1984' a été retourné par Jean Dupont.
Historique des emprunts de Jean Dupont :
- Le Petit Prince

Si vous avez des suggestions ou souhaitez des modifications, je suis à votre disposition !
D'après le fichier fourni, je vais implémenter une classe Bibliotheque en Java, parfaitement
structurée et documentée. Cette classe permettra de gérer les livres et les emprunts dans une
application console de bibliothèque virtuelle. Je vais également veiller à ce que le code soit clair et
convivial.
Voici une première version de la classe Bibliotheque :
import java.util.*;

/**
* Classe représentant une bibliothèque virtuelle.
* Gère les opérations telles que l'ajout, la recherche, l'emprunt,
* le retour et la suppression de livres.
*/
public class Bibliotheque {

// Liste pour stocker les livres de la bibliothèque

private List<Livre> livres;

// Historique des emprunts (Utilisateur -> Liste des livres empruntés)

private Map<Utilisateur, List<Livre>> historiqueEmprunts;
/**
* Constructeur de la classe Bibliotheque.
* Initialise les structures de données.
*/
public Bibliotheque() {
this.livres = new ArrayList<>();
this.historiqueEmprunts = new HashMap<>();
}

/**
* Ajoute un livre à la bibliothèque.
* @param livre Le livre à ajouter.
*/
public void ajouterLivre(Livre livre) {
if (livre != null) {
livres.add(livre);
System.out.println("Livre ajouté : " + livre);
} else {
System.out.println("Erreur : Le livre est invalide.");
}
}

/**
* Recherche des livres par un critère donné.
* @param critere Le critère de recherche ("titre", "auteur", "genre").
* @param valeur La valeur associée au critère.
* @return La liste des livres correspondant au critère.
*/
public List<Livre> rechercherLivres(String critere, String valeur) {
List<Livre> resultats = new ArrayList<>();
for (Livre livre : livres) {
switch (critere.toLowerCase()) {
 case "titre":
if (livre.getTitre().equalsIgnoreCase(valeur)) {
resultats.add(livre);
}
break;
case "auteur":
if (livre.getAuteur().equalsIgnoreCase(valeur)) {
resultats.add(livre);
}
break;
case "genre":
if (livre.getGenre().equalsIgnoreCase(valeur)) {
resultats.add(livre);
}
break;
default:
System.out.println("Critère invalide : " + critere);
}
}
return resultats;
}

/**
* Permet à un utilisateur d'emprunter un livre.
* @param utilisateur L'utilisateur qui emprunte le livre.
* @param livre Le livre à emprunter.
*/
public void emprunterLivre(Utilisateur utilisateur, Livre livre) {
if (livre != null && livres.contains(livre) && livre.isDisponible()) {
livre.setDisponible(false);
historiqueEmprunts.putIfAbsent(utilisateur, new ArrayList<>());
historiqueEmprunts.get(utilisateur).add(livre);
 System.out.println(utilisateur.getNom() + " a emprunté le livre : " + livre);
} else {
System.out.println("Le livre n'est pas disponible ou n'existe pas.");
}
}

/**
* Permet à un utilisateur de retourner un livre emprunté.
* @param utilisateur L'utilisateur qui retourne le livre.
* @param livre Le livre à retourner.
*/
public void retournerLivre(Utilisateur utilisateur, Livre livre) {
if (historiqueEmprunts.containsKey(utilisateur) &&
historiqueEmprunts.get(utilisateur).remove(livre)) {
livre.setDisponible(true);
System.out.println(utilisateur.getNom() + " a retourné le livre : " + livre);
} else {
System.out.println("Erreur : Retour impossible.");
}
}

/**
* Affiche les statistiques de la bibliothèque.
* - Liste des livres disponibles.
* - Liste des livres empruntés.
*/
public void afficherStatistiques() {
System.out.println("\n--- Statistiques de la bibliothèque ---");

System.out.println("\nLivres disponibles :");

for (Livre livre : livres) {
if (livre.isDisponible()) {
 System.out.println(livre);
}
}

System.out.println("\nLivres empruntés :");

for (Livre livre : livres) {
if (!livre.isDisponible()) {
System.out.println(livre);
}
}
}

/**
* Supprime un livre de la bibliothèque.
* @param livre Le livre à supprimer.
*/
public void supprimerLivre(Livre livre) {
if (livres.remove(livre)) {
System.out.println("Livre supprimé : " + livre);
} else {
System.out.println("Erreur : Le livre n'existe pas dans la bibliothèque.");
}
}
}

Description du Code
1. Attributs Principaux :
• livres : Une liste pour stocker les livres.
• historiqueEmprunts : Une map pour garder une trace des emprunts.
2. Méthodes Clés :
• ajouterLivre : Ajoute un nouveau livre à la bibliothèque.
• rechercherLivres : Permet la recherche de livres selon un critère.
• emprunterLivre : Gère l'emprunt de livres par des utilisateurs.
• retournerLivre : Permet de retourner un livre emprunté.
 • afficherStatistiques : Affiche les livres disponibles et empruntés.
• supprimerLivre : Supprime un livre de la bibliothèque.
3. Gestion des erreurs : Messages explicites en cas d'erreurs (critère invalide, livre
indisponible, etc.).
Souhaitez-vous que je crée également les classes auxiliaires Livre et Utilisateur ainsi que le
menu principal pour l'application console ?
Voici une implémentation de la classe GestionBibliotheque, qui répond parfaitement aux exigences
du sujet. Le code est clair, simple, riche en fonctionnalités, et bien documenté pour une meilleure
compréhension.

GestionBibliotheque.java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// Classe représentant un livre

class Livre {
private String titre;
private String auteur;
private int anneePublication;
private String genre;
private boolean estEmprunte;

public Livre(String titre, String auteur, int anneePublication, String

genre) {
this.titre = titre;
this.auteur = auteur;
this.anneePublication = anneePublication;
this.genre = genre;
this.estEmprunte = false;
}

public String getTitre() {

return titre;
}

public String getAuteur() {

return auteur;
}

public String getGenre() {

return genre;
}

public boolean estDisponible() {

return !estEmprunte;
}

public void emprunter() {

estEmprunte = true;
}

public void retourner() {

estEmprunte = false;
}
 @Override
public String toString() {
return String.format("Titre: %s, Auteur: %s, Année: %d, Genre: %s,
Disponible: %s",
titre, auteur, anneePublication, genre, estDisponible() ?
"Oui" : "Non");
}
}

// Classe représentant un utilisateur

class Utilisateur {
private String nom;
private List<Livre> emprunts;

public Utilisateur(String nom) {

this.nom = nom;
this.emprunts = new ArrayList<>();
}

public String getNom() {

return nom;
}

public List<Livre> getEmprunts() {

return emprunts;
}

public void emprunterLivre(Livre livre) {

emprunts.add(livre);
}

public void retournerLivre(Livre livre) {

emprunts.remove(livre);
}

@Override
public String toString() {
return "Nom: " + nom + ", Emprunts: " + emprunts.stream()
.map(Livre::getTitre)
.collect(Collectors.joining(", "));
}
}

// Classe principale pour gérer la bibliothèque

public class GestionBibliotheque {
private List<Livre> livres;
private Map<String, Utilisateur> utilisateurs;

public GestionBibliotheque() {
livres = new ArrayList<>();
utilisateurs = new HashMap<>();
}

// Ajout d'un nouveau livre

public void ajouterLivre(String titre, String auteur, int anneePublication,
String genre) {
livres.add(new Livre(titre, auteur, anneePublication, genre));
System.out.println("Livre ajouté avec succès !");
}

// Recherche de livres
public List<Livre> rechercherLivre(String critere, String valeur) {
return livres.stream()
 .filter(livre -> (critere.equalsIgnoreCase("titre") &&
livre.getTitre().equalsIgnoreCase(valeur)) ||
(critere.equalsIgnoreCase("auteur") &&
livre.getAuteur().equalsIgnoreCase(valeur)) ||
(critere.equalsIgnoreCase("genre") &&
livre.getGenre().equalsIgnoreCase(valeur)))
.collect(Collectors.toList());
}

// Emprunt d'un livre

public void emprunterLivre(String nomUtilisateur, String titreLivre) {
Utilisateur utilisateur = utilisateurs.computeIfAbsent(nomUtilisateur,
Utilisateur::new);
for (Livre livre : livres) {
if (livre.getTitre().equalsIgnoreCase(titreLivre) &&
livre.estDisponible()) {
livre.emprunter();
utilisateur.emprunterLivre(livre);
System.out.println("Livre emprunté avec succès !");
return;
}
}
System.out.println("Livre indisponible ou introuvable.");
}

// Retour d'un livre

public void retournerLivre(String nomUtilisateur, String titreLivre) {
Utilisateur utilisateur = utilisateurs.get(nomUtilisateur);
if (utilisateur != null) {
for (Livre livre : utilisateur.getEmprunts()) {
if (livre.getTitre().equalsIgnoreCase(titreLivre)) {
livre.retourner();
utilisateur.retournerLivre(livre);
System.out.println("Livre retourné avec succès !");
return;
}
}
}
System.out.println("Livre non trouvé dans les emprunts de
l'utilisateur.");
}

// Suppression d'un livre

public void supprimerLivre(String titreLivre) {
livres.removeIf(livre -> livre.getTitre().equalsIgnoreCase(titreLivre));
System.out.println("Livre supprimé avec succès !");
}

// Affichage des statistiques

public void afficherStatistiques() {
System.out.println("Liste des livres disponibles :");

livres.stream().filter(Livre::estDisponible).forEach(System.out::println);

System.out.println("\nListe des livres empruntés :");

livres.stream().filter(livre -> !
livre.estDisponible()).forEach(System.out::println);

System.out.println("\nHistorique des emprunts par utilisateur :");

utilisateurs.values().forEach(System.out::println);
}
}
Fonctionnalités principales :
1. Ajout de livres.
2. Recherche par titre, auteur ou genre.
3. Emprunt et retour de livres.
4. Affichage des livres disponibles/empruntés et historique par utilisateur.
5. Suppression d’un livre.
L'intégration de ce code dans une classe principale avec un menu interactif permettra de finaliser
une application console. Souhaitez-vous que je génère également ce menu interactif ?