Pour stocker un int comme "valeur" dans un couple clef/valeur d'un hash,
je convertis le plus souvent le int en Integer (ou le double en Double,
etc.), de façon à faire :
hash.put(key, new Integer(value));
évidemment la récupération du int est couteux, (il faut passer par
intValue()).
Integer valueInteger = (Integer) hash.get(key);
int value = valueInteger.intValue();
Je lis dans du code une autre manière de faire, en utilisant un tableau :
int[] valueArray = new int[1];
valueArray[0] = value;
hash.put(key, value);
et pour récupérer le int d'origine :
int valueArray = (int[]) hash.get(key);
int value = valueArray[0];
Là aussi il faut une manip, après avoir appeler get, pour récupérer la
valeur voulue : demander l'indice zéro. Quelle est la plus orthodoxe et la
plus efficace entre ces deux façon de faire -- à moins qu'il y en ait une
autre ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Xavier Tarrago
La façon habituelle est la première. Je ne vois pas l'intérêt de la deuxième. Il faudrait que l'allocation d'un tableau de int int[1] soit moins coûteuse que celle d'un Integer. Je ne sais pas si c'est le cas.
Si la performance est un problème, je sais qu'il existe des framework de collections en open source avec des implémentations de Hashmap de type natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du coté Apache/Jakarta.
"SL" a écrit dans le message de news:
Bonjour,
Pour stocker un int comme "valeur" dans un couple clef/valeur d'un hash, je convertis le plus souvent le int en Integer (ou le double en Double, etc.), de façon à faire :
hash.put(key, new Integer(value));
évidemment la récupération du int est couteux, (il faut passer par intValue()).
Integer valueInteger = (Integer) hash.get(key); int value = valueInteger.intValue();
Je lis dans du code une autre manière de faire, en utilisant un tableau :
int[] valueArray = new int[1]; valueArray[0] = value; hash.put(key, value);
et pour récupérer le int d'origine :
int valueArray = (int[]) hash.get(key); int value = valueArray[0];
Là aussi il faut une manip, après avoir appeler get, pour récupérer la valeur voulue : demander l'indice zéro. Quelle est la plus orthodoxe et la plus efficace entre ces deux façon de faire -- à moins qu'il y en ait une autre ?
Bien à vous, SL
La façon habituelle est la première. Je ne vois pas l'intérêt de la
deuxième. Il faudrait que l'allocation d'un tableau de int int[1] soit moins
coûteuse que celle d'un Integer. Je ne sais pas si c'est le cas.
Si la performance est un problème, je sais qu'il existe des framework de
collections en open source avec des implémentations de Hashmap de type
natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du coté
Apache/Jakarta.
"SL" <spam@wanadoo.fr> a écrit dans le message de
news:opst3lumqpgzjzaj@sylvain...
Bonjour,
Pour stocker un int comme "valeur" dans un couple clef/valeur d'un hash,
je convertis le plus souvent le int en Integer (ou le double en Double,
etc.), de façon à faire :
hash.put(key, new Integer(value));
évidemment la récupération du int est couteux, (il faut passer par
intValue()).
Integer valueInteger = (Integer) hash.get(key);
int value = valueInteger.intValue();
Je lis dans du code une autre manière de faire, en utilisant un tableau :
int[] valueArray = new int[1];
valueArray[0] = value;
hash.put(key, value);
et pour récupérer le int d'origine :
int valueArray = (int[]) hash.get(key);
int value = valueArray[0];
Là aussi il faut une manip, après avoir appeler get, pour récupérer la
valeur voulue : demander l'indice zéro. Quelle est la plus orthodoxe et la
plus efficace entre ces deux façon de faire -- à moins qu'il y en ait une
autre ?
La façon habituelle est la première. Je ne vois pas l'intérêt de la deuxième. Il faudrait que l'allocation d'un tableau de int int[1] soit moins coûteuse que celle d'un Integer. Je ne sais pas si c'est le cas.
Si la performance est un problème, je sais qu'il existe des framework de collections en open source avec des implémentations de Hashmap de type natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du coté Apache/Jakarta.
"SL" a écrit dans le message de news:
Bonjour,
Pour stocker un int comme "valeur" dans un couple clef/valeur d'un hash, je convertis le plus souvent le int en Integer (ou le double en Double, etc.), de façon à faire :
hash.put(key, new Integer(value));
évidemment la récupération du int est couteux, (il faut passer par intValue()).
Integer valueInteger = (Integer) hash.get(key); int value = valueInteger.intValue();
Je lis dans du code une autre manière de faire, en utilisant un tableau :
int[] valueArray = new int[1]; valueArray[0] = value; hash.put(key, value);
et pour récupérer le int d'origine :
int valueArray = (int[]) hash.get(key); int value = valueArray[0];
Là aussi il faut une manip, après avoir appeler get, pour récupérer la valeur voulue : demander l'indice zéro. Quelle est la plus orthodoxe et la plus efficace entre ces deux façon de faire -- à moins qu'il y en ait une autre ?
Bien à vous, SL
SL
Si la performance est un problème, je sais qu'il existe des framework de collections en open source avec des implémentations de Hashmap de type natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du coté Apache/Jakarta.
Oui, si ça vous intéresse j'ai trouvé plusieurs choses : - Commons primitives de Jakarta (http://jakarta.apache.org/commons/primitives/) (mais concentré sur les Lists et les Iterators) - chez Colt, il y a des Map {int, long, double}->Object (mais pas de Object->{int, etc.}), utilisés pour leurs matrices creuses : http://hoschek.home.cern.ch/hoschek/colt/V1.0.3/doc/cern/colt/map/package-summary.html - PCJ qui a l'air le plus complet : http://pcj.sourceforge.net/, notamment pour les Map il y a une collection impressionnantes pour mapper toutes les paires de primitives ou de Objet/primitives possibles. - GNU Trove http://trove4j.sourceforge.net/ qui offre des objets du même type.
Par ailleurs il y a un benchmark entre ces différentes collections ici : http://blogs.codehaus.org/people/mproctor/archives/000890_primitive_map_implementation_and_benchmark_comparisons.html
où l'auteur propose une implementation alternative (sur laquelle je serais curieux d'avoir des avis d'ailleurs, je ne me suis pas encore fait une idée).
Bien à vous, slv
Si la performance est un problème, je sais qu'il existe des framework de
collections en open source avec des implémentations de Hashmap de type
natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du
coté
Apache/Jakarta.
Oui, si ça vous intéresse j'ai trouvé plusieurs choses :
- Commons primitives de Jakarta
(http://jakarta.apache.org/commons/primitives/) (mais concentré sur les
Lists et les Iterators)
- chez Colt, il y a des Map {int, long, double}->Object (mais pas de
Object->{int, etc.}), utilisés pour leurs matrices creuses :
http://hoschek.home.cern.ch/hoschek/colt/V1.0.3/doc/cern/colt/map/package-summary.html
- PCJ qui a l'air le plus complet : http://pcj.sourceforge.net/, notamment
pour les Map il y a une collection impressionnantes pour mapper toutes les
paires de primitives ou de Objet/primitives possibles.
- GNU Trove http://trove4j.sourceforge.net/ qui offre des objets du même
type.
Par ailleurs il y a un benchmark entre ces différentes collections ici :
http://blogs.codehaus.org/people/mproctor/archives/000890_primitive_map_implementation_and_benchmark_comparisons.html
où l'auteur propose une implementation alternative (sur laquelle je serais
curieux d'avoir des avis d'ailleurs, je ne me suis pas encore fait une
idée).
Si la performance est un problème, je sais qu'il existe des framework de collections en open source avec des implémentations de Hashmap de type natif. Malheureusement, je n'ai pu retouver le pointeur. Peut-être du coté Apache/Jakarta.
Oui, si ça vous intéresse j'ai trouvé plusieurs choses : - Commons primitives de Jakarta (http://jakarta.apache.org/commons/primitives/) (mais concentré sur les Lists et les Iterators) - chez Colt, il y a des Map {int, long, double}->Object (mais pas de Object->{int, etc.}), utilisés pour leurs matrices creuses : http://hoschek.home.cern.ch/hoschek/colt/V1.0.3/doc/cern/colt/map/package-summary.html - PCJ qui a l'air le plus complet : http://pcj.sourceforge.net/, notamment pour les Map il y a une collection impressionnantes pour mapper toutes les paires de primitives ou de Objet/primitives possibles. - GNU Trove http://trove4j.sourceforge.net/ qui offre des objets du même type.
Par ailleurs il y a un benchmark entre ces différentes collections ici : http://blogs.codehaus.org/people/mproctor/archives/000890_primitive_map_implementation_and_benchmark_comparisons.html
où l'auteur propose une implementation alternative (sur laquelle je serais curieux d'avoir des avis d'ailleurs, je ne me suis pas encore fait une idée).
