Java Generics Type de sécurité avec avertissement hashmap récursive

Question

J'utilise un arbre récursif de hashmaps, en particulier la carte hashmap où l'objet 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 avec une solution qui ne soit un assert(/*entry.getValue() is of type HashMap<String, Object>*/) ou jette une exception quand il est pas. Je suis descendu la route pour Generics type sécurité et la compilation 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. Effectuez les opérations suivantes:

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());
    }
}

devrait compiler correctement sans aucun avertissement.

Cependant, si vous avez le contrôle de la carte, et peut remplacer votre propre classe, il pourrait être plus facile à lire pour faire un nœud de classe (cela ressemble à un arbre pour moi), que contient a carte à la place. Quelque chose comme:

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

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

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

Answer 2

Vous pouvez utiliser cette classe au lieu de HashMap:

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

Answer 3

Votre structure de données semble que vous voulez représenter les arbres de fichiers (noms de fichiers) avec elle. Je vous recommande de ne pas 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 vous utilisez revient à l'ensemble apparaissant dans DirectoryNode.