package Tp1;

import static java.lang.System.*;

public class Somme {

public static void main(String[] args) {

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

if (args.length == 0) {

System.out.println("Veuillez fournir des mots en argument.");

return;

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

for (int i = 0; i < args.length; i++) {

try {

// Essayer de convertir l'argument en entier

int a = Integer.parseInt(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

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

// Afficher le résultat de la somme

System.out.println("La somme est : " + som);

 }

package Tp1;

public class Morse {

public static void main(String[] args) {

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

if (args.length == 0) {

System.out.println("Veuillez fournir des mots en argument.");

return;

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

for (int i = 0; i < args.length; i++) {

System.out.print(args[i]+" Stop. ");

package bibliotheque;

import java.io.Serializable;

import java.util.Vector;

public class Bibliotheque implements Serializable {

private Vector<Livre> livres;

private int capaciteMax;

// Constructeur

public Bibliotheque(int capaciteMax) {

this.capaciteMax = capaciteMax;

this.livres = new Vector<>(capaciteMax);

// Ajouter un livre

public boolean ajouteLivre(Livre livre) {

if (livres.size() < capaciteMax) {

livres.add(livre);

return true;

return false;

// Récupérer le nombre de livres

public int size() {

return livres.size();

// 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 : livre.getAuteurs()) {

if (a.toLowerCase().startsWith(auteur.toLowerCase())) {

livresTrouves.add(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();

sb.append("Liste des livres :\n");

for (Livre livre : livres) {

sb.append(livre.toString()).append("\n\n");

return sb.toString();

package Tp1;
import java.io.Serializable;

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){

this.titre=titre;

this.auteurs=auteurs;

this.ISBN=ISBN;

this.prix=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) {this.titre=titre;}

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

public void setISBN(String ISBN) {this.ISBN=ISBN;}

public void setPrix(double prix) {this.prix=prix;}

public String toString() {

StringBuffer details=new StringBuffer();

details.append("Titre: ").append(titre).append("\n");

details.append("ISBN: ").append(ISBN).append("\n");

details.append("Prix: ").append(prix).append("\n");
 details.append("Auteurs: \n");

for(String auteur:auteurs) {

details.append(" -").append(auteur).append("\n");

return details.toString();

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

public boolean auteurCommencePar(String auteur) {

for(String a : auteurs ) {

if(a.toLowerCase().startsWith(auteur.toLowerCase())) {

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 java.util.Scanner;

import java.io.*;

import java.util.Vector;

public class TestBibliotheque {

public static void main(String[] args) {

Scanner clavier = new Scanner(System.in);

Bibliotheque B = null;

try {

System.out.print("Entrez la capacité maximale de la bibliothèque : ");

int capaciteMax = clavier.nextInt();

clavier.nextLine(); // Consommer le retour à la ligne

B = new Bibliotheque(capaciteMax);

} catch (Exception e) {

System.out.println("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) ois.readObject();

} catch (FileNotFoundException e) {

System.out.println(" Aucun fichier précédent trouvé, démarrage d'une nouvelle

bibliothèque.");

} catch (IOException | ClassNotFoundException e) {

System.out.println(" Erreur lors du chargement du fichier : " + e.getMessage());

while (true) {

System.out.println("=== Menu Bibliothèque ===");

System.out.println("1. Ajouter un Livre");

System.out.println("2. Afficher la Bibliothèque");

System.out.println("3. Calculer la taille et capacité de la Bibliothèque");

System.out.println("4. Rechercher un livre par auteur");

System.out.println("5. Quitter");

System.out.print("Choisissez une option : ");

int choix;

try {

choix = clavier.nextInt();

clavier.nextLine();

} catch (Exception e) {

System.out.println(" Veuillez entrer un nombre valide.");

clavier.nextLine();

continue;

}
 switch (choix) {

case 1:

try {

System.out.println("Entrez le titre : ");

String titre = clavier.nextLine();

System.out.println("Combien d'auteurs : ");

int nbAuteurs = clavier.nextInt();

clavier.nextLine();

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++) {

System.out.print("Nom de l'auteur " + (i + 1) + " : ");

auteurs[i] = clavier.nextLine();

System.out.println("Entrez ISBN : ");

String ISBN = clavier.nextLine();

System.out.println("Entrez le prix : ");

double prix = clavier.nextDouble();

clavier.nextLine();

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

négatif.");

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

 if (B.ajouteLivre(livre)) {

System.out.println(" Livre ajouté avec succès !");

} else {

System.out.println(" La bibliothèque est pleine !");

} catch (Exception e) {

System.out.println(" Erreur lors de l'ajout du livre : " + e.getMessage());

clavier.nextLine();

break;

case 2:

if (B.size() == 0) {

System.out.println(" La bibliothèque est vide !");

} else {

System.out.println("\n Contenu de la bibliothèque :");

System.out.println(B);

break;

case 3:

System.out.println(" Capacité de la bibliothèque : " + B.capacite());

System.out.println(" Nombre de livres dans la bibliothèque : " + B.size());

break;

case 4:

System.out.println("Donner le nom ou le début du nom de l'auteur :");

String nom = clavier.nextLine();

 Vector<Livre> result = B.cherche(nom);

if (result.isEmpty()) {

System.out.println("Aucun livre trouvé pour cet auteur.");

} else {

System.out.println("\n Livres trouvés :");

for (Livre l : result) {

System.out.println(l);

break;

case 5:

try (ObjectOutputStream oos = new ObjectOutputStream(new

FileOutputStream("fichierObjet"))) {

oos.writeObject(B);

oos.flush();

} catch (IOException e) {

System.out.println("Erreur lors de l'écriture du fichier : " + e.getMessage());

System.out.println("au revoir !");

clavier.close();

return;

default:

System.out.println(" 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);

System.out.println(livre);

package hh;

import java.util.StringTokenizer;

// 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 = Double.toString(x);

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

String intPart = tokenizer.nextToken();

String decimalPart = tokenizer.hasMoreTokens() ? tokenizer.nextToken() : ""; // Évite

l'erreur

if (nbDecimales == 0 || decimalPart.isEmpty()) {

return intPart;

if (decimalPart.length() > nbDecimales) {

decimalPart = decimalPart.substring(0, nbDecimales); // Tronquer

return intPart + "." + decimalPart;

public static void main(String[] args) {

try {

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

if (args.length == 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 (args.length % 2 != 0) {

throw new NombreArgumentsImpairException();

}
 for (int i = 0; i < args.length; i += 2) {

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

double x;

try {

x = Double.parseDouble(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 = Integer.parseInt(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

System.out.print(tronque(x, nbDecimales) + "\t");

System.out.println(); // Nouvelle ligne après affichage

} catch (Exception e) {

System.err.println("Erreur : " + e.getMessage());

}
 }

package hh;

import java.util.Scanner;

public class EssaiTri {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

TriSimple tri = new TriSimple();

while (true) {

System.out.println("\nOptions :");

System.out.println(" a - Ajouter une valeur");

System.out.println(" s - Supprimer une valeur");

System.out.println(" q - Quitter");

System.out.print("Entrez votre commande : ");

String input = scanner.nextLine().trim();

if (input.isEmpty()) {

System.out.println("Erreur : Veuillez entrer une commande valide.");

continue;

char commande = input.charAt(0);

if (commande == 'q') {
 System.out.println("Programme terminé.");

break;

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

System.out.print("Entrez la valeur entière : ");

String valeurStr = scanner.nextLine().trim();

if (valeurStr.isEmpty()) {

System.out.println("Erreur : La valeur ne peut pas être vide.");

continue;

try {

int valeur = Integer.parseInt(valeurStr);

if (commande == 'a') {

tri.inserer(valeur);

System.out.println("Tableau après insertion : " + tri);

System.out.println("Taille du tableau : " + tri.getTaille()); // Affichage de la

taille

} else {

try {

tri.supprimer(valeur);

System.out.println("Tableau après suppression : " + tri);

System.out.println("Taille du tableau : " + tri.getTaille()); // Affichage de la

taille

} catch (EmptyEntiersException | EntierNotExistException e) {

System.out.println(e);

}
 } catch (NumberFormatException e) {

System.out.println("Erreur : Veuillez entrer un nombre entier valide.");

} else {

System.out.println("Erreur : Commande inconnue. Veuillez entrer 'a', 's' ou 'q'.");

scanner.close();

package hh;

import java.util.Arrays;

class TriSimple {

private int[] tableau;

private int taille;

private int capacite;

private int increment;

public TriSimple() {

this.capacite = 3; // Taille par défaut

this.increment = 6;

this.tableau = new int[capacite];

this.taille = 0;

// Méthode pour obtenir la taille du tableau

public int getTaille() {

return taille;

public TriSimple(int capaciteInitiale, int increment) {

this.capacite = capaciteInitiale;

this.increment = increment;

this.tableau = new int[capacite];

this.taille = 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 = Arrays.copyOf(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 = Arrays.copyOf(tableau, capacite);

@Override

public String toString() {

return Arrays.toString(Arrays.copyOf(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 = "chambres.dat";

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(System.in);

int capacite;

double prix;

System.out.print("Entrez le numéro de la chambre : ");

int numero = clavier.nextInt();

System.out.print("Entrez la catégorie : ");

int categorie = clavier.nextInt();

do {

System.out.print("Entrez la capacité entre 1 et 4: ");

capacite = clavier.nextInt();

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

do {

System.out.print("Entrez le prix superieur a 0 : ");

prix = clavier.nextDouble();
 }while(prix<=0);

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

public void saisirTableau() {

Scanner clavier = new Scanner(System.in);

System.out.println("Nombre de chambres à ajouter : ");

int nombre = clavier.nextInt();

if (nbChambres >= chambres.length) {

System.out.println(" Tableau plein, impossible d'ajouter de nouvelles

chambres !");

return;

for (int i = 0; i < nombre && nbChambres < chambres.length; i++) {

try {

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

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

} catch (Exception e) {

System.out.println(" Erreur lors de l'ajout : " + e.getMessage());

public void afficherChambresParCategorie(int categorie) {

 System.out.println("Chambres de la catégorie " + categorie + " :");

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

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

System.out.println(chambres);

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

public void trierChambresParCapacite(Chambre[] chambres) {

Arrays.sort(chambres, (c1, c2) -> Integer.compare(c1.getCapacite(),

c2.getCapacite()));

System.out.println("\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();

System.out.println("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 = reader.readLine()) != null && nbChambres < chambres.length ) {

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

String[] parts = ligne.split(",");

int numero = Integer.parseInt(parts[0]);

int categorie = Integer.parseInt(parts[1]);

double prix = Double.parseDouble(parts[2]);

int capacite = Integer.parseInt(parts[3]);

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

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

etat);

} catch (FileNotFoundException e) {

System.out.println("Fichier non trouvé, création d'un nouveau fichier...");

 } catch (IOException e) {

System.out.println("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++) {

writer.write(chambres[i].toString());

writer.newLine();

System.out.println("Données enregistrées !");

} catch (IOException e) {

System.out.println("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) {

writer.write(ch.toString());
 writer.newLine();

} catch (IOException e) {

e.printStackTrace();

*/

/* public void ajouterChambre() {

if (nbChambres < chambres.length) {

try {

Chambre nouvelleChambre = saisirChambre(); // Saisie

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

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

sauvegarderChambres(); // Sauvegarde

System.out.println(" Chambre ajoutée !");

} catch (Exception e) {

System.out.println(" Erreur : " + e.getMessage());

} else {

System.out.println(" Tableau plein, impossible d'ajouter une nouvelle chambre

!");

// Supprimer une chambre par numéro

public void supprimerChambre() {

Scanner clavier = new Scanner(System.in);

System.out.print("Entrez le numéro de la chambre à supprimer : ");

 int numero = clavier.nextInt();

int index = -1;

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

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

index = i;

break;

if (index == -1) {

System.out.println("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();

System.out.println("Chambre supprimée !");

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

public void modifierChambre() {

Scanner clavier = new Scanner(System.in);

System.out.print("Entrez le numéro de la chambre à modifier : ");

int numero = clavier.nextInt();

int index = -1;

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

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

index = i;

break;

if (index == -1) {

System.out.println("Chambre introuvable !");

return;

System.out.print("Entrez le nouveau prix : ");

double nouveauPrix = clavier.nextDouble();

System.out.print("Entrez la nouvelle capacité (entre 1 et 4) : ");

int nouvelleCapacite = clavier.nextInt();

chambres[index].prix = nouveauPrix;

chambres[index].capacite = nouvelleCapacite;

sauvegarderChambres();

System.out.println("Chambre modifiée !");

// Afficher toutes les chambres

public void afficherChambres() {

if (nbChambres == 0) {

System.out.println("Aucune chambre enregistrée.");

return;

System.out.println("Liste des chambres :");

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

System.out.println(chambres[i]);
 }

*/

package ensemble;

import java.util.*;

import java.io.*;

import java.io.File;

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(System.in);

System.out.print("Entrez le numéro de la chambre : ");

int numero = clavier.nextInt();

System.out.print("Entrez la catégorie : ");

int categorie = clavier.nextInt();

 do {

System.out.print("Entrez la capacité (entre 1 et 4) : ");

capacite = clavier.nextInt();

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

do {

System.out.print("Entrez le prix (supérieur à 0) : ");

prix = clavier.nextDouble();

} while (prix <= 0);

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

// Ajouter plusieurs chambres

public void saisirTableau() {

Scanner clavier=new Scanner(System.in);

System.out.print("Nombre de chambres à ajouter : ");

int nombre = clavier.nextInt();

if (nbChambres >= chambres.length) {

System.out.println(" Tableau plein, impossible d'ajouter de nouvelles

chambres !");

return;

for (int i = 0; i < nombre && nbChambres < chambres.length; i++) {

 chambres[nbChambres++] = saisirChambre();

sauvegarderChambres();

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

public void afficherChambresParCategorie(int categorie) {

System.out.println("Chambres de la catégorie " + categorie + " :");

boolean found = false;

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

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

System.out.println(chambres[i]);

found = true;

if (!found) System.out.println("Aucune chambre trouvée pour cette

catégorie.");

// Trier les chambres par capacité

public void trierChambresParCapacite() {

Arrays.sort(chambres, 0, nbChambres,
Comparator.comparingInt(Chambre::getCapacite));

System.out.println("\n Chambres triées par capacité !");

sauvegarderChambres();

// Charger les chambres depuis le fichier

 public void chargerChambres() {

try (BufferedReader reader = new BufferedReader(new

FileReader("hotel.txt"))) {

String ligne;

nbChambres = 0; // Reset the number of rooms

while ((ligne = reader.readLine()) != null) {

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

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

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

String[] parts = ligne.split(", ");

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

if (parts.length == 5) {

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

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

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

int capacite = Integer.parseInt(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 < chambres.length) {

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

capacite, etat);

} else {

System.out.println("Limite du nombre de chambres atteinte.");

}
 } else {

System.out.println("Ligne mal formatée : " + ligne);

} catch (FileNotFoundException e) {

System.out.println("Fichier non trouvé, création d'un nouveau fichier...");

} catch (IOException e) {

System.out.println("Erreur de lecture du fichier !");

// Sauvegarder les chambres dans le fichier

public void sauvegarderChambres() {

try (BufferedWriter writer = new BufferedWriter(new FileWriter("hotel.txt"))) {

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

writer.write(chambres[i].toString());

writer.newLine();

System.out.println(" Données enregistrées !");

} catch (IOException e) {

System.out.println("Erreur lors de l'écriture dans le fichier !");

// Ajouter une chambre

public void ajouterChambre() {

 if (nbChambres >= chambres.length) {

System.out.println(" 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() == nouvelleChambre.getNumero()) {

numeroExiste = true;

break;

if (numeroExiste) {

System.out.println(" Le numéro de chambre existe déjà !");

} else {

chambres[nbChambres++] = nouvelleChambre;

sauvegarderChambres();

System.out.println(" Chambre ajoutée !");

// Supprimer une chambre

public void supprimerChambre() {

 Scanner clavier=new Scanner(System.in);

System.out.print("Entrez le numéro de la chambre à supprimer : ");

int numero = clavier.nextInt();

int index = -1;

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

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

index = i;

break;

if (index == -1) {

System.out.println(" Chambre introuvable !");

return;

// Décalage des chambres

System.arraycopy(chambres, index + 1, chambres, index, nbChambres -

index - 1);

chambres[--nbChambres] = null;

sauvegarderChambres();

System.out.println(" Chambre supprimée !");

// Modifier une chambre

public void modifierChambre() {

Scanner clavier = new Scanner(System.in);

System.out.print("Entrez le numéro de la chambre à modifier : ");

int numero = clavier.nextInt();

// 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) {

System.out.println(" Chambre introuvable !");

return;

// Afficher les détails de la chambre

System.out.println("Chambre trouvée : " + chambres[index]);

// Menu de modification

int choix;

do {

System.out.println("\n1 : Modifier le numéro");

System.out.println("2 : Modifier la catégorie");

System.out.println("3 : Modifier la capacité");

System.out.println("4 : Modifier le prix");

System.out.println("5 : Modifier l'état");

System.out.println("6 : Quitter la modification");

System.out.print("Votre choix : ");

choix = clavier.nextInt();

switch (choix) {

case 1:

System.out.print("Entrez le nouveau numéro : ");

int nouveauNumero = clavier.nextInt();

// 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) {

System.out.println(" Le numéro de chambre existe déjà !");

} else {

chambres[index].setNumero(nouveauNumero);

System.out.println(" Numéro modifié !");

break;

case 2:

System.out.print("Entrez la nouvelle catégorie : ");

int nouvelleCategorie = clavier.nextInt();

chambres[index].setCategorie(nouvelleCategorie);

System.out.println(" Catégorie modifiée !");

break;

case 3:
 System.out.print("Entrez la nouvelle capacité (entre 1 et 4) : ");

int nouvelleCapacite = clavier.nextInt();

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

chambres[index].setCapacite(nouvelleCapacite);

System.out.println(" Capacité modifiée !");

} else {

System.out.println(" Capacité invalide !");

break;

case 4:

System.out.print("Entrez le nouveau prix : ");

double nouveauPrix = clavier.nextDouble();

if (nouveauPrix > 0) {

chambres[index].setPrix(nouveauPrix);

System.out.println(" Prix modifié !");

} else {

System.out.println(" Prix invalide !");

break;

case 5:

System.out.print("Entrez le nouvel état (L pour Libre, O pour Occupée) :

");

char nouvelEtat = clavier.next().charAt(0);

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

chambres[index].setEtat(nouvelEtat);

System.out.println(" État modifié !");

} else {

System.out.println(" État invalide !");

 }

break;

case 6:

System.out.println(" Modification terminée.");

break;

default:

System.out.println(" Choix invalide !");

break;

} while (choix != 6);

sauvegarderChambres();

// Afficher toutes les chambres

public void afficherChambres() {

if (nbChambres == 0) {

System.out.println("Aucune chambre enregistrée.");

return;

System.out.println("Liste des chambres :");

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

System.out.println(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) {

writer.write(chambres[i].toString());

writer.newLine();

found = true;

if (found) {

System.out.println(" Chambres de la catégorie " + categorie + "

copiées dans " + fichierDestination);

} else {

System.out.println(" Aucune chambre trouvée pour cette catégorie.");

} catch (IOException e) {

System.out.println(" Erreur lors de la copie des chambres : " +

e.getMessage());

public Vector<Chambre> chambresLibres() {

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

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

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

chambresLibres.add(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();

System.out.println(" Recette maximale journalière : " + recetteMax + "

DH");

System.out.println(" Recette réelle du jour : " + recetteReelle + " DH");

public static void main(String[] args) {

// TODO Auto-generated method stub

package ensemble;

import java.util.*;

import java.io.File;
public class TestHotel {

public static void main(String[] args) {

Scanner clavier = new Scanner(System.in);

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

hotel.chargerChambres(); // Charger les chambres depuis le fichier

while (true) {

try {

// Afficher le menu

System.out.println("\n==== Menu Hotel ====");

System.out.println("1. Ajouter une chambre");

System.out.println("2. Supprimer une chambre");

System.out.println("3. Modifier une chambre");

System.out.println("4. Afficher toutes les chambres");

System.out.println("5. Afficher les chambres par catégorie");

System.out.println("6. Trier les chambres par capacité");

System.out.println("7. Copier les chambres par catégorie");

System.out.println("8. Afficher les chambres libres");

System.out.println("9. Calculer les recettes");

System.out.println("10. Quitter");

System.out.print("Choisissez une option : ");

int choix = clavier.nextInt();

switch (choix) {

case 1:

hotel.ajouterChambre();

break;

case 2:

hotel.supprimerChambre();
 break;

case 3:

hotel.modifierChambre();

break;

case 4:

hotel.afficherChambres();

break;

case 5:

System.out.print("Entrez la catégorie de chambres à afficher : ");

int categorie = clavier.nextInt();

hotel.afficherChambresParCategorie(categorie);

break;

case 6:

hotel.trierChambresParCapacite();

break;

case 7:

System.out.print("Entrez la catégorie de chambres à copier : ");

int categorieCopier = clavier.nextInt();

System.out.print("Entrez le fichier de destination : ");

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

hotel.copierChambresCategorie(categorieCopier, fichierDestination);

break;

case 8:

Vector<Chambre> chambresLibres = hotel.chambresLibres();

if (chambresLibres.isEmpty()) {

System.out.println("Aucune chambre libre.");

} else {

System.out.println("Chambres libres :");

 for (Chambre ch : chambresLibres) {

System.out.println(ch);

break;

case 9:

hotel.calculerRecettes();

break;

case 10:

System.out.println("Merci d'avoir utilisé le système. Au revoir !");

clavier.close();

return; // Quitter le programme

default:

System.out.println("Choix invalide. Veuillez réessayer.");

break;

} catch (Exception e) {

System.out.println("Erreur : " + e.getMessage());

clavier.nextLine(); // Consommer la ligne restante pour éviter des boucles

infinies