[Collections] - Hash de Hash - Méthode plus simple

Version imprimable

Bonjour à tous,
Et au passage bonne fêtes de fin d'années à tous.

Je recherche un moyen plus simplde de faire un hash de hash.
Voilà un exemple de structure que j'aimerai obtenir :
Un hash dans lequel chaque valeur est aussi un hash.

Code:

1
2
 
{shipping={colissimo=500, chronopost=500}, brand={xx=1000},  payment={CHEQUE=750, ESPECE=750, CB=750}}

J'ai un bout de code qui me permet d'obtenit le hash de hash ci-dessus, mais je ne suis vraiment pas satisfait des performances.
est-ce qu'il existerait une méthode plus simple et plus performante

Code:

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
 
	    int maxDoc = Math.min(hits.length(), 1000);
	    int i ;
	    start = new Date().getTime();
 
            // cette Map me sert à construire le Hash "interne"
	    Map map = new HashMap();
           // Ma structure finale Hash de Hash
	    Map complexMap = new HashMap();
 
	    Integer ONE = new Integer(1);
 
	    for (i = 0; i < maxDoc; i++) {
	      Document doc = hits.doc(i);	      
	      for(Enumeration fields = doc.fields(); fields.hasMoreElements();) {
		      Field field = (Field)fields.nextElement();                  
		      String name = field.name();
 
		      // Ici je récupère la map correspondant à la clé courante
                      map = (Map)complexMap.get(name);
		      if (map == null) {
		           map = new HashMap();
		      }
	    	  String [] keys = doc.getValues(name);
		      if (keys != null) {
			      for (int j = 0; j < keys.length; j++) {
					Integer frequency = (Integer)map.get(keys[j]);
					if (frequency == null) {
						frequency = ONE;
					} else {
						int value = frequency.intValue();
						frequency = new Integer(value + 1);
					}
				      // Je met à jour la fréquence de la clé courante
                                      map.put(keys[j], frequency);
 
                                      // Je met à jour mon hash de hash
				      complexMap.put(name, map);
			      }
		      }	    	  
	      }

27/12/2005, 16h35
billou77

purée, ca a l'air compliqué ton code
c'est mal indenté

quelles sont les données en entrée ? et en sortie ?

avant meme d'essayer de comprendre ton code :

ce qui fait chuter les perfs, en general (pour ne citer qu'eux) :
- les cast
- les boucles de i=0 à i=x : les boucles à l'envers (i=x à i=0) sont plus rapides
- l'utilisation de table de hachage !
28/12/2005, 16h10
spidetra

Citation:

Envoyé par billou77

purée, ca a l'air compliqué ton code
c'est mal indenté

J'ai mis en l'air l'indentantion en ajoutant des commentaires après mon copier-coller. désolé !

Citation:

Envoyé par billou77

quelles sont les données en entrée ? et en sortie ?

En entrée j'ai un Hits Lucene. cad un ensemble de documents correspond a une query.
En sortie : Je voudrais un hash de hash. La structure complexMap.
dans ce complexMap, je met l'ensemble des valeurs des fields des documents, ainsi que leurs fréquences.

Citation:

Envoyé par billou77

- l'utilisation de table de hachage !

Qu'est ce que tu entend par table de hachage ?
les structures HashTable ou les structures HashMap.
J'utilise les HashMap justement parce que je pensais que c'était des structures performantes.

Merci pour l'aide.

J'ai repris le code en mettant les commentaires directement dans Eclipse.
L'indentantion a l'air meilleure.
J'ai rajouté un peu plus de commentaires.

Code:

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
 
	    // Mes deux structures de Hash
	    // La map pour le hash interne
	    map = new HashMap();
	    // La structure complexe : Le Hash De Hash
	    complexMap = new HashMap();
 
	    // Parcours l'ensemble des documents du hits ( Lucene )
	    for (i = 0; i < maxDoc; i++) {
	    	Document doc = hits.doc(i);	      
 
	    	// parcours l'ensemble des field du documents courant
	    	for(Enumeration fields = doc.fields(); fields.hasMoreElements();) {
	    		Field field = (Field)fields.nextElement();
	    		String name = field.name();
 
	    		// récupére la map interne
	    		// on crée une nvlle ref si elle est nulle
	    		map = (Map)complexMap.get(name);
	    		if (map == null) {
	    			map = new HashMap();
	    		}
 
	    		String [] keys = doc.getValues(name);
	    		// teste l'existence de keys
	    		if (keys != null && !name.equals("price")) {
 
	    			// Parcours du tableau keys
	    			// Recherche des keys[j] dans la map interne
	    			for (int j = 0; j < keys.length; j++) {
	    				Integer frequency = (Integer)map.get(keys[j]);
 
 
	    				// Mise à jour des frequences
	    				if (frequency == null) {
	    					frequency = ONE;
	    				} else {
	    					int value = frequency.intValue();
	    					frequency = new Integer(value + 1);
	    				} // Enf If Frequency
 
 
	    				// Mise à jour de la map Interne
	    				map.put(keys[j], frequency);
	    				// Mise à jour de la structure complexMap
	    				complexMap.put(name, map);	    				
	    			} // Enf For Strinf [] keys
 
	    		} // End If Keys
 
	    	} // End For Enumeration
 
	    } // End For maxDocs

28/12/2005, 16h35
billou77

le code indenté ? :o super je vais pouvoir me pencher sur ton cas :o))))
28/12/2005, 16h38
spidetra

Citation:

Envoyé par billou77

le code indenté ? :o super je vais pouvoir me pencher sur ton cas :o))))

merci bc :D
30/12/2005, 10h33
orest

Salut,
un hashMap qui en contient un autre peut en effet être un bon moyen de stocker et acceder à des infos de manière efficace et clair. Je te conseille de faire les méthodes suivantes:
(il me semble que objet est tj un int dans ton cas, mais pour montrer le principe je reste générique)

//stockage de l'objet
public Object putObject(String groupId, String objectId, Object objet)

//récupération de l'objet
public Object getObject(String groupId, String objectId)

//retire tous les objets de groupId
public Object removeObjects(String groupId)

//retire un objet précis
public Object removeObject(String groupId, String objectId)

le plus simple à l'intérieur de ces méthodes sera de faire des "création si c'est nécessaire",
c-a-d rergarder si le Map existe, si c'est pas le cas la créer.
ex.:
if(!stockage.containsKey(groupId))
stockage.put(groupId, new HashMap());
30/12/2005, 12h07
spidetra

merci.
Les accés d'un Hash de Hash sont très rapide, mais il me semble que c'est la construction de la structure qui est gourmande en temps.
Je ne suis pas sur que ce soit le meilleur choix de structure dans mon cas.

Je suis en train de regarder du côté de Lucène si je peux trouver une méthode plus rapide.
Mon pb c'est que la requête que je fais sur l'index Lucène est 2 à 3 fois plus rapide que la construction de mon Hash de Hash.
Je passe donc d'une requête dont le temp d'éxécution serait de quelques dixième de secondes à un temps total de traitement de l'ordre de la seconde.