Java Generics tipo di sicurezza di avvertimento con HashMap ricorsiva

Question

Io sto usando un albero ricorsiva di HashMaps, specificamente mappa HashMap in cui oggetto è un riferimento a un altro HashMap e così via. Questo sarà passata intorno ad un algoritmo ricorsivo:

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

So per certo Object è di tipo Hashmap<String, Object>, ma sono irritato che devo eliminare l'avviso utilizzando @SuppressWarnings("unchecked").

sarò soddisfatto con una soluzione che fa o un assert(/*entry.getValue() is of type HashMap<String, Object>*/) o genera un'eccezione quando non lo è. Sono andato giù il percorso Generics per la sicurezza tipo di compilazione e se eliminare l'avviso poi sconfigge lo scopo.

Grazie per i vostri commenti, KSB

Answer 1

Ciò è possibile utilizzando un metodo generico con una variabile di tipo ricorsivo. Provare quanto segue:

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

Dovrebbe compilare bene senza alcun avviso.

Tuttavia, se si ha il controllo della mappa, e può sostituire la propria classe, potrebbe essere più leggibile per fare un nodo di classe (questo appare come un albero per me), che contiene un Mappa invece. Qualcosa di simile:

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

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

E hanno foo prendere un Node come secondo argomento, invece. Solo un suggerimento.

Answer 2

È possibile utilizzare questa classe invece di HashMap:

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

Answer 3

Il tuo struttura dati appare come si vuole rappresentare una serie di files (nomi di file) con esso. Io non vi consiglio di farlo con HashMap come il tipo di nodo.

Io suggerirei di usare il composite (vedi Wikipedia), il codice semplificato:

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

Il HashMap si stesse utilizzando riduce al Set che appaiono nelle DirectoryNode.