je lis des données d'un fichier texte et je veux stocker HashMap dans un autre HashMap.
HashMap<string,HashMap<string,value>>
comment stocker des données et les récupérer? tout exemple de code sera apprécié ... merci
Exemple:
Créer et remplir les cartes
Map<String, Map<String, Value>> outerMap = new HashMap<String, HashMap<String, Value>>();
Map<String, Value> innerMap = new HashMap<String, Value>();
innerMap.put("innerKey", new Value());
Stocker une carte
outerMap.put("key", innerMap);
Récupérer une carte et ses valeurs
Map<String, Value> map = outerMap.get("key");
Value value = map.get("innerKey");
Création de deux tables de hachage simples: InnerMap et OuterMap
HashMap<String, HashMap<String, String>> outerMap = new HashMap<String, HashMap<String,String>>();
HashMap<String, String> innerMap = new HashMap<String, String>();
Remplir les HashMaps
innerMap.put("InnerKey", "InnerValue");
outerMap.put("OuterKey", innerMap);
Récupérer les valeurs de HashMaps
String value = ((HashMap<String, String>)outerMap.get("OuterKey")).get("InnerKey").toString();
System.out.println("Retreived value is : " + value);
Vous obtenez quelque chose qui ressemble à un HashMap 2 dimensions, pour ainsi dire. Ce qui signifie que vous avez besoin de 2 String pour stocker une valeur et pour en récupérer une.
Vous pouvez, par exemple, écrire une classe pour envelopper cette complexité, comme ceci (code non testé):
public class HashMap2D<T> {
private HashMap<String,HashMap<String,T>> outerMap;
public HashMap2D() {
outerMap = new HashMap<String,HashMap<String,T>>();
}
public void addElement(String key1, String key2, T value) {
innerMap=outerMap.get(key1);
if (innerMap==null) {
innerMap = new HashMap<String,T>();
outerMap.put(key1,innerMap);
}
innerMap.put(key2,value);
}
public T getElement(String key1, String key2) {
Hashmap innerMap = outerMap.get(key1);
if (innerMap==null) {
return null;
}
return innerMap.get(key2);
}
}
Si vous voulez que les méthodes traitent plus d'une donnée à la fois, c'est plus compliqué, mais suit les mêmes principes.
Cela résoudra le même problème en utilisant une carte (bien que cela ne réponde pas directement à votre question) en aplatissant deux cartes imbriquées en une seule grande carte, à l'aide d'une double clé.
public class Key2D{
private final String outer;
private final String inner;
public Key2D(String outer, String inner){
this.outer = outer;
this.inner = inner;
}
//include default implementations for
//Object.equals(Object) and Object.hashCode()
//Tip: If you're using Eclipse it can generate
//them for you.
}
Ensuite, créez simplement une carte avec une double clé:
Map<Key2D, Value> map = new HashMap<Key2D, Value>();
map.put(new Key2D("outerKey", "innerKey"), "Value");
map.get(new Key2D("outerKey", "innerKey")); // yields "Value"
Cela donne une solution plus courte. Les performances sont probablement les mêmes. Les performances de la mémoire sont probablement légèrement meilleures (deviner, cependant).
HashMap dans HashMap posera des problèmes de lisibilité, en particulier lorsqu'il dépasse deux niveaux. Je suppose que lorsque vous lisez des données à partir d'un fichier texte, vous souhaitez classer les entrées à partir de lignes et de colonnes, qui doivent être similaires aux catégories multiniveaux ou à celles d'une catégorie. Si vous pouvez publier les exemples de données et votre intention, je pourrais proposer un exemple de classe personnalisée.
public class Category {
private List<Category> subCategories;
private List<Item> items;
}
La structure de données ci-dessus vous aidera à résoudre tous les niveaux d'imbrication lors de la catégorisation des données. Cet exemple est spécifique à la classification des articles d'un magasin.