Discussion :

[jean3xw]

Bonjour,
je débute en Java et plus généralement en objet:

Je n'ait jamais fait de HashMap mais il me semble que c'est ce qu'il me faut pour mon programme(un TP de licence):

Code :

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

1
2
3
4
	// private Habitant CageField[]; // CHANGEMENT POUR  HASHMAP
             static private int NB_PLACE_1=1;
	private HashMap<Habitant,Habitant> CageField;
// initialiser hashmap a NB_PLACE_1 pour le nb de champs

/*Mon programme doit gérer un Zoo->Des cages de différentes tailles et qui peuvent contenir tous les types ou un type d'animaux spécifiques; et bien sûr j'ai les classes des animaux(parent Habitant) à faire avec chacun sa particularité et ses méthodes propres...*/

Je me suit rendu compte qu'avec un simple tableau pour contenir des animaux dans les cages(CageBuilder) je galérait un peu trop pour avoir le type d'animal(basiquement herbivore, carnivore, omnivore) et utiliser la(les) méthode(s) qui s'y rattache(nottament dans les cages qui peuvent contenir plusieurs types différents), HashMap me sembles convenir: j'entres le type de l'Objet en clé et l'Objet en valeur.
C'est là que je me suit rendu compte que je n'arrives pas à créer ma HashMap(faut il d'abord créer un objet Map?)
merci de vos conseils

[visiwi]

Salut,

Code :

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

Map<Habitant,Habitant> map = new HashMap<Habitant,Habitant>();

Cela dit, je ne saisi pas bien l'interrêt de ta clef. Il existe le mot-clef instanceof qui te permet de tester le type. Aussi une simple List devrait suffire.

Code :

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

List<Habitant> list = new ArrayList<Habitant>();

Peut-être aussi utiliser le polymorphisme si c'est possible (mais peut-être n'as tu pas encore vu ce concept).

[sethys]

Ton objectif est de déterminer quels types d'animaux peuvent contenir tes cages ou quels animaux sont dans tes cages ?

[roudoudouduo]

Au lieu d'utiliser une ArrayList tu peux utiliser un HashSet si tu as besoin d'assurer l'unicité des données.

Iterable comme une liste, il est impossible d'avoir l'accès direct aux données (ce qui n'est peut-être pas nécessaire pour toi).

Pour ce qui est de collections il est très interessant, de connaitre l'architecture en java (notammant les interfaces). En effet Map est une interface et HashMap tout comme TreeMap (qui implemente SortedMap) est simplement une implementation.

Toutefois ton analyse ne me semble pas très correct (à première vue).

A priori tu devrais avoir un objet Zoo qui contient des cages (un Set<Cage>). Chaque Cage contient des animaux (une Set<Animals>). Et un animal a une methode getTypeOfAnimal.

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
 
 
final public class Zoo {
 
    private final Set<Cage> cages = new HashSet<Cage>();
 
    public Set<Cage> getCages(){
        //permet de rendre non modifiable l'ensemble des cages
        //une exception est levée en cas d'appel d'add ou addAll
         return Collections.unmodifiableSet(this.cages);
    }
 
    public void addCage(Cage cage){
       if(null == cage) {
           throw new NullPointerException();
       }
       this.cages.add(cage);
   }
}
 
final public class Cage {
     //Premier cas
    private final Set<Animal> animaux = new HashSet<Animal>();
 
   public Set<Animal> getAnimaux(){
         //permet de rendre non modifiable l'ensemble des animaux
        //une exception est levée en cas d'appel d'add ou addAll
         return Collections.unmodifiableSet(this.animaux);
   }
 
  public void addAnimal(Animal animal){
       if(null == animal){
            throw new NullPointerException();
       }
       //si l'animal a deja ete ajouté le set ne change pas
       this.animaux.add(animal);
  }
 
}
 
final public class Animal {
   private final TypeOfAnimal typeOfAnimal;
 
   public Animal(TypeOfAnimal typeOfAnimal) {
        if(null == typeOfAnimal) {
               throw new NullPointerException();
        }
        this.typeOfAnimal = typeOfAnimal;
   }
 
   public TypeOfAnimal getTypeOfAnimal(){
       return this.typeOfAnimal;
   }
}
 
final public enum TypeOfAnimal {
   HERBIVORE, CARNIVORE (etc....);
}

Dans la classe cage tu peux éventuellement remplacer le Set<Cage> par une Map<IdentOfTheCage, Cage>, cela dépend de tes besoins.

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
 
 
final public class Zoo {
    //Dans notre cas les cages sont identifiées par un numéro
    private final Map<BigDecimal, Cage> cages = new HashSet<Cage>();
 
    public Map<BigDecimal, Cage> getCages(){
        //permet de rendre non modifiable l'ensemble des cages
        //une exception est levée en cas d'appel d'add ou addAll
         return Collections.unmodifiableMap(this.cages);
    }
 
    public void addCage(BigDecimal identOfTheCage, Cage cage){
      if(null == identOfTheCage) {
           throw new NullPointerException();
       }
       if(null == cage) {
           throw new NullPointerException();
       }
       this.cages.put(identOfTheCage, cage);
   }
}

Tu peux éventuellement faire de même pour les animaux en mettant un critère d'identification (en changeant le Set<Animal> dans Cage par un Map<IndentOfTheAnimal, Animal>). On peut par exemple considérer qu'un animal est identifié par son nom.

Encore une fois les collections sont une vrai force en java, et il faut bien les connaitre. Toutefois elles ne doivent pas être utiliser en lieu et place de classe java (comme c'est souvent le cas chez les débutants).

[jean3xw]

Bonsoir,
j'ai pas eu l'occasion de retourner voir le forum depuis un moment(cause virus+reinstal avec galére pour récup mes données) et je voit ici des pistes intéressantes et exemple pratique. Merci à tous.

Comme certains l'ont signalé mon soucis vient peut-être de la conception et je vais voir du côté du polymorphisme avant de m'intéresser aux collections et autres...

L'objet va bien finir par rentrer à force de me jeter la tête dessus(aie!).