package Tp1;

import static [Link].*;

public class Somme {

public static void main(String[] args) {

// Vérifier si des arguments ont été fournis

if ([Link] == 0) {

[Link]("Veuillez fournir des mots en argument.");

return;

int som = 0; // Initialiser la somme à 0

for (int i = 0; i < [Link]; i++) {

try {

// Essayer de convertir l'argument en entier

int a = [Link](args[i]);

som += a; // Ajouter l'entier à la somme

} catch (NumberFormatException e) {

// Si l'argument n'est pas un entier, afficher un message d'erreur

[Link]("L'argument '" + args[i] + "' n'est pas un entier valide.");

// Afficher le résultat de la somme

[Link]("La somme est : " + som);

 }

package Tp1;

public class Morse {

public static void main(String[] args) {

// Vérifier si des arguments ont été fournis

if ([Link] == 0) {

[Link]("Veuillez fournir des mots en argument.");

return;

// Parcourir les arguments et les afficher séparés par " Stop."

for (int i = 0; i < [Link]; i++) {

[Link](args[i]+" Stop. ");

package bibliotheque;

import [Link];

import [Link];

public class Bibliotheque implements Serializable {

private Vector<Livre> livres;

private int capaciteMax;

// Constructeur

public Bibliotheque(int capaciteMax) {

[Link] = capaciteMax;

[Link] = new Vector<>(capaciteMax);

// Ajouter un livre

public boolean ajouteLivre(Livre livre) {

if ([Link]() < capaciteMax) {

[Link](livre);

return true;

return false;

// Récupérer le nombre de livres

public int size() {

return [Link]();

// Récupérer la capacité

public int capacite() {

return capaciteMax;

}
 // Chercher un livre par auteur

public Vector<Livre> cherche(String auteur) {

Vector<Livre> livresTrouves = new Vector<>();

for (Livre livre : livres) {

for (String a : [Link]()) {

if ([Link]().startsWith([Link]())) {

[Link](livre);

break; // Évite d'ajouter plusieurs fois le même livre

return livresTrouves;

// La méthode toLowerCase() convertit les deux chaînes

//(l'auteur recherché et l'auteur dans la liste) en minuscules avant de faire la

comparaison.

// Afficher les livres

@Override

public String toString() {

StringBuffer sb = new StringBuffer();

[Link]("Liste des livres :\n");

for (Livre livre : livres) {

[Link]([Link]()).append("\n\n");

return [Link]();

package Tp1;
import [Link];

public class Livre implements Serializable {

// Attributs de la classe Livre

private String titre; // Titre du livre

private String[] auteurs; // Tableau d'auteurs

private String ISBN; // Numéro ISBN du livre

private double prix; // Prix du livre en euros

public Livre(String titre,String[] auteurs,String ISBN,double prix){

[Link]=titre;

[Link]=auteurs;

[Link]=ISBN;

[Link]=prix;

public String getTitre() { return titre;}

public String[] getAuteurs() { return auteurs;}

public String getISBN() {return ISBN;}

public double getPrix() {return prix;}

public void setTitre(String titre) {[Link]=titre;}

public void setAuteurs(String[] auteurs) {[Link]=auteurs;}

public void setISBN(String ISBN) {[Link]=ISBN;}

public void setPrix(double prix) {[Link]=prix;}

public String toString() {

StringBuffer details=new StringBuffer();

[Link]("Titre: ").append(titre).append("\n");

[Link]("ISBN: ").append(ISBN).append("\n");

[Link]("Prix: ").append(prix).append("\n");
 [Link]("Auteurs: \n");

for(String auteur:auteurs) {

[Link](" -").append(auteur).append("\n");

return [Link]();

// Méthode pour vérifier si un auteur commence par un nom donné

public boolean auteurCommencePar(String auteur) {

for(String a : auteurs ) {

if([Link]().startsWith([Link]())) {

return true;

return false;

public static void main(String[] args) {

}
 // Méthode pour récupérer les livres

public Vector<Livre> getLivres() {

return livres;

package Tp1;

import [Link];

import [Link].*;

import [Link];

public class TestBibliotheque {

public static void main(String[] args) {

Scanner clavier = new Scanner([Link]);

Bibliotheque B = null;

try {

[Link]("Entrez la capacité maximale de la bibliothèque : ");

int capaciteMax = [Link]();

[Link](); // Consommer le retour à la ligne

B = new Bibliotheque(capaciteMax);

} catch (Exception e) {

[Link]("Erreur lors de la saisie de la capacité. Veuillez entrer un

nombre valide.");

return;

}
 // Charger la bibliothèque depuis le fichier si elle existe

try (ObjectInputStream ois = new ObjectInputStream(new

FileInputStream("fichierObjet"))) {

B = (Bibliotheque) [Link]();

} catch (FileNotFoundException e) {

[Link](" Aucun fichier précédent trouvé, démarrage d'une nouvelle

bibliothèque.");

} catch (IOException | ClassNotFoundException e) {

[Link](" Erreur lors du chargement du fichier : " + [Link]());

while (true) {

[Link]("=== Menu Bibliothèque ===");

[Link]("1. Ajouter un Livre");

[Link]("2. Afficher la Bibliothèque");

[Link]("3. Calculer la taille et capacité de la Bibliothèque");

[Link]("4. Rechercher un livre par auteur");

[Link]("5. Quitter");

[Link]("Choisissez une option : ");

int choix;

try {

choix = [Link]();

[Link]();

} catch (Exception e) {

[Link](" Veuillez entrer un nombre valide.");

[Link]();

continue;

}
 switch (choix) {

case 1:

try {

[Link]("Entrez le titre : ");

String titre = [Link]();

[Link]("Combien d'auteurs : ");

int nbAuteurs = [Link]();

[Link]();

if (nbAuteurs <= 0) throw new IllegalArgumentException("Le nombre

d'auteurs doit être positif.");

String[] auteurs = new String[nbAuteurs];

for (int i = 0; i < nbAuteurs; i++) {

[Link]("Nom de l'auteur " + (i + 1) + " : ");

auteurs[i] = [Link]();

[Link]("Entrez ISBN : ");

String ISBN = [Link]();

[Link]("Entrez le prix : ");

double prix = [Link]();

[Link]();

if (prix < 0) throw new IllegalArgumentException("Le prix ne peut pas être

négatif.");

Livre livre = new Livre(titre, auteurs, ISBN, prix);

 if ([Link](livre)) {

[Link](" Livre ajouté avec succès !");

} else {

[Link](" La bibliothèque est pleine !");

} catch (Exception e) {

[Link](" Erreur lors de l'ajout du livre : " + [Link]());

[Link]();

break;

case 2:

if ([Link]() == 0) {

[Link](" La bibliothèque est vide !");

} else {

[Link]("\n Contenu de la bibliothèque :");

[Link](B);

break;

case 3:

[Link](" Capacité de la bibliothèque : " + [Link]());

[Link](" Nombre de livres dans la bibliothèque : " + [Link]());

break;

case 4:

[Link]("Donner le nom ou le début du nom de l'auteur :");

String nom = [Link]();

 Vector<Livre> result = [Link](nom);

if ([Link]()) {

[Link]("Aucun livre trouvé pour cet auteur.");

} else {

[Link]("\n Livres trouvés :");

for (Livre l : result) {

[Link](l);

break;

case 5:

try (ObjectOutputStream oos = new ObjectOutputStream(new

FileOutputStream("fichierObjet"))) {

[Link](B);

[Link]();

} catch (IOException e) {

[Link]("Erreur lors de l'écriture du fichier : " + [Link]());

[Link]("au revoir !");

[Link]();

return;

default:

[Link](" Option invalide. Veuillez choisir une option valide.");

}
}

package Tp1;

public class TestLivre {

public static void main(String[] args) {

String[] auteurs = {"J.K. Rowling", "John Tiffany", "Jack Thorne"};

Livre livre = new Livre("Harry Potter and the Cursed Child", auteurs, "978-1-338-
28468-7", 19.99);

[Link](livre);

package hh;

import [Link];

// Exception pour un nombre d'arguments impair

class NombreArgumentsImpairException extends Exception {

public NombreArgumentsImpairException() {

super("Le nombre d'arguments doit être pair.");

// Exception pour un argument invalide

class ArgumentInvalideException extends Exception {

public ArgumentInvalideException(String message) {

 super(message);

// Exception pour un argument qui n'est pas un nombre valide

class NombreInvalideException extends ArgumentInvalideException {

public NombreInvalideException(String argument) {

super("L'argument '" + argument + "' n'est pas un nombre valide.");

// Exception pour un nombre de décimales invalide

class DecimalesInvalideException extends ArgumentInvalideException {

public DecimalesInvalideException(String argument) {

super("Le nombre de décimales '" + argument + "' n'est pas un entier valide.");

// Exception pour un nombre de décimales négatif

class DecimalesNegativesException extends ArgumentInvalideException {

public DecimalesNegativesException() {

super("Le nombre de décimales ne peut pas être négatif.");

public class Arrondir {

public static String tronque(double x, int nbDecimales) {

 String str = [Link](x);

StringTokenizer tokenizer = new StringTokenizer(str, ".");

String intPart = [Link]();

String decimalPart = [Link]() ? [Link]() : ""; // Évite

l'erreur

if (nbDecimales == 0 || [Link]()) {

return intPart;

if ([Link]() > nbDecimales) {

decimalPart = [Link](0, nbDecimales); // Tronquer

return intPart + "." + decimalPart;

public static void main(String[] args) {

try {

// Vérifier s'il n'y a pas d'arguments

if ([Link] == 0) {

throw new ArgumentInvalideException("Aucun argument fourni. Veuillez entrer

au moins un nombre et un nombre de décimales.");

// Vérifier si le nombre d'arguments est impair

if ([Link] % 2 != 0) {

throw new NombreArgumentsImpairException();

}
 for (int i = 0; i < [Link]; i += 2) {

// Vérifier si le premier argument est un double valide

double x;

try {

x = [Link](args[i]);

} catch (NumberFormatException e) {

throw new NombreInvalideException(args[i]);

// Vérifier si le deuxième argument est un entier valide et positif ou nul

int nbDecimales;

try {

nbDecimales = [Link](args[i + 1]);

if (nbDecimales < 0) {

throw new DecimalesNegativesException(); // Vérification ici

} catch (NumberFormatException e) {

throw new DecimalesInvalideException(args[i + 1]);

// Affichage du résultat après troncature

[Link](tronque(x, nbDecimales) + "\t");

[Link](); // Nouvelle ligne après affichage

} catch (Exception e) {

[Link]("Erreur : " + [Link]());

}
 }

package hh;

import [Link];

public class EssaiTri {

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

TriSimple tri = new TriSimple();

while (true) {

[Link]("\nOptions :");

[Link](" a - Ajouter une valeur");

[Link](" s - Supprimer une valeur");

[Link](" q - Quitter");

[Link]("Entrez votre commande : ");

String input = [Link]().trim();

if ([Link]()) {

[Link]("Erreur : Veuillez entrer une commande valide.");

continue;

char commande = [Link](0);

if (commande == 'q') {
 [Link]("Programme terminé.");

break;

} else if (commande == 'a' || commande == 's') {

[Link]("Entrez la valeur entière : ");

String valeurStr = [Link]().trim();

if ([Link]()) {

[Link]("Erreur : La valeur ne peut pas être vide.");

continue;

try {

int valeur = [Link](valeurStr);

if (commande == 'a') {

[Link](valeur);

[Link]("Tableau après insertion : " + tri);

[Link]("Taille du tableau : " + [Link]()); // Affichage de la

taille

} else {

try {

[Link](valeur);

[Link]("Tableau après suppression : " + tri);

[Link]("Taille du tableau : " + [Link]()); // Affichage de la

taille

} catch (EmptyEntiersException | EntierNotExistException e) {

[Link](e);

}
 } catch (NumberFormatException e) {

[Link]("Erreur : Veuillez entrer un nombre entier valide.");

} else {

[Link]("Erreur : Commande inconnue. Veuillez entrer 'a', 's' ou 'q'.");

[Link]();

package hh;

import [Link];

class TriSimple {

private int[] tableau;

private int taille;

private int capacite;

private int increment;

public TriSimple() {

[Link] = 3; // Taille par défaut

[Link] = 6;

[Link] = new int[capacite];

[Link] = 0;

// Méthode pour obtenir la taille du tableau

public int getTaille() {

return taille;

public TriSimple(int capaciteInitiale, int increment) {

[Link] = capaciteInitiale;

[Link] = increment;

[Link] = new int[capacite];

[Link] = 0;

public void inserer(int entier) {

if (taille == capacite) {

agrandirTableau();

int i = taille - 1;

while (i >= 0 && tableau[i] > entier) {

tableau[i + 1] = tableau[i];

i--;

tableau[i + 1] = entier;

taille++;

private void agrandirTableau() {

capacite += increment;

tableau = [Link](tableau, capacite);

}
 public void supprimer(int entier) throws EmptyEntiersException,
EntierNotExistException {

if (taille == 0) {

throw new EmptyEntiersException();

int index = -1;

for (int i = 0; i < taille; i++) {

if (tableau[i] == entier) {

index = i;

break;

if (index == -1) {

throw new EntierNotExistException();

for (int i = index; i < taille - 1; i++) {

tableau[i] = tableau[i + 1];

taille--;

reduireTableau();

private void reduireTableau() {

if (capacite - taille >= 2 * increment) {

 capacite -= increment;

tableau = [Link](tableau, capacite);

@Override

public String toString() {

return [Link]([Link](tableau, taille));

class EmptyEntiersException extends Exception {

@Override

public String toString() {

return "EmptyEntiersException: Le tableau est vide, suppression impossible!";

class EntierNotExistException extends Exception {

@Override

public String toString() {

return "EntierNotExistException: La valeur n'existe pas dans le tableau!";

/* private Chambre[]chambres;

private int nbChambres;

private String FICHIER = "[Link]";

public Hotel(int taille) {

chambres=new Chambre[taille];

nbChambres=0;

public class GestionChambres {

// Méthode pour saisir une chambre

public static Chambre saisirChambre() {

Scanner clavier = new Scanner([Link]);

int capacite;

double prix;

[Link]("Entrez le numéro de la chambre : ");

int numero = [Link]();

[Link]("Entrez la catégorie : ");

int categorie = [Link]();

do {

[Link]("Entrez la capacité entre 1 et 4: ");

capacite = [Link]();

}while(capacite<=1 ||capacite>=4);

do {

[Link]("Entrez le prix superieur a 0 : ");

prix = [Link]();
 }while(prix<=0);

return new Chambre(numero, categorie, prix, capacite, 'L'); // État par défaut :
Libre

public void saisirTableau() {

Scanner clavier = new Scanner([Link]);

[Link]("Nombre de chambres à ajouter : ");

int nombre = [Link]();

if (nbChambres >= [Link]) {

[Link](" Tableau plein, impossible d'ajouter de nouvelles

chambres !");

return;

for (int i = 0; i < nombre && nbChambres < [Link]; i++) {

try {

chambres[nbChambres] = saisirChambre(); // Saisie de la chambre

nbChambres++; // Incrémentation après ajout réussi

} catch (Exception e) {

[Link](" Erreur lors de l'ajout : " + [Link]());

public void afficherChambresParCategorie(int categorie) {

 [Link]("Chambres de la catégorie " + categorie + " :");

for(int i=0;i<nbChambres;i++) {

if(chambres[i].getCategorie()==categorie) {

[Link](chambres);

// c. Trier les chambres par capacité (ordre croissant)

public void trierChambresParCapacite(Chambre[] chambres) {

[Link](chambres, (c1, c2) -> [Link]([Link](),

[Link]()));

[Link]("\n Chambres triées par capacité (ordre croissant) !");

sauvegarderChambres();

/*

* // Trier les chambres par capacité (ordre croissant)

public static void trierParCapacite() {

for (int i = 0; i < nbChambres - 1; i++) {

for (int j = i + 1; j < nbChambres; j++) {

if (chambres[i].capacite > chambres[j].capacite) {

Chambre temp = chambres[i];

chambres[i] = chambres[j];

chambres[j] = temp;
 }

sauvegarderChambres();

[Link]("Chambres triées par capacité !");

*/

// Charger les chambres depuis le fichier en parsant directement chaque ligne

/* public void chargerChambres() {

try (BufferedReader reader = new BufferedReader(new FileReader(FICHIER))) {

String ligne;

nbChambres = 0;

while ((ligne = [Link]()) != null && nbChambres < [Link] ) {

// Supposons que la ligne est au format "numero,categorie,prix,capacite,etat"

String[] parts = [Link](",");

int numero = [Link](parts[0]);

int categorie = [Link](parts[1]);

double prix = [Link](parts[2]);

int capacite = [Link](parts[3]);

char etat = parts[4].charAt(0);

chambres[nbChambres++] = new Chambre(numero, categorie, prix, capacite,

etat);

} catch (FileNotFoundException e) {

[Link]("Fichier non trouvé, création d'un nouveau fichier...");

 } catch (IOException e) {

[Link]("Erreur de lecture du fichier !");

// Sauvegarder les chambres dans le fichier avec BufferedWriter

public void sauvegarderChambres() {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(FICHIER))) {

for (int i = 0; i < nbChambres; i++) {

[Link](chambres[i].toString());

[Link]();

[Link]("Données enregistrées !");

} catch (IOException e) {

[Link]("Erreur lors de l'écriture dans le fichier !");

/*

* // Sauvegarder toutes les chambres dans le fichier

private void sauvegarderDansFichier() {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(fichier))) {

for (Chambre ch : chambres) {

[Link]([Link]());
 [Link]();

} catch (IOException e) {

[Link]();

*/

/* public void ajouterChambre() {

if (nbChambres < [Link]) {

try {

Chambre nouvelleChambre = saisirChambre(); // Saisie

chambres[nbChambres] = nouvelleChambre; // Ajout dans le tableau

nbChambres++; // Incrémentation après l'ajout réussi

sauvegarderChambres(); // Sauvegarde

[Link](" Chambre ajoutée !");

} catch (Exception e) {

[Link](" Erreur : " + [Link]());

} else {

[Link](" Tableau plein, impossible d'ajouter une nouvelle chambre

!");

// Supprimer une chambre par numéro

public void supprimerChambre() {

Scanner clavier = new Scanner([Link]);

[Link]("Entrez le numéro de la chambre à supprimer : ");

 int numero = [Link]();

int index = -1;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].numero == numero) {

index = i;

break;

if (index == -1) {

[Link]("Chambre introuvable !");

return;

// Décalage des éléments pour combler le trou

for (int i = index; i < nbChambres - 1; i++) {

chambres[i] = chambres[i + 1];

chambres[--nbChambres] = null;

sauvegarderChambres();

[Link]("Chambre supprimée !");

// Modifier une chambre par numéro (prix et capacité)

public void modifierChambre() {

Scanner clavier = new Scanner([Link]);

[Link]("Entrez le numéro de la chambre à modifier : ");

int numero = [Link]();

int index = -1;

 for (int i = 0; i < nbChambres; i++) {

if (chambres[i].numero == numero) {

index = i;

break;

if (index == -1) {

[Link]("Chambre introuvable !");

return;

[Link]("Entrez le nouveau prix : ");

double nouveauPrix = [Link]();

[Link]("Entrez la nouvelle capacité (entre 1 et 4) : ");

int nouvelleCapacite = [Link]();

chambres[index].prix = nouveauPrix;

chambres[index].capacite = nouvelleCapacite;

sauvegarderChambres();

[Link]("Chambre modifiée !");

// Afficher toutes les chambres

public void afficherChambres() {

if (nbChambres == 0) {

[Link]("Aucune chambre enregistrée.");

return;

[Link]("Liste des chambres :");

for (int i = 0; i < nbChambres; i++) {

[Link](chambres[i]);
 }

*/

package ensemble;

import [Link].*;

import [Link].*;

import [Link];

public class Hotel {

private Chambre[] chambres;

private int nbChambres;

public Hotel(int taille) {

chambres = new Chambre[taille];

nbChambres = 0;

// Saisir une chambre avec vérification des entrées

public Chambre saisirChambre() {

int capacite;

double prix;

Scanner clavier=new Scanner([Link]);

[Link]("Entrez le numéro de la chambre : ");

int numero = [Link]();

[Link]("Entrez la catégorie : ");

int categorie = [Link]();

 do {

[Link]("Entrez la capacité (entre 1 et 4) : ");

capacite = [Link]();

} while (capacite < 1 || capacite > 4);

do {

[Link]("Entrez le prix (supérieur à 0) : ");

prix = [Link]();

} while (prix <= 0);

return new Chambre(numero, categorie, prix, capacite, 'L'); // 'L' pour Libre

// Ajouter plusieurs chambres

public void saisirTableau() {

Scanner clavier=new Scanner([Link]);

[Link]("Nombre de chambres à ajouter : ");

int nombre = [Link]();

if (nbChambres >= [Link]) {

[Link](" Tableau plein, impossible d'ajouter de nouvelles

chambres !");

return;

for (int i = 0; i < nombre && nbChambres < [Link]; i++) {

 chambres[nbChambres++] = saisirChambre();

sauvegarderChambres();

// Afficher les chambres d'une catégorie donnée

public void afficherChambresParCategorie(int categorie) {

[Link]("Chambres de la catégorie " + categorie + " :");

boolean found = false;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getCategorie() == categorie) {

[Link](chambres[i]);

found = true;

if (!found) [Link]("Aucune chambre trouvée pour cette

catégorie.");

// Trier les chambres par capacité

public void trierChambresParCapacite() {

[Link](chambres, 0, nbChambres,
[Link](Chambre::getCapacite));

[Link]("\n Chambres triées par capacité !");

sauvegarderChambres();

// Charger les chambres depuis le fichier

 public void chargerChambres() {

try (BufferedReader reader = new BufferedReader(new

FileReader("[Link]"))) {

String ligne;

nbChambres = 0; // Reset the number of rooms

while ((ligne = [Link]()) != null) {

// Clean up the string if it starts with "Chambre{" and ends with "}"

ligne = [Link]("Chambre{", "").replace("}", "");

// Split the line into attributes using comma as a delimiter

String[] parts = [Link](", ");

// Ensure the correct number of parts (5 attributes expected)

if ([Link] == 5) {

int numero = [Link](parts[0].split("=")[1]); // Room number

int categorie = [Link](parts[1].split("=")[1]); // Category

double prix = [Link](parts[2].split("=")[1]); // Price

int capacite = [Link](parts[3].split("=")[1]); // Capacity

char etat = parts[4].split("=")[1].charAt(0); // Room state

(assuming single character)

// Dynamically grow the array or use a List instead of fixed-size array

if (nbChambres < [Link]) {

chambres[nbChambres++] = new Chambre(numero, categorie, prix,

capacite, etat);

} else {

[Link]("Limite du nombre de chambres atteinte.");

}
 } else {

[Link]("Ligne mal formatée : " + ligne);

} catch (FileNotFoundException e) {

[Link]("Fichier non trouvé, création d'un nouveau fichier...");

} catch (IOException e) {

[Link]("Erreur de lecture du fichier !");

// Sauvegarder les chambres dans le fichier

public void sauvegarderChambres() {

try (BufferedWriter writer = new BufferedWriter(new FileWriter("[Link]"))) {

for (int i = 0; i < nbChambres; i++) {

[Link](chambres[i].toString());

[Link]();

[Link](" Données enregistrées !");

} catch (IOException e) {

[Link]("Erreur lors de l'écriture dans le fichier !");

// Ajouter une chambre

public void ajouterChambre() {

 if (nbChambres >= [Link]) {

[Link](" Tableau plein, impossible d'ajouter une nouvelle

chambre !");

return;

Chambre nouvelleChambre = saisirChambre();

// Vérifier si le numéro de chambre existe déjà

boolean numeroExiste = false;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getNumero() == [Link]()) {

numeroExiste = true;

break;

if (numeroExiste) {

[Link](" Le numéro de chambre existe déjà !");

} else {

chambres[nbChambres++] = nouvelleChambre;

sauvegarderChambres();

[Link](" Chambre ajoutée !");

// Supprimer une chambre

public void supprimerChambre() {

 Scanner clavier=new Scanner([Link]);

[Link]("Entrez le numéro de la chambre à supprimer : ");

int numero = [Link]();

int index = -1;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getNumero() == numero) {

index = i;

break;

if (index == -1) {

[Link](" Chambre introuvable !");

return;

// Décalage des chambres

[Link](chambres, index + 1, chambres, index, nbChambres -

index - 1);

chambres[--nbChambres] = null;

sauvegarderChambres();

[Link](" Chambre supprimée !");

// Modifier une chambre

public void modifierChambre() {

Scanner clavier = new Scanner([Link]);

[Link]("Entrez le numéro de la chambre à modifier : ");

int numero = [Link]();

// Rechercher la chambre par son numéro

int index = -1;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getNumero() == numero) {

index = i;

break;

if (index == -1) {

[Link](" Chambre introuvable !");

return;

// Afficher les détails de la chambre

[Link]("Chambre trouvée : " + chambres[index]);

// Menu de modification

int choix;

do {

[Link]("\n1 : Modifier le numéro");

[Link]("2 : Modifier la catégorie");

[Link]("3 : Modifier la capacité");

[Link]("4 : Modifier le prix");

[Link]("5 : Modifier l'état");

[Link]("6 : Quitter la modification");

[Link]("Votre choix : ");

choix = [Link]();

switch (choix) {

case 1:

[Link]("Entrez le nouveau numéro : ");

int nouveauNumero = [Link]();

// Vérifier si le nouveau numéro existe déjà

boolean numeroExiste = false;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getNumero() == nouveauNumero) {

numeroExiste = true;

break;

if (numeroExiste) {

[Link](" Le numéro de chambre existe déjà !");

} else {

chambres[index].setNumero(nouveauNumero);

[Link](" Numéro modifié !");

break;

case 2:

[Link]("Entrez la nouvelle catégorie : ");

int nouvelleCategorie = [Link]();

chambres[index].setCategorie(nouvelleCategorie);

[Link](" Catégorie modifiée !");

break;

case 3:
 [Link]("Entrez la nouvelle capacité (entre 1 et 4) : ");

int nouvelleCapacite = [Link]();

if (nouvelleCapacite >= 1 && nouvelleCapacite <= 4) {

chambres[index].setCapacite(nouvelleCapacite);

[Link](" Capacité modifiée !");

} else {

[Link](" Capacité invalide !");

break;

case 4:

[Link]("Entrez le nouveau prix : ");

double nouveauPrix = [Link]();

if (nouveauPrix > 0) {

chambres[index].setPrix(nouveauPrix);

[Link](" Prix modifié !");

} else {

[Link](" Prix invalide !");

break;

case 5:

[Link]("Entrez le nouvel état (L pour Libre, O pour Occupée) :

");

char nouvelEtat = [Link]().charAt(0);

if (nouvelEtat == 'L' || nouvelEtat == 'O') {

chambres[index].setEtat(nouvelEtat);

[Link](" État modifié !");

} else {

[Link](" État invalide !");

 }

break;

case 6:

[Link](" Modification terminée.");

break;

default:

[Link](" Choix invalide !");

break;

} while (choix != 6);

sauvegarderChambres();

// Afficher toutes les chambres

public void afficherChambres() {

if (nbChambres == 0) {

[Link]("Aucune chambre enregistrée.");

return;

[Link]("Liste des chambres :");

for (int i = 0; i < nbChambres; i++) {

[Link](chambres[i]);

public void copierChambresCategorie(int categorie, String fichierDestination) {

try (BufferedWriter writer = new BufferedWriter(new

FileWriter(fichierDestination))) {
 boolean found = false;

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getCategorie() == categorie) {

[Link](chambres[i].toString());

[Link]();

found = true;

if (found) {

[Link](" Chambres de la catégorie " + categorie + "

copiées dans " + fichierDestination);

} else {

[Link](" Aucune chambre trouvée pour cette catégorie.");

} catch (IOException e) {

[Link](" Erreur lors de la copie des chambres : " +

[Link]());

public Vector<Chambre> chambresLibres() {

Vector<Chambre> chambresLibres = new Vector<>();

for (int i = 0; i < nbChambres; i++) {

if (chambres[i].getEtat() == 'L') { // 'L' pour Libre

[Link](chambres[i]);

return chambresLibres;

}
 public void calculerRecettes() {

double recetteMax = 0;

double recetteReelle = 0;

for (int i = 0; i < nbChambres; i++) {

recetteMax += chambres[i].getPrix();

if (chambres[i].getEtat() == 'O') { // 'O' pour Occupée

recetteReelle += chambres[i].getPrix();

[Link](" Recette maximale journalière : " + recetteMax + "

DH");

[Link](" Recette réelle du jour : " + recetteReelle + " DH");

public static void main(String[] args) {

// TODO Auto-generated method stub

package ensemble;

import [Link].*;

import [Link];
public class TestHotel {

public static void main(String[] args) {

Scanner clavier = new Scanner([Link]);

Hotel hotel = new Hotel(10); // Taille de l'hôtel (10 chambres pour cet exemple)

[Link](); // Charger les chambres depuis le fichier

while (true) {

try {

// Afficher le menu

[Link]("\n==== Menu Hotel ====");

[Link]("1. Ajouter une chambre");

[Link]("2. Supprimer une chambre");

[Link]("3. Modifier une chambre");

[Link]("4. Afficher toutes les chambres");

[Link]("5. Afficher les chambres par catégorie");

[Link]("6. Trier les chambres par capacité");

[Link]("7. Copier les chambres par catégorie");

[Link]("8. Afficher les chambres libres");

[Link]("9. Calculer les recettes");

[Link]("10. Quitter");

[Link]("Choisissez une option : ");

int choix = [Link]();

switch (choix) {

case 1:

[Link]();

break;

case 2:

[Link]();
 break;

case 3:

[Link]();

break;

case 4:

[Link]();

break;

case 5:

[Link]("Entrez la catégorie de chambres à afficher : ");

int categorie = [Link]();

[Link](categorie);

break;

case 6:

[Link]();

break;

case 7:

[Link]("Entrez la catégorie de chambres à copier : ");

int categorieCopier = [Link]();

[Link]("Entrez le fichier de destination : ");

String fichierDestination ="categorie_" + categorieCopier + ".dat";

[Link](categorieCopier, fichierDestination);

break;

case 8:

Vector<Chambre> chambresLibres = [Link]();

if ([Link]()) {

[Link]("Aucune chambre libre.");

} else {

[Link]("Chambres libres :");

 for (Chambre ch : chambresLibres) {

[Link](ch);

break;

case 9:

[Link]();

break;

case 10:

[Link]("Merci d'avoir utilisé le système. Au revoir !");

[Link]();

return; // Quitter le programme

default:

[Link]("Choix invalide. Veuillez réessayer.");

break;

} catch (Exception e) {

[Link]("Erreur : " + [Link]());

[Link](); // Consommer la ligne restante pour éviter des boucles

infinies