Discussion :

[johannsan]

Bonjour.

J'ai une question concernant les hashmap.

J'ai une classe qui étend d'une arrayList

Cette classe contient donc un certain nombre d'attribut du style :

Code :

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

1
2
3
 
private BigDecimal totalMarinsCotisationsNettes = BigDecimal.ZERO;
private Map<String, BigDecimal> totalMarinCotisationsNettes = new HashMap<String, BigDecimal>();

Cette classe est initialisée au début et fait une fois les calculs en parcourant mon arrayList.
Suite à cela, je vais chercher les totaux au besoin des ces attributs (sans à faire à chaque fois les calculs)

La première valeur me permet de connaitre un total pour tous les marins de ma liste.
La deuxième valeur me permet de connaitre le total pour chaque marin.

Comme vous le voyez, la map est déclarée en tant que "HashMap<String, BigDecimal>" --> Je ne stocke dans la clé pas le marin mais uniquement un string (son matricule).

Je pense donc que cela est plus propre de déclarer cette Map en tant que HashMap<Marin, BigDecimal> ce qui permet d'avoir tous les éléments du marin à disposition.

Par contre, cela va-t-il changer quelquechose en charge mémoire de l'application (on stocke un objet "Marin" au lieu de stocker qu'un matricule) ou cela ne va-t-il rien changer si ce n'est que des références aux objets qui sont réellement stockées en mémoire?


Merci d'avance

[tchize_]

Tes Marins sont-ils déjà tous en mémoire en temps normal? Si oui, ça ne change rien à la charge mémoire. Sinon, ça forcera l'application a avoir tous les marins en mémoire.

Par contre, chose importante, la clé d'un Hashmap doit être immutable. Si tu opte donc pour la solution du Marin en clé,, ça veux dire que tu ne pourra plus modifier ton marin après. (Pour être plus précis, hashCode() ne peux plus changer, et equals doit rester cohérent avec hashcode).

Le numéro de matricule me semble donc, d'une manière général plus approprié.

[johannsan]

Merci pour la réponse.

Mes marins sont déjà en mémoire car ces "sommes" sont faite à partir de ma liste qui pour chaque élément de cette liste fait référence à un Marin.

Pour la notion d'immuable", je ne suis pas confronté au problème car ces map ne sont là que pour stocker un résultat à afficher dans plusieurs éditions et non pour modifier la clé.

Vous dites

Le numéro de matricule me semble donc, d'une manière général plus approprié.

Initialement, je n'avais que des HashMap<String, BigDecimal> (avec le matricule comme clé), mais mon dernier besoin (d'où ma question) est d'afficher un tableau (dans mes éditions) a partir de cette Map contenant le matricule, le nom/prénom du marin et le résultat.
Si je n'utile que HashMap<String, BigDecimal> et non HashMap<Marin, BigDecimal>, cela va me forcer en parcourant cette map d'aller rechercher les infos des marins à partir de chaque clé via un traitement supplémentaire.

Pour conclure, j'hésite donc :
- à garder des HashMap<String, BigDecimal> et des HashMap<Marin, BigDecimal> quand j'en ai besoin (dans mon cas présent)
ou
- à tout modifier en HashMap<Marin, BigDecimal> afin d'assurer une cohérence générale

Qu'en pensez vous?

[thelvin]

Pour la notion d'immuable", je ne suis pas confronté au problème car ces map ne sont là que pour stocker un résultat à afficher dans plusieurs éditions et non pour modifier la clé.

... Oui, c'est normal que la Map ne serve pas à modifier la clé, puisque la clé ne doit pas être modifiée et puis c'est tout.

La question n'est pas "tu ne dois pas utiliser cette Map pour modifier les clés" mais "tu ne dois pas modifier les clés, où que ce soit, pour quelque raison que ce soit, pendant que cette Map existe."
Et le mieux c'est "ces clés ne doivent pas pouvoir être modifiées quand que ce soit, par quoi que ce soit," car du coup on est sûr qu'on les modifiera pas.

C'est pour ça qu'on préfère les String : rien ne peut les modifier et puis c'est tout.
Pour ce qui est de retrouver le Marin correspondant à une id, ce n'est pas un "traitement supplémentaire." Il suffit d'une HashMap<String, Marin>.

[johannsan]

Je suis étonné car lorsque vous dites

Pour ce qui est de retrouver le Marin correspondant à une id, ce n'est pas un "traitement supplémentaire." Il suffit d'une HashMap<String, Marin>.

, c'est pour moi une étape supplémentaire.

En détaillant un peu mon traitement, cela donne :

J'ai une liste d'activité : chaque activité concerne un marin, et donc un montant de cotisation.

Je boucle sur cette liste d'Activité.
Pour chaque ligne (chaque activité), j'alimente mes map : Je vais prendre le cas où je mets dans la clé le Marin (et non que son matricule)

Code :

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

1
2
3
 
valeur = valeur sur ligne + valeur deja stocké dans la map pour ce marin;
totalMarinCotisationsNettes.put(activite.getMarin(), valeur)

Lors de mon édition :

Code :

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

1
2
3
4
5
6
7
8
9
for (Marin marin : totalMarinCotisationsNettes.keySet())
 		{
  			if(totalMarinCotisationsNettes.get(marin) < valeurDeComparaison)
  			{
  				affichage de marin.getMatricule()
  				affichage de marin.getNom()
  				affichage de la valeur totalMarinCotisationsNettes.get(marin)
  			}
  		}

Dans le cas où je met le matricule en clé lors de l'alimentation, mon édition sera de ce genre :

Code :

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

1
2
3
4
5
6
7
8
9
for (String matricule : totalMarinCotisationsNettes.keySet())
 		{
  			if(totalMarinCotisationsNettes.get(matricule) < valeurDeComparaison)
  			{
  				affichage de matricule
  				affichage du nom : --> obligé d''aller lire en base ou en map le marin à partir de son matricule alors que j''aurais pu avoir celui-ci directement en tant qu''objet
  				affichage de la valeur totalMarinCotisationsNettes.get(marin)
  			}
  		}

Dans tous les cas, le marin n'est pas modifiable dans mon application

[thelvin]

Dans tous les cas, le marin n'est pas modifiable dans mon application

Dans ce cas pourquoi pas.
Il est simplement d'usage d'utiliser des classes plus connues et dont on sait que c'est le cas et qu'elles ont des implémentations de hashCode() et equals() bien pensées.
Mais ça marche très bien aussi avec d'autres classes immutables, notamment quand on a pas besoin de faire des get(), ou que le hachage par défaut est suffisant, ou que hashCode() et equals() ont été bien faits aussi.

Je suis étonné car lorsque vous dites
, c'est pour moi une étape supplémentaire.

Une ligne courte, c'est quand même pas super gênant comme étape supplémentaire .

[johannsan]

Merci pour ces réponses