Java Generics Type Avertissement de sécurité avec Hashmap récursif

Question

J'utilise une arborescence récursive de hashmaps, en particulier Hashmap map où Object est une référence à une autre Hashmap et ainsi de suite. Ce sera passé autour d'un algorithme récursif:

foo(String filename, Hashmap<String, Object> map) 
{ 
    //some stuff here 
    for (Entry<String, Object> entry : map.entrySet()) 
    { 
     //type warning that must be suppressed 
     foo(entry.getKey(), (HashMap<String, Object>)entry.getValue()); 
    } 
} 

Je sais que Object est de type Hashmap<String, Object> mais je suis irrité que je dois supprimer l'avertissement à l'aide @SuppressWarnings("unchecked").

Je serai satisfait d'une solution qui fait assert(/*entry.getValue() is of type HashMap<String, Object>*/) ou déclenche une exception quand ce n'est pas le cas. Je suis descendu le chemin des génériques pour la sécurité du type de compilation et si je supprime l'avertissement, alors il va à l'encontre du but.

Merci pour vos commentaires, KSB

Answer 1

Ceci est possible en utilisant une méthode générique avec une variable de type récursif. Essayez ce qui suit:

public <T extends Map<String, T>> void foo(String filename, T map) { 
    //some stuff here 
    for (Map.Entry<String, T> entry : map.entrySet()) { 
     foo(entry.getKey(), entry.getValue()); 
    } 
} 

Doit être compilé sans aucun avertissement. Cependant, si vous avez le contrôle de la carte, et pouvez substituer votre propre classe, il peut être plus lisible de faire un nœud de classe (cela ressemble à un arbre), que contient une carte à la place. Quelque chose comme:

public class Node { 
    private Map<String, Node> children; 

    ... 
    // accessor methods to retrieve children ... 
} 

Et ont foo prendre un Node comme second argument à la place. Juste une suggestion.

Answer 2

Vous pouvez utiliser à la place de cette classe HashMap:

public class RecursiveHashMap extends HashMap<String,RecursiveHashMap> 
{ 
} 

Answer 3

Votre structure de données a l'air de vouloir représenter des arbres de fichiers (noms de fichiers) avec elle. Je ne recommanderais pas de le faire avec HashMap comme type de nœud.

Je vous suggère d'utiliser le motif composite (voir wikipedia), le code simplifié:

abstract class Node 
{ 
    String filename; 
    Node(String filename) { this.filename = filename; } 
    abstract foo(); 
} 

class FileNode implements Node 
{ 
    FileNode(String filename) { super(filename); } 
    foo() { ... } 
} 

class DirectoryNode implements Node 
{ 
    Set<Node> children; 
    DirectoryNode(String filename, Set<Node> children) 
    { 
    super(filename); 
    this.children = children; 
    } 
    foo() 
    { 
    for (Node child : children) child.foo(); 
    } 
} 

Le HashMap que vous utilisez revient à l'ensemble apparaissant dans DirectoryNode.