Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    septembre 2017
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2017
    Messages : 44
    Points : 27
    Points
    27

    Par défaut éviter doublons avec les collections

    Bonjour à tous,

    Je bloque sur deux notions de collection, les Hashset et Treeset.
    Je rentre les employés d'une société, et je voudrais que une personne n'ai qu'une seul fonction (ex: Dupont est directeur, donc Dupont ne pourra pas être ouvrier), donc je dois éviter les doublons, c'est le pourquoi de l'emploi des Hashset ou Treeset.
    Je sais que pour le Hashset, je dois surchargé les méthodes equals() et hashcode() et pour le Treeset, je dois surchargé le méthode compareTo().
    Donc à priori ici, je dois comparer le nom et le fonction des personne que je rentre, ce que je crois que je fais dans la méthode equals().

    Je vous mets les deux classes qui sont concernées par ce hashset.
    Classe Personnes.java dans laquelle, j'ai mes attributs, constructeurs et accesseurs, mes méthodes hashCode() (qui me met une erreur Override) et equals().
    Classe IntroDonneesSaveBin.java dans laquelle j'encode mes employés dans un tableau, après sérialisation, ils sont mis dans un fichier binaire (peu intéressant pour ce qui me concerne ici), par contre je parcours mon tableau, je crée mon hashset et je veux introduire mes objets Personnes dans mon hashset à partir de mon tableau, tout en comparant le nom et la fonction et c'est là que ça coince, il introduit tout, même quand j'ai des doublons.

    Personnes.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
     
    import java.io.Serializable;
     
    /**
     *
     * @author Fred Nico
     */
    public abstract class Personnes implements IntPersonne, Serializable {
     
        // ***********************   Attributs  ***************************************
        /**
         * Numero national de la personne
         */
        public String numeroNational;
        /**
         * Prénom de la personne
         */
        public String prenom;
        /**
         * Nom de la personne
         */
        public String nom;
        /**
         * Fonction de la personne
         */
        public String fonction;
     
        // ***********************  Constructeurs ***************************************
        /**
         * Constructeur avec paramètres
         *
         * @param numeroNational
         * @param prenom
         * @param nom
         * @param fonction
         */
        public Personnes(String numeroNational, String prenom, String nom, String fonction) {
            this.numeroNational = numeroNational;
            this.prenom = prenom;
            this.nom = nom;
            this.fonction = fonction;
        }
     
        /**
         * Constructeur par défaut
         */
        public Personnes() {
        }
     
        // *********************** Getters and setters *********************************
        /**
         * Getters and Setters commun à toutes les classes
         *
         * @return
         */
        public String getNumeroNational() {
            return numeroNational;
        }
     
        public void setNumeroNational(String numeroNational) {
            this.numeroNational = numeroNational;
        }
     
        public String getPrenom() {
            return prenom;
        }
     
        public void setPrenom(String prenom) {
            this.prenom = prenom;
        }
     
        public String getNom() {
            return nom;
        }
     
        public void setNom(String nom) {
            this.nom = nom;
        }
     
        public String getFonction() {
            return fonction;
        }
     
        public void setFonction(String fonction) {
            this.fonction = fonction;
        }
     
    //******************************* Méthodes ******************************************
        /**
         * Méthodes
         */
        @Override
        public abstract void joue();
     
        @Override
        public abstract void manger();
     
        //implement code
        @Override
        public String hashCode() {
            return nom + fonction;
        }
        //implément code
     
        public boolean equals(Object pp) {
            Personnes p = (Personnes) pp;
            return ((this.nom == p.nom) & (this.fonction == p.fonction));
        }
    }

    IntroDonneesSaveBin.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
     
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.logging.Level;
    import java.util.logging.Logger;
     
    /**
     *
     * @author Fred Nico
     */
    public class IntroDonneesSaveBin implements Prog {
     
        /**
         * Tableau d'objets Personnes
         */
        public Personnes[] tabPersonnel = null;
     
        /**
         * Methode qui remplis mon tableau et les attributs de chaques employés
         *
         */
        @Override
        public void execute(MenuDepart programme) {
            //Création d'une haspMap qui définira la fonction d'un objet
            HashMap<Integer, String> mesFonctions = new HashMap<>();
            // Insertion des valeurs dans la liste
            mesFonctions.put(1, "Directeur");
            mesFonctions.put(2, "Comptable");
            mesFonctions.put(3, "Secretaire");
            mesFonctions.put(4, "Ouvrier");
     
            ObjectOutputStream sortie = null;
            //dimensionnement de mon tableau de personnel avec ma méthode taille tableau
            this.tabPersonnel = new Personnes[tailleTableau()];
            for (int i = 0; i < tabPersonnel.length; i++) {
     
                int choix = menuFonction();//Appel de ma méthode MenuFonction     
     
                System.out.println("\n");
                //Switch pour remplir les attributs d'une classe en fonction du choix fait avant           
                switch (choix) {
                    case 0:
                        System.exit(0);
                        break;
                    case 1:
                        Personnes directeur = new Directeur();
                        System.out.println("Entrer les informations demandée sur le directeur:  ");
                        System.out.print("Numéro National: ");
                        directeur.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        directeur.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        directeur.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        directeur.setFonction(mesFonctions.get(choix));   //Utilisation de la clé du HashMap pour définir la fonction
                        this.tabPersonnel[i] = directeur;
                        System.out.println("\n");
                        break;
                    case 2:
                        Personnes comptable = new Comptable();
                        System.out.println("Entrer les informations demandée sur le comptable:  ");
                        System.out.print("Numéro National: ");
                        comptable.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        comptable.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        comptable.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        comptable.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        this.tabPersonnel[i] = comptable;
                        System.out.println("\n");
                        break;
                    case 3:
                        Personnes secretaire = new Secretaire();
                        System.out.println("Entrer les informations demandée sur la/le secretaire:  ");
                        System.out.print("Numéro National: ");
                        secretaire.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        secretaire.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        secretaire.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        secretaire.setFonction(mesFonctions.get(choix));  //Utilisation de la clé du HashMap pour définir la fonction
                        this.tabPersonnel[i] = secretaire;
                        System.out.println("\n");
                        break;
                    case 4:
                        Personnes ouvrier = new Ouvrier();
                        System.out.println("Entrer les informations demandée sur l'ouvrier:  ");
                        System.out.print("Numéro National: ");
                        ouvrier.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        ouvrier.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        ouvrier.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        ouvrier.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        this.tabPersonnel[i] = ouvrier;
                        System.out.println("\n");
                        break;
                    case 5:
                        programme.showMenuDépart();
                    default:
                        this.menuFonction();
                }
            }
            try {
                this.saveDataTab(this.tabPersonnel);//appel de la méthode de sauvegarde en fichier binaire
            } catch (IOException ex) {
                Logger.getLogger(IntroDonneesSaveBin.class.getName()).log(Level.SEVERE, null, ex);
            }
     
            // Création d'un hashSet d'objets Personnes
            HashSet<Personnes> employe = new HashSet<>();
     
            //Ajout et affichage des objets Personnes dans la liste (hashset)à partir du tableau
            for (Personnes perstab : tabPersonnel) {
                // Test de présence d'un doublon
                boolean ajoute = employe.add(perstab);
                if (ajoute) {
                    System.out.println(" a été ajouté.");
                } else {
                    System.out.println("est deja présent");
                }
                System.out.print("Contenu de la hashSet: ");
                affiche(employe);
            }
     
            this.endProg(programme);//appel de la méthode fin de programme
     
        }
     
        /**
         * Méthode qui utilise un itérateur pour parcourir et afficher ce qu'il y a dans mon hashset
         * @param empl 
         */
        public static void affiche(HashSet<Personnes> empl) {
     
            // Création d'un itérateur
            Iterator<Personnes> iter = empl.iterator();
            // Boucle d'affichage
            while (iter.hasNext()) {
                Personnes p = iter.next();
            }
            System.out.println();
        }
     
        /**
         * Fin du programme, retour au menu principale
         *
         * @param programme
         */
        @Override
        public void endProg(MenuDepart programme) {
            System.out.println("Appuyer sur une touche pour retourner au menu.");
            String str = Clavier.lireString();
            programme.showMenuDépart();
        }
     
        /**
         * Méthode pour sauvegarder en binaire les objets de mon tableau(flux de
         * sortie d'objet)
         *
         * @param tableau
         * @throws FileNotFoundException
         * @throws IOException
         */
        public void saveDataTab(Personnes[] tableau) throws FileNotFoundException, IOException {
            try (ObjectOutputStream sortie = new ObjectOutputStream(new FileOutputStream("fichier.dat"))) {
                for (Personnes tabPersonnel1 : tabPersonnel) {
                    sortie.writeObject(tabPersonnel1);
                }
            }
        }
     
        /**
         * Méthode pour choisir la fonction, quitter ou retour au menu principale
         *
         * @return
         */
        private int menuFonction() {
            System.out.println("Veuillez choisir un chiffre dans la liste ci-dessous: ");
            System.out.println("0  ==> Quitter");
            System.out.println("1  ==> Directeur");
            System.out.println("2  ==> Comptable");
            System.out.println("3  ==> Secretaire");
            System.out.println("4  ==> Ouvrier");
            System.out.println("5  ==> Retour au menu de départ");
            System.out.print("Votre choix: ");
            int choix;
            choix = (Clavier.lireInt());
            return choix;
        }
     
        /**
         * Méthode pour choisir le nombre d'employé et donc la taille de mon tableau
         *
         * @return
         */
        private int tailleTableau() {
            int taille;
            System.out.print("Entrer le nombre d'employé dans l'entreprise: ");
            taille = Clavier.lireInt();
            return taille;
        }
    }
    Voilà, si quelqu'un de plus expérimenté que moi pouvait m'éclairer...

  2. #2
    Membre éclairé Avatar de Cincinnatus
    Homme Profil pro
    Développeur Java
    Inscrit en
    mars 2007
    Messages
    289
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Service public

    Informations forums :
    Inscription : mars 2007
    Messages : 289
    Points : 817
    Points
    817

    Par défaut

    Citation Envoyé par Cisman Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
        @Override
        public String hashCode() {
            return nom + fonction;      
        }
    Sérieusement ? hashCode() devrait renvoyer un int.


    Citation Envoyé par Cisman Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
        public boolean equals(Object pp) {
            Personnes p = (Personnes) pp;
            return ((this.nom == p.nom) & (this.fonction == p.fonction));
        }
    }
    Le & est n'est pas un opérateur logique en Java. Utilise plutôt && pour le ET logique.

    Revoie les méthodes hashCode() et equals().

  3. #3
    Modérateur

    Profil pro
    Inscrit en
    septembre 2004
    Messages
    11 560
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : septembre 2004
    Messages : 11 560
    Points : 19 629
    Points
    19 629

    Par défaut

    Citation Envoyé par Cincinnatus Voir le message
    Le & est n'est pas un opérateur logique en Java. Utilise plutôt && pour le ET logique.
    Ben si, en fait. C'est le ET logique et pas paresseux.

    Celui qu'on a l'habitude d'utiliser, qui est && est un ET logique paresseux. C'est à dire qu'il évalue d'abord l'opérande de gauche, et si elle est fausse, il sait que celle de droite n'y changera rien, donc pas la peine de l'évaluer. On dit direct que c'est faux.

    L'opérateur & est aussi un ET logique, mais lui il évalue les deux opérandes, peu lui importe d'avoir détecté que la première des deux était fausse et donc que le résultat est déjà connu.

    Bien entendu, cela n'a d'intérêt que si évaluer les opérandes a des effets de bord que l'on tient à activer, comme mettre à jour quelque chose d'extérieur ou lancer une exception. En pratique je ne suis jamais tombé sur un cas où c'est une bonne idée.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    septembre 2017
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2017
    Messages : 44
    Points : 27
    Points
    27

    Par défaut

    Bonjour,
    Pour finir, j'ai modifier mon equals(), je ne test que sur le nom et ça fonctionne. Etant bien d'accord que normalement, je testerai sur une ID ou numéro national qui serait unique.
    Par contre, je répète dans mon switch case, 4 fois la même condition, et je n'arrive pas à en faire une méthode qui fonctionne, je cafouille dans les paramètres que je dois lui passé et ce qu'elle doit retourner.

    Personnes.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
     
    import java.io.Serializable;
     
    /**
     *
     * @author Fred
     */
    public abstract class Personnes implements IntPersonne, Serializable {
     
        // ***********************   Attributs  ***************************************
        /**
         * Numero national de la personne
         */
        public String numeroNational;
        /**
         * Prénom de la personne
         */
        public String prenom;
        /**
         * Nom de la personne
         */
        public String nom;
        /**
         * Fonction de la personne
         */
        public String fonction;
     
        // ***********************  Constructeurs ***************************************
        /**
         * Constructeur avec paramètres
         *
         * @param numeroNational
         * @param prenom
         * @param nom
         * @param fonction
         */
        public Personnes(String numeroNational, String prenom, String nom, String fonction) {
            this.numeroNational = numeroNational;
            this.prenom = prenom;
            this.nom = nom;
            this.fonction = fonction;
        }
     
        /**
         * Constructeur par défaut
         */
        public Personnes() {
        }
     
        // *********************** Getters and setters *********************************
        /**
         * Getters and Setters commun à toutes les classes
         * @return
         */
        public String getNumeroNational() {
            return numeroNational;
        }
     
        public void setNumeroNational(String numeroNational) {
            this.numeroNational = numeroNational;
        }
     
        public String getPrenom() {
            return prenom;
        }
     
        public void setPrenom(String prenom) {
            this.prenom = prenom;
        }
     
        public String getNom() {
            return nom;
        }
     
        public void setNom(String nom) {
            this.nom = nom;
        }
     
        public String getFonction() {
            return fonction;
        }
     
        public void setFonction(String fonction) {
            this.fonction = fonction;
        }
     
    //******************************* Méthodes ******************************************
        /**
         * Méthodes Overridé
         */
        @Override
        public abstract void joue();
     
        @Override
        public abstract void manger();
     
        /**
         * Méthode hashCode pour mon hashset
         * @return 
         */
        @Override
        public int hashCode() {
            return 10;
        }
        /**
         * Méthode equals pour mon hashset
         * @param obj
         * @return 
         */
        @Override
        public boolean equals(Object obj) {
           if (obj instanceof Personnes){
               return((Personnes)obj).getNom().equals(this.getNom());   
           }
           return false;
        }
    }

    IntroDonneesSaveBin
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
     
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.logging.Level;
    import java.util.logging.Logger;
     
    /**
     *
     * @author Fred
     */
    public class IntroDonneesSaveBin implements Prog {
     
        /**
         * Tableau de int qui servira pour boucler autant de fois qu'il y a
         * d'employé dans l'entreprise
         */
        public int[] tableau = null;
     
        /**
         * Methode qui remplis mon hashset et les attributs de chaques employés
         *
         */
        @Override
        public void execute(MenuDepart programme) {
            //Création d'une haspMap qui définira la fonction d'un objet
            HashMap<Integer, String> mesFonctions = new HashMap<>();
            // Insertion des valeurs dans la hashmap
            mesFonctions.put(1, "Directeur");
            mesFonctions.put(2, "Comptable");
            mesFonctions.put(3, "Secretaire");
            mesFonctions.put(4, "Ouvrier");
     
            // Création d'un hashSet d'objets Personnes
            HashSet<Personnes> hset = new HashSet<>();
     
            ObjectOutputStream sortie = null;
            //dimensionnement de mon tableau  avec ma méthode taille tableau
            this.tableau = new int[tailleTableau()];
            for (int i = 0; i < tableau.length; i++) {
     
                int choix = menuFonction();//Appel de ma méthode MenuFonction     
     
                System.out.println("\n");
                //Switch pour remplir les attributs d'une classe en fonction du choix fait avant           
                switch (choix) {
                    case 0:
                        System.exit(0);
                        break;
                    case 1:
                        Personnes directeur = new Directeur();
                        System.out.println("Entrer les informations demandée sur le directeur:  ");
                        System.out.print("Numéro National: ");
                        directeur.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        directeur.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        directeur.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        directeur.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(directeur)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 2:
                        Personnes comptable = new Comptable();
                        System.out.println("Entrer les informations demandée sur le comptable:  ");
                        System.out.print("Numéro National: ");
                        comptable.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        comptable.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        comptable.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        comptable.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(comptable)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 3:
                        Personnes secretaire = new Secretaire();
                        System.out.println("Entrer les informations demandée sur la/le secretaire:  ");
                        System.out.print("Numéro National: ");
                        secretaire.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        secretaire.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        secretaire.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        secretaire.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(secretaire)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 4:
                        Personnes ouvrier = new Ouvrier();
                        System.out.println("Entrer les informations demandée sur l'ouvrier:  ");
                        System.out.print("Numéro National: ");
                        ouvrier.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        ouvrier.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        ouvrier.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        ouvrier.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(ouvrier)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 5:
                        programme.showMenuDépart();
                    default:
                        this.menuFonction();
                }
            }
     
            try {
                saveDataHset(hset);//appel de ma méthode saveDataHset
            } catch (IOException ex) {
                Logger.getLogger(IntroDonneesSaveBin.class.getName()).log(Level.SEVERE, null, ex);
            }
     
            this.endProg(programme);//appel de la méthode fin de programme
        }
     
        //****************************************Méthodes*****************************************************
     
        /**
         * Méthode qui parcour mon hashset via un itérateur et encode mes objets
         * Personnes dans un fichier binaire
         *
         * @param hs
         * @throws FileNotFoundException
         * @throws IOException
         */
        public static void saveDataHset(HashSet<Personnes> hs) throws FileNotFoundException, IOException {
            // Création d'un itérateur
            Iterator<Personnes> iter = hs.iterator();
            ObjectOutputStream sortie = new ObjectOutputStream(new FileOutputStream("fichier.dat"));
            // Boucle tant qu'il y a un objet dans le hashset
            while (iter.hasNext()) {
                Personnes empl = iter.next();
                sortie.writeObject(empl);
            }
            System.out.println();
        }
     
        /**
         * Fin du programme, retour au menu principale
         *
         * @param programme
         */
        @Override
        public void endProg(MenuDepart programme) {
            System.out.println("Appuyer sur une touche pour retourner au menu.");
            String str = Clavier.lireString();
            programme.showMenuDépart();
        }
     
        /**
         * Méthode pour choisir la fonction, quitter ou retour au menu principale
         *
         * @return
         */
        private int menuFonction() {
            System.out.println("Veuillez choisir un chiffre dans la liste ci-dessous: ");
            System.out.println("0  ==> Quitter");
            System.out.println("1  ==> Directeur");
            System.out.println("2  ==> Comptable");
            System.out.println("3  ==> Secretaire");
            System.out.println("4  ==> Ouvrier");
            System.out.println("5  ==> Retour au menu de départ");
            System.out.print("Votre choix: ");
            int choix;
            choix = (Clavier.lireInt());
            return choix;
        }
     
        /**
         * Méthode pour choisir le nombre d'employé et donc la taille de mon tableau
         *
         * @return
         */
        private int tailleTableau() {
            int taille;
            System.out.print("Entrer le nombre d'employé dans l'entreprise: ");
            taille = Clavier.lireInt();
            return taille;
        }
    }

  5. #5
    Membre éclairé Avatar de Cincinnatus
    Homme Profil pro
    Développeur Java
    Inscrit en
    mars 2007
    Messages
    289
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Service public

    Informations forums :
    Inscription : mars 2007
    Messages : 289
    Points : 817
    Points
    817

    Par défaut

    Citation Envoyé par thelvin Voir le message
    Ben si, en fait. C'est le ET logique et pas paresseux.
    Ok. Pour moi le & ne devait être utilisé que pour les opérations sur les bits. Un reste d'informatique industrielle, dans une autre vie.
    Et cf : https://docs.oracle.com/javase/tutor...operators.html

    A l'occasion, je m'en resservirais peut-être. En tout cas ça m'aura appris quelque chose.

  6. #6
    Membre habitué
    Homme Profil pro
    Consultant informatique
    Inscrit en
    mars 2016
    Messages
    57
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Russie

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2016
    Messages : 57
    Points : 130
    Points
    130

    Par défaut

    Citation Envoyé par Cisman Voir le message
    Bonjour,
    Pour finir, j'ai modifier mon equals(), je ne test que sur le nom et ça fonctionne. Etant bien d'accord que normalement, je testerai sur une ID ou numéro national qui serait unique.
    Par contre, je répète dans mon switch case, 4 fois la même condition, et je n'arrive pas à en faire une méthode qui fonctionne, je cafouille dans les paramètres que je dois lui passé et ce qu'elle doit retourner.

    Personnes.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
     
    import java.io.Serializable;
     
    /**
     *
     * @author Fred
     */
    public abstract class Personnes implements IntPersonne, Serializable {
     
        // ***********************   Attributs  ***************************************
        /**
         * Numero national de la personne
         */
        public String numeroNational;
        /**
         * Prénom de la personne
         */
        public String prenom;
        /**
         * Nom de la personne
         */
        public String nom;
        /**
         * Fonction de la personne
         */
        public String fonction;
     
        // ***********************  Constructeurs ***************************************
        /**
         * Constructeur avec paramètres
         *
         * @param numeroNational
         * @param prenom
         * @param nom
         * @param fonction
         */
        public Personnes(String numeroNational, String prenom, String nom, String fonction) {
            this.numeroNational = numeroNational;
            this.prenom = prenom;
            this.nom = nom;
            this.fonction = fonction;
        }
     
        /**
         * Constructeur par défaut
         */
        public Personnes() {
        }
     
        // *********************** Getters and setters *********************************
        /**
         * Getters and Setters commun à toutes les classes
         * @return
         */
        public String getNumeroNational() {
            return numeroNational;
        }
     
        public void setNumeroNational(String numeroNational) {
            this.numeroNational = numeroNational;
        }
     
        public String getPrenom() {
            return prenom;
        }
     
        public void setPrenom(String prenom) {
            this.prenom = prenom;
        }
     
        public String getNom() {
            return nom;
        }
     
        public void setNom(String nom) {
            this.nom = nom;
        }
     
        public String getFonction() {
            return fonction;
        }
     
        public void setFonction(String fonction) {
            this.fonction = fonction;
        }
     
    //******************************* Méthodes ******************************************
        /**
         * Méthodes Overridé
         */
        @Override
        public abstract void joue();
     
        @Override
        public abstract void manger();
     
        /**
         * Méthode hashCode pour mon hashset
         * @return 
         */
        @Override
        public int hashCode() {
            return 10;
        }
        /**
         * Méthode equals pour mon hashset
         * @param obj
         * @return 
         */
        @Override
        public boolean equals(Object obj) {
           if (obj instanceof Personnes){
               return((Personnes)obj).getNom().equals(this.getNom());   
           }
           return false;
        }
    }

    IntroDonneesSaveBin
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
     
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.logging.Level;
    import java.util.logging.Logger;
     
    /**
     *
     * @author Fred
     */
    public class IntroDonneesSaveBin implements Prog {
     
        /**
         * Tableau de int qui servira pour boucler autant de fois qu'il y a
         * d'employé dans l'entreprise
         */
        public int[] tableau = null;
     
        /**
         * Methode qui remplis mon hashset et les attributs de chaques employés
         *
         */
        @Override
        public void execute(MenuDepart programme) {
            //Création d'une haspMap qui définira la fonction d'un objet
            HashMap<Integer, String> mesFonctions = new HashMap<>();
            // Insertion des valeurs dans la hashmap
            mesFonctions.put(1, "Directeur");
            mesFonctions.put(2, "Comptable");
            mesFonctions.put(3, "Secretaire");
            mesFonctions.put(4, "Ouvrier");
     
            // Création d'un hashSet d'objets Personnes
            HashSet<Personnes> hset = new HashSet<>();
     
            ObjectOutputStream sortie = null;
            //dimensionnement de mon tableau  avec ma méthode taille tableau
            this.tableau = new int[tailleTableau()];
            for (int i = 0; i < tableau.length; i++) {
     
                int choix = menuFonction();//Appel de ma méthode MenuFonction     
     
                System.out.println("\n");
                //Switch pour remplir les attributs d'une classe en fonction du choix fait avant           
                switch (choix) {
                    case 0:
                        System.exit(0);
                        break;
                    case 1:
                        Personnes directeur = new Directeur();
                        System.out.println("Entrer les informations demandée sur le directeur:  ");
                        System.out.print("Numéro National: ");
                        directeur.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        directeur.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        directeur.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        directeur.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(directeur)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 2:
                        Personnes comptable = new Comptable();
                        System.out.println("Entrer les informations demandée sur le comptable:  ");
                        System.out.print("Numéro National: ");
                        comptable.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        comptable.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        comptable.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        comptable.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(comptable)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 3:
                        Personnes secretaire = new Secretaire();
                        System.out.println("Entrer les informations demandée sur la/le secretaire:  ");
                        System.out.print("Numéro National: ");
                        secretaire.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        secretaire.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        secretaire.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        secretaire.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(secretaire)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 4:
                        Personnes ouvrier = new Ouvrier();
                        System.out.println("Entrer les informations demandée sur l'ouvrier:  ");
                        System.out.print("Numéro National: ");
                        ouvrier.setNumeroNational(Clavier.lireString());
                        System.out.print("Prénom: ");
                        ouvrier.setPrenom(Clavier.lireString());
                        System.out.print("Nom: ");
                        ouvrier.setNom(Clavier.lireString());
                        System.out.println("Fonction: " + mesFonctions.get(choix));
                        ouvrier.setFonction(mesFonctions.get(choix));//Utilisation de la clé du HashMap pour définir la fonction
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(ouvrier)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 5:
                        programme.showMenuDépart();
                    default:
                        this.menuFonction();
                }
            }
     
            try {
                saveDataHset(hset);//appel de ma méthode saveDataHset
            } catch (IOException ex) {
                Logger.getLogger(IntroDonneesSaveBin.class.getName()).log(Level.SEVERE, null, ex);
            }
     
            this.endProg(programme);//appel de la méthode fin de programme
        }
     
        //****************************************Méthodes*****************************************************
     
        /**
         * Méthode qui parcour mon hashset via un itérateur et encode mes objets
         * Personnes dans un fichier binaire
         *
         * @param hs
         * @throws FileNotFoundException
         * @throws IOException
         */
        public static void saveDataHset(HashSet<Personnes> hs) throws FileNotFoundException, IOException {
            // Création d'un itérateur
            Iterator<Personnes> iter = hs.iterator();
            ObjectOutputStream sortie = new ObjectOutputStream(new FileOutputStream("fichier.dat"));
            // Boucle tant qu'il y a un objet dans le hashset
            while (iter.hasNext()) {
                Personnes empl = iter.next();
                sortie.writeObject(empl);
            }
            System.out.println();
        }
     
        /**
         * Fin du programme, retour au menu principale
         *
         * @param programme
         */
        @Override
        public void endProg(MenuDepart programme) {
            System.out.println("Appuyer sur une touche pour retourner au menu.");
            String str = Clavier.lireString();
            programme.showMenuDépart();
        }
     
        /**
         * Méthode pour choisir la fonction, quitter ou retour au menu principale
         *
         * @return
         */
        private int menuFonction() {
            System.out.println("Veuillez choisir un chiffre dans la liste ci-dessous: ");
            System.out.println("0  ==> Quitter");
            System.out.println("1  ==> Directeur");
            System.out.println("2  ==> Comptable");
            System.out.println("3  ==> Secretaire");
            System.out.println("4  ==> Ouvrier");
            System.out.println("5  ==> Retour au menu de départ");
            System.out.print("Votre choix: ");
            int choix;
            choix = (Clavier.lireInt());
            return choix;
        }
     
        /**
         * Méthode pour choisir le nombre d'employé et donc la taille de mon tableau
         *
         * @return
         */
        private int tailleTableau() {
            int taille;
            System.out.print("Entrer le nombre d'employé dans l'entreprise: ");
            taille = Clavier.lireInt();
            return taille;
        }
    }

    Bonjour,

    Il ne te manque pas un bout de code?
    Je vois pas la définition de la classe "Directeur".

    Pourquoi ne pas faire par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    case1
    Directeur directeur = new Directeur()
    remplirDonneesPersonnes(directeur);
    ...
    break;

    et la méthode remplirDonneesPersonnes est :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private void remplirDonneesPErsonnes(Personnes pers){
    System.out.println("Entrer les informations demandée sur le directeur:  ");
                        System.out.print("Numéro National: ");
                        String numeroNational = Clavier.lireString();
                        System.out.print("Prénom: ");
                        String prenom = Clavier.lireString();
                        System.out.print("Nom: ");
                        String nom = Clavier.lireString();
                        System.out.println("Fonction: " + mesFonctions.get(choix));
    }
    Comme ca ca t'enlève le code dupliqué.
    Et vu que tes Objects Secrétaire, comptable.. sont étendus de Personnes tu peux le mettre pour tous les cas.

    Jére´my.

  7. #7
    Nouveau membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    septembre 2017
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2017
    Messages : 44
    Points : 27
    Points
    27

    Par défaut

    Bonjour et merci pour vos réponses.
    Pour remplir les donnée Personnes, je résous la répétition du code en rentrant ça dans des variables en début de boucle. J'ai plutôt un soucis pour le code suivant, une condition qui se répète 4 fois dans mon code. J’essaie d'en faire une méthode, mais je ne vois pas comment passer la hashset en paramètre.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    if (hset.add(ouvrier)) {
    } else {
          System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
          System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
          i--;
    }
    Ma classe complète
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
     
    package be.iepscfjemelle.poolabo.nicolay.entreprise2withcollections;
     
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.logging.Level;
    import java.util.logging.Logger;
     
    /**
     * Classe héritant de l'interface Prog, qui à partir d'un menu secondaire, crée
     * des objets Personnes et leurs attributs, (fonctions d'après un hashmap).
     * Places ces objets Personnes dans un hashset, pour éviter les doublons.
     * Ensuite, parcours le hashset, sérialise chaque ojets et l'enregistre dans un
     * fichier binaire. Propose un retour au menu principal à la fin.
     *
     * @author Frederic Nicolay 2ème Bachelier Informatique
     */
    public class IntroDonneesSaveBin implements Prog {
     
        /**
         * Methode qui remplis mon hashset et les attributs de chaques employés
         *
         */
        @Override
        public void execute(MenuDepart programme) {
            //Création d'une haspMap qui définira la fonction d'un objet
            HashMap<Integer, String> mesFonctions = new HashMap<>();
            // Insertion des valeurs dans la hashmap
            mesFonctions.put(1, "Directeur");
            mesFonctions.put(2, "Comptable");
            mesFonctions.put(3, "Secretaire");
            mesFonctions.put(4, "Ouvrier");
     
            // Création d'un hashSet d'objets Personnes
            HashSet<Personnes> hset = new HashSet<>();
     
            ObjectOutputStream sortie = null;
     
            int nbr = nombreEmploye();//nombre d'employé dans l'entreprise pour définir le nombre de boucles
     
            for (int i = 0; i < nbr; i++) {
                int choix = menuFonction();//Appel de ma méthode MenuFonction    
                //Lecture des données de chaque employé dans la console pour remplir les attributs de chaque objet Personnes
                System.out.println("Entrer les informations demandée sur l'ouvrier:  ");
                System.out.print("Numéro National: ");
                String numeroNational = Clavier.lireString();
                System.out.print("Prénom: ");
                String prenom = Clavier.lireString();
                System.out.print("Nom: ");
                String nom = Clavier.lireString();
                System.out.println("Fonction: " + mesFonctions.get(choix));
                String fonction = mesFonctions.get(choix);
                System.out.println("\n");
                //Switch pour remplir les attributs d'une classe en fonction du choix fait avant           
                switch (choix) {
                    case 0:
                        System.exit(0);
                        break;
                    case 1:
                        Personnes directeur = new Directeur(numeroNational, prenom, nom, fonction);
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(directeur)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 2:
                        Personnes comptable = new Comptable(numeroNational, prenom, nom, fonction);
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(comptable)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 3:
                        Personnes secretaire = new Secretaire(numeroNational, prenom, nom, fonction);
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(secretaire)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 4:
                        Personnes ouvrier = new Ouvrier(numeroNational, prenom, nom, fonction);
                        //condition ajout de l'objet, si le nom existe déjà, msg erreur et demande à nouveau les attributs du nouvel employé
                        if (hset.add(ouvrier)) {
                        } else {
                            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                            i--;
                        }
                        System.out.println("\n");
                        break;
                    case 5:
                        programme.showMenuDépart();
                    default:
                        this.menuFonction();
                }
            }
     
            try {
                saveDataHset(hset);//appel de ma méthode saveDataHset
            } catch (IOException ex) {
                Logger.getLogger(IntroDonneesSaveBin.class.getName()).log(Level.SEVERE, null, ex);
            }
     
            this.endProg(programme);//appel de la méthode fin de programme
        }
     
        //****************************************Méthodes*****************************************************
        public void addPersHset(hset<Personnes>, Personnes pers, int i) {
            if (hset.add(pers)) {
            } else {
                System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
                System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
                i--;
            }
        }
     
        /*public String entreeDonneePersonnes(chiffre){
            System.out.println("Entrer les informations demandée sur l'ouvrier:  ");
            System.out.print("Numéro National: ");
            String numeroNational = Clavier.lireString();
            System.out.print("Prénom: ");
            String prenom = Clavier.lireString();
            System.out.print("Nom: ");
            String nom = Clavier.lireString();
            System.out.println("Fonction: " + mesFonctions.get(chiffre));
            String fonction = mesFonctions.get(chiffre);
            return numeroNational, prenom, nom, fonction;
        }*/
        /**
         * Méthode qui parcour mon hashset via un itérateur et encode mes objets
         * Personnes dans un fichier binaire
         *
         * @param hs
         * @throws FileNotFoundException
         * @throws IOException
         */
        public static void saveDataHset(HashSet<Personnes> hs) throws FileNotFoundException, IOException {
            // Création d'un itérateur
            Iterator<Personnes> iter = hs.iterator();
            ObjectOutputStream sortie = new ObjectOutputStream(new FileOutputStream("fichier.dat"));
            // Boucle tant qu'il y a un objet dans le hashset
            while (iter.hasNext()) {
                Personnes empl = iter.next();
                sortie.writeObject(empl);
            }
            System.out.println();
        }
     
        /**
         * Fin du programme, retour au menu principale
         *
         * @param programme
         */
        @Override
        public void endProg(MenuDepart programme) {
            System.out.println("Appuyer sur une touche pour retourner au menu.");
            String str = Clavier.lireString();
            programme.showMenuDépart();
        }
     
        /**
         * Méthode pour choisir la fonction, quitter ou retour au menu principale
         *
         * @return
         */
        private int menuFonction() {
            System.out.println("Veuillez choisir un chiffre dans la liste ci-dessous: ");
            System.out.println("0  ==> Quitter");
            System.out.println("1  ==> Directeur");
            System.out.println("2  ==> Comptable");
            System.out.println("3  ==> Secretaire");
            System.out.println("4  ==> Ouvrier");
            System.out.println("5  ==> Retour au menu de départ");
            System.out.print("Votre choix: ");
            int choix;
            choix = (Clavier.lireInt());
            return choix;
        }
     
        /**
         * Méthode pour choisir le nombre d'employé et renvoyé un int
         *
         * @return
         */
        private int nombreEmploye() {
            int taille;
            System.out.print("Entrer le nombre d'employé dans l'entreprise: ");
            taille = Clavier.lireInt();
            return taille;
        }
    }

  8. #8
    Membre habitué
    Homme Profil pro
    Consultant informatique
    Inscrit en
    mars 2016
    Messages
    57
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Russie

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2016
    Messages : 57
    Points : 130
    Points
    130

    Par défaut

    Bonjour

    Tu dois juste l'externaliser dans une méthode à part.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    case1
    Directeur directeur = new Directeur(numeroNational, prenom, nom, fonction);
    i = ajoutPersonneToList(directeur, hset)? i : i--;
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    private boolean ajoutPersonneToList(Personnes pers, HashSet<Personnes> hset){
    if (hset.add(directeur)) {
            return true;
    } else {
            System.out.println("Cet employé occupe déjà une fonction dans l'entreprise.\n");
            System.out.println("Veuillez rentrer à nouveau les informations sur l'employé.\n");
            return false;
                        }
    }
    Tu peux essayer qqch de ce genre la.

    Jére´my.

  9. #9
    Nouveau membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    septembre 2017
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2017
    Messages : 44
    Points : 27
    Points
    27

    Par défaut

    Bonjour, et merci pour cette solution.

    J'ai essayé ta solution hier et encore ce matin.
    ça m'indique bien que l'employé existe déjà dans la société et me propose de rentrer à nouveau l'employé, mais le i-- n'a pas l'air de fonctionner.
    Je sort de la boucle et ça m'amène directement à ma méthode endProg.

    Bizare, pcq la ternaire que tu me propose doit normalement faire la même chose que mon if/else.

  10. #10
    Membre habitué
    Homme Profil pro
    Consultant informatique
    Inscrit en
    mars 2016
    Messages
    57
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Russie

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2016
    Messages : 57
    Points : 130
    Points
    130

    Par défaut

    Bonjour,

    Oui il fait la même chose. Sauf que le i-- n'est pas bon dans e cas, my bad.

    Donc il faut faire :

    Essaie de modifier la méthode ajoutPersonneToList comme ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    i = ajoutPersonneToList(directeur, hset)? i : i-1;
    ou

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    if(!ajoutPersonneToList(directeur, hset)){
    i--;
    }

    Jérémy.

  11. #11
    Nouveau membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    septembre 2017
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2017
    Messages : 44
    Points : 27
    Points
    27

    Par défaut

    Les deux conditions fonctionne

    Un grand merci pour le coup de main.

    Bon maintenant, je me colle aux tests unitaires.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Problème avec les collections
    Par kore62 dans le forum Langage
    Réponses: 11
    Dernier message: 22/08/2007, 15h26
  2. problème de recherche avec les collections
    Par gibea00 dans le forum VB 6 et antérieur
    Réponses: 1
    Dernier message: 22/08/2007, 00h23
  3. problème avec les collections
    Par root76 dans le forum Langage
    Réponses: 4
    Dernier message: 08/01/2007, 16h06
  4. doublons avec les expressions régulières
    Par Mister Nono dans le forum Fichiers
    Réponses: 8
    Dernier message: 16/09/2006, 13h14
  5. Empécher les doublon avec les post
    Par Death83 dans le forum Formulaires
    Réponses: 15
    Dernier message: 20/07/2006, 10h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo