Hashmap, hashset et classes !

**helmutobrian** · 15/03/2009, 22h51

Bonjour à tous !

Je suis actuellement entrain de travailler sur un projet d'école de niveau débutant, mais ne connaissant pas bien le Java je bloque sur une question qui me permettrait de finir et de rendre mon projet.

En effet, le but de ce projet est de manipuler et utiliser les classes en Java.

Pour cela, nous devons gérer un magasin en créant des classes pour son stock et ses articles.

Les articles proposés par le magasin sont caractérisés par une référence (représentée par un chaîne de caractères formée de chiffres de longueur 8 au maximum), une dénomination, un prix hors taxe, un taux de TVA.

En partant de la, j'ai créé une classe Article (qui est validée, mais si vous avez des remarques n'hésitez pas).

Celle-ci ressemble à ça :

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
public class Article {
 
    private String Reference;
    private String Nom;
    private float Prix;
    private float Tva;
 
    public static void Article(){};
 
    public void Article(String Ref, String Nom, float TVA, float Prix)
    {
       if(Ref.length()<=8)
       {
            this.Reference = Ref;
            this.Nom = Nom;
            this.Tva = TVA;
            this.Prix = Prix;
       }
       else
       {
            System.out.println("Erreur : référence trop longue.");
       }
    }
 
    public void setArticleRef(String Ref)
    {
        if(Ref.length()<=8)
        {
            this.Reference = Ref;
        }
        else
        {
            System.out.println("Erreur : référence trop longue.");
        }
    }
 
    public String getArticleRef()
    {
        return this.Reference;
    }
 
    public void setArticleNom(String Nom)
    {
        this.Nom = Nom;
    }
 
    public String getArticleNom()
    {
        return this.Nom;
    }
 
    public void setArticleTVA(float TVA)
    {
        this.Tva = TVA;
    }
 
    public void setArticlePrix(float Prix)
    {
        this.Prix = Prix;
    }
 
    public float getArticlePrix()
    {
        return this.Prix;
    }
 
    public String toString()
    {
     return "[ref : " + this.Reference + ", nom : " + this.Nom + ", PrixHT : " + this.Prix + ", TVA : " + this.Tva + "]";
    }
}

Ensuite, il nous est demandé :

Créer une classe Stock qui rassemble l'ensemble des articles créés dans une même structure de données
(Collection). Il faut aussi représenter le nombre d'exemplaires disponibles pour chaque article. On choisira
dans le package java.util la structure la plus adaptée parmi :
ArrayList, HashMap, HashSet.
En plus de ses constructeur et accesseurs, cette classe devra comporter des méthodes :
pour ajouter un article au stock.
pour le supprimer du stock
pour retourner un article connaissant sa référence
pour retourner le nombre d'exemplaires associé à un article

J'ai trouvé qu'il fallait utiliser Hashmap ou Hashset pour cette nouvelle classe car celles-ci permettent d'éviter les doublons, mais je ne comprends vraiment comment mettre en place cette classe avec Hashmap ou Hashset, en fait je ne vois pas vraiment à quoi ça sert.

On va créer une variable de type Hashmap ou Hashset dans la classe pour regrouper les Articles créés ? Ou est-ce la classe Stock qui est de type Hashmap ou Hashset ?

Je suis vraiment dans le floue, je n'arrive pas à saisir ce à quoi sert vraiment ces fonctions. J'ai lu le tutoriel dans la section Java parlant des collections, mais je ne vois pas comment l'utiliser le mettre en place dans mon cas.

Une autre question c'est, comment récupérer les différentes instances de classes de la classe Article ? Est-ce possible ?

Je n'arrive pas à faire le lien entre les deux classes que je vous ai cités.

Si quelqu'un peut prendre du temps pour m'expliquer les collections, ou du moins leurs mises en places / architecture dans mon problème ce serait cool.

Je ne demande pas à ce qu'on réalise mon projet. Mais qu'on me donne des indices pour avancer.

En vous souhaitant une bonne soirée.

Cordialement,

Helmut O'Brian

**helmutobrian** · 16/03/2009, 01h37

Bon j'ai pas mal avancé, est-ce que d'après vous cette solution est convenable et efficace d'un point de vue traitement :

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
import java.util.*;
 
public class Stock {
        private Set stock = new HashSet();
 
        public static void Stock(){};
 
        public void ajoutArticle(Article Ajout){
            stock.add(Ajout);
        }
 
       public void supprimeArticle(Article Suppression){
           stock.remove(Suppression);
       }
 
       public boolean presenceArticle(String reference){
           Iterator i = stock.iterator();
           int n=0;
 
           while(i.hasNext())
           {
               Article e = (Article) i.next();
               if(e.getArticleRef().equals(reference))return true;
           }
 
           return false;
       }
 
       public int nombreArticle(String nom){
           Iterator i = stock.iterator();
           int n=0;
 
           while(i.hasNext())
           {
               Article e = (Article) i.next();
               if(e.getArticleNom().equals(nom))n++;
           }
 
           return n;
       }
}

**Jidefix** · 16/03/2009, 11h39

Bonjour,
Dans ton cas, un Article est défini par sa référence.
Par conséquent vu que tu va faire tes recherches sur cette référence, j'aurai plutot utilisé une HashMap, avec pour chaque entrée:
la clé serait la référence
l'objet serait ton Article

Ta fonction de recherche en serait grandement accéléré (plus besoin de faire un parcours, tu accèdes directement à la référence voulue)

Par ailleurs la notion de "Stock" n'implique-t-elle pas une notion de quantité sur chaque Article?

edit: ah oui aussi, sur les Collections (ArrayList, Set, HashSet...) et les Map (HashMap...), il y a une superbe fonction size() qui te renvoie le nombre d'éléments dedans

**Heimdal** · 16/03/2009, 11h44

Salut,
j'ai quelques remarques ebn vrac:

1) Essaye de suivre les conventions de nommage: une Classe, un Objet, un attribut, une variable, une methode().

2) A quoi sert

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public static void Article(){}

???

3) Les différentes collections existantes (HashSet, ArrayList, HashMap) se basent sur les methode equals et hashmap des objets, il est donc vivement conseillé de les surcharger pour pouvoir utiliser les méthodes fournis par l'api.
De plus, conceptuellement il est intéressant de pouvoir dire que tel article est le meme que tel autre.

4) Un HashSet est selon moi peu adapté pour ton objet Stock. Si tu élimines les doublons comment comptes-tu savoir combien tu possèdes de tel article.
Tel quel cela marche miraculeusement car lorsque tu fais un set.add(article) il l'ajoute car ayant une adresse mémoire différente.
Je te conseille une ArrayList (change quasiment rien de ton code) ou une HashMap (pour mieux structurer ton stock)

4) Enfin, utilises les génériques pour typer tes collections:
private Set<Article> stock = new HashSet<Article>();

**helmutobrian** · 16/03/2009, 22h07

Bonsoir à tous !

Merci beaucoup pour vos conseils, j'ai finallement abandonné les HashSet et je suis passé aux HashMap, mais je ne suis pas sur de l'efficacité de mon code :

Classe Article :

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
 
import java.util.*;
import java.io.Serializable;
 
public class Article implements Serializable{
 
    /**
     * Les différentes variables de la classe Article
     * @param Reference La référence d'un article (unique)
     * @param Nom Le nom d'un article
     * @param Prix Le prix d'un article
     * @param Tva La TVA appliquée à un article
     * @preconditions Référence de 8 caractères maximum
     */
    private String Reference;
    private String Nom;
    private float Prix;
    private float Tva;
 
    /**
     * Les différentes variables de la classe Article
     *
     * @param Reference La référence d'un article (unique)
     * @param Nom Le nom d'un article
     * @param Prix Le prix d'un article
     * @param Tva La TVA appliquée à un article
     *
     * @preconditions Référence de 8 caractères maximum
     */
    public void Article(String Ref, String Nom, float TVA, float Prix)
    {
       if(Ref.length()<=8)
       {
            this.Reference = Ref;
            this.Nom = Nom;
            this.Tva = TVA;
            this.Prix = Prix;
       }
       else
       {
            System.out.println("Erreur : référence trop longue.");
       }
    }
 
    /**
     * Défini la référence d'un article
     *
     * @param La référence d'un article
     */
    public void setArticleRef(String Ref)
    {
        if(Ref.length()<=8)
        {
            this.Reference = Ref;
        }
        else
        {
            System.out.println("Erreur : référence trop longue.");
        }
    }
 
    /**
     * Récupère la référence d'un article
     *
     * @return La référence d'un article
     */
    public String getArticleRef()
    {
        return this.Reference;
    }
 
    /**
     * Défini le nom d'un article
     *
     * @param Le nom d'un article
     */
    public void setArticleNom(String Nom)
    {
        this.Nom = Nom;
    }
 
    /**
     * Récupère le nom d'un article
     *
     * @return Le nom d'un article
     */    
    public String getArticleNom()
    {
        return this.Nom;
    }
 
    /**
     * Défini la TVA d'un article
     *
     * @param La TVA d'un article
     */
    public void setArticleTVA(float TVA)
    {
        this.Tva = TVA;
    }
 
    /**
     * Défini le prix d'un article
     *
     * @param Le prix d'un article
     */
    public void setArticlePrix(float Prix)
    {
        this.Prix = Prix;
    }
 
    /**
     * Récupère le prix d'un article
     *
     * @return Le prix d'un article
     */
    public float getArticlePrix()
    {
        return this.Prix;
    }
 
    /**
     * Récupère la TVA d'un article
     *
     * @return La TVA d'un article
     */
    public float getArticleTVA()
    {
        return this.Tva;
    }
 
    /**
     * Récupère toutes les propriétés d'un article sous forme de string
     *
     * @return Les propriétés d'un article sous forme de string
     */
    public String toString()
    {
     return "[ref : " + this.Reference + ", nom : " + this.Nom + ", PrixHT : " + this.Prix + ", TVA : " + this.Tva + "]";
    }
}

Classe Stock :

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
 
import java.io.Serializable;
import java.util.*;
 
public class Stock implements Serializable{
 
        /**
         * Nouvelle donnée de type HashMap pour gérer un stock
         *  @param stock Le stock d'articles
         */
        private Map stock = new HashMap();
 
        /**
         *  Ajoute un article a un stock
         *  @param Ajout L'article à ajouter
         */
        public void ajoutArticle(Article Ajout){
            stock.put(Ajout.getArticleRef(), Ajout);
        }
 
        /**
         *  Supprime un article d'un stock
         *  @param Ajout L'article à supprimer
         */
       public void supprimeArticle(Article Suppression){
           stock.remove(Suppression);
       }
 
        /**
         * Recherche un article dans le stock à partir de sa référence
         * @param La référence de l'article à rechercher
         * @return L'article présentant la référence indiquée
         */
       public Article presenceArticle(String reference){
           Article Article = (Article) stock.get(reference);
           return Article;
       }
 
        /**
         * Recherche le nombre d'articles dans le stock à partir de son nom
         * @param Le nom de l'article à rechercher
         * @return Le nombre d'article présentant le nom indiqué
         */
       public int nombreArticle(String nom){
            Set Cles = stock.entrySet();
            Iterator i = Cles.iterator();
            int n=0;
 
            while(i.hasNext())
            {
               Map.Entry e = (Map.Entry) i.next();
               Article Article = (Article) e.getValue();
                if(Article.getArticleNom().equals(nom))n++;
            }
 
            return n;
       }
 
       /**
        * Affiche un stock
        * @return Affiche une boîte de dialogue contenant les articles du stock
        */
      public void afficheStock()
      {
            Set Cles = stock.entrySet();
            Iterator i = Cles.iterator();
            String Message="";
            int n=1;
 
            while(i.hasNext())
            {
               Map.Entry e = (Map.Entry) i.next();
               Article Article = (Article) e.getValue();
               Message += "Article n° " + n + " - Nom : " + Article.getArticleNom() + " - Prix : " + Article.getArticlePrix() + " - TVA : " + Article.getArticleTVA() + " - Référence : " + Article.getArticleRef() + "\n";
               n++;
            }
 
            Interface.AfficheMessage("Stock :", Message);
      }
 
       /**
        * Return un stock sous forme d'une chaîne
        * @return Les articles du stock sous forme d'une chaîne
        */
      public String toString(){
            Set Cles = stock.entrySet();
            Iterator i = Cles.iterator();
            String Message="";
            int n=1;
 
            while(i.hasNext())
            {
               Map.Entry e = (Map.Entry) i.next();
               Article Article = (Article) e.getValue();
               Message += "Article n° " + n + " - Nom : " + Article.getArticleNom() + " - Prix : " + Article.getArticlePrix() + " - TVA : " + Article.getArticleTVA() + " - Référence : " + Article.getArticleRef() + "\n";
               n++;
            }
 
            return Message;
      }
}

Classe Interface :

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
 
import javax.swing.JOptionPane;
 
public class Interface{
 
    /**
     * Affiche un message
     *
     * @param Titre Le titre de la fenêtre.
     * @param Message Le message de la fenêtre.
     */
    public static void AfficheMessage(String Titre, String Message)
    {
        JOptionPane.showMessageDialog(null, Message, Titre, JOptionPane.INFORMATION_MESSAGE);
    }
 
    /**
     * Effectue une saisie utilisateur de type Float
     *
     * @param Titre Le titre de la fenêtre.
     * @param Question Le message de question la fenêtre.
     * @return La saisie utilisateur
     */
    public static float SaisieFloat(String Titre, String Question)
    {
         String donnees = JOptionPane.showInputDialog(null, Question, Titre, JOptionPane.QUESTION_MESSAGE);
         float retour = Float.parseFloat(donnees);
         return retour;
    }
 
    /**
     * Effectue une saisie utilisateur de type Entier
     *
     * @param Titre Le titre de la fenêtre.
     * @param Question Le message de question la fenêtre.
     * @return La saisie utilisateur
     */
    public static float SaisieInt(String Titre, String Question)
    {
         String donnees = JOptionPane.showInputDialog(null, Question, Titre, JOptionPane.QUESTION_MESSAGE);
         int retour = Integer.parseInt(donnees);
         return retour;
    }
 
    /**
     * Effectue une saisie utilisateur de type String
     *
     * @param Titre Le titre de la fenêtre.
     * @param Question Le message de question la fenêtre.
     * @return La saisie utilisateur
     */
    public static String Saisie(String Titre, String Question)
    {
         String donnees = JOptionPane.showInputDialog(null, Question, Titre, JOptionPane.QUESTION_MESSAGE);
         return donnees;
    }
 
    /**
     * Effectue une saisie utilisateur de type Entier
     *
     * @param Stock Le stock auquel ajouter un article
     * @return Le stock avec un nouvel article
     */
   public void SaisieArticle(Stock Stock)
   {
        Article Article = new Article();
 
        Article.setArticleNom(this.Saisie("Ajout d'un article dans le stock","Définissez le nom de l'article"));
        Article.setArticleRef(this.Saisie("Ajout d'un article dans le stock","Définissez la référence de l'article"));
        Article.setArticlePrix(this.SaisieFloat("Ajout d'un article dans le stock","Définissez le prix de l'article"));
        Article.setArticleTVA(this.SaisieFloat("Ajout d'un article dans le stock","Définissez la TVA de l'article"));
        Interface.AfficheMessage("Félicitations","Ajout réussi !");
 
        Stock.ajoutArticle(Article);
   }
}

Classe Client :

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
public class Client {
 
    /**
     * Affiche une interface utilisateur pour gérer un stock.
     */
    public void creeStock() throws ClassNotFoundException
    {
        Interface Gerant = new Interface();
        Stock stock = new Stock();
        String fichier = "";
        int n = (int) Interface.SaisieInt("Création d'un stock", "Entrez le nombre d'articles à ajouter au stock :");
 
        if(n != 0)
        {
            for(int i=0;i<n;i++)
            {
                Gerant.SaisieArticle(stock);
            }
 
            fichier = Interface.Saisie("Enregistrement...", "Entrez un nom de fichier pour enregistrer votre stock :");
            new main().stock2fichier(fichier, stock);
            stock = new main().fichier2Stock(fichier, stock);
            stock.afficheStock();
        }
    }
}

Classe main :

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
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class main{
 
 /* Enregistre un stock dans un fichier
  *
  * @param fichier Le nom du fichier à engregistrer
  * @param Stock Le stock à enregistrer
  */
 public void stock2fichier(String fichier, Stock Stock) {
 
        ObjectOutputStream outputStream = null;
 
        try {
                outputStream = new ObjectOutputStream(new FileOutputStream(fichier));
                outputStream.writeObject(Stock);
 
            }
        catch (FileNotFoundException ex)
            {
                ex.printStackTrace();
            }
        catch (IOException ex)
            {
                ex.printStackTrace();
            }
        finally
            {
                try
                    {
                        if (outputStream != null)
                            {
                                outputStream.flush();
                                outputStream.close();
                            }
                    }
                catch (IOException ex)
                    {
                        ex.printStackTrace();
                    }
            }
    }
 
 /* Récupère un stock dans un fichier
  *
  * @param fichier Le nom du fichier à engregistrer
  * @param Stock Le stock à récupérer
  */
    public Stock fichier2Stock(String fichier, Stock Stock) throws ClassNotFoundException{
 
        ObjectInputStream inputStream = null;
 
        try
            {
                inputStream = new ObjectInputStream(new FileInputStream(fichier));
                Stock = (Stock) inputStream.readObject();
            }
        catch (FileNotFoundException ex)
            {
                ex.printStackTrace();
            }
        catch (IOException ex)
            {
                ex.printStackTrace();
            }
        finally
            {
                try
                    {
                        if (inputStream != null)
                            {
                                inputStream.close();
                            }
                    }
                catch (IOException ex)
                    {
                        ex.printStackTrace();
                    }
            }
 
        return Stock;
    }
 
   /**
    * Fonction principale
    *
    * @param args Paramètres à passer à notre programme
    */
    public static void main(String[] args) throws ClassNotFoundException{
        Client Client = new Client();
        Client.creeStock();
    }    
}

Je ne suis pas sur de la pertinence et de l'efficacité de mon code, je n'ai jamais programmé en Java auparavant et quand vous me parlez de generics, etc... c'est du chinois pour moi lol (j'en suis à mon troisième cours de Java).

Vous trouverez ci-joint le sujet du projet à réaliser pour ceux que ça intéresse, j'ai rendu mon projet aujourd'hui, mais si vous avez des remarques, elles sont toujours bonnes à prendre.

Bonne soirée !

Cordialement,

Helmut O'Brian

**helmutobrian** · 16/03/2009, 22h11

Envoyé par Jidefix

Bonjour,
Dans ton cas, un Article est défini par sa référence.
Par conséquent vu que tu va faire tes recherches sur cette référence, j'aurai plutot utilisé une HashMap, avec pour chaque entrée:
la clé serait la référence
l'objet serait ton Article

Ta fonction de recherche en serait grandement accéléré (plus besoin de faire un parcours, tu accèdes directement à la référence voulue)

Par ailleurs la notion de "Stock" n'implique-t-elle pas une notion de quantité sur chaque Article?

edit: ah oui aussi, sur les Collections (ArrayList, Set, HashSet...) et les Map (HashMap...), il y a une superbe fonction size() qui te renvoie le nombre d'éléments dedans

Merci de ta réponse Jidefix, en fait la notion de quantité est assez bizarre dans ce projet, le professeur ne veut pas que l'on ajoute ce paramètres à la classe, mais que plusieurs articles peuvent être les memes en ayant une référence différentes...C'est un peu bizarre, mais bon si c'est le cahier des charges je le respecte.

Cordialement,

Helmut O'Brian

Hashmap, hashset et classes !

Collection et Stream Java

Discussions similaires

Partager

Partager