Come utilizzare correttamente HashMap?

Question

HashMap savedStuff = new HashMap(); 
savedStuff.put("symbol", this.symbol); //this is a string 
savedStuff.put("index", this.index); //this is an int 

mi dà l'avvertimento:

HashMap is a raw type. References to generic type HashMap<K,V> should be parameterized 

Answer 1

Non sono sicuro di quello che stai cercando di fare, ma dal momento che l'esempio che hai fornito utilizza stringhe hard-coded per indicizzare i dati, sembra che tu sappia quali dati vuoi raggruppare. Se questo è il caso, quindi una mappa non è probabilmente una buona scelta. L'approccio migliore sarebbe quella di fare una classe di dati comunemente raggruppati:

public class SavedStuff { 
    private int index; 
    private String symbol; 

    public SavedStuff(int index, String symbol) { 
    this.index = index; 
    this.symbol = symbol; 
    } 

    public int getIndex() { 
    return index; 
    } 

    public String getSymbol() { 
    return symbol; 
    } 
} 

Questo consente al codice client per fare questo:

SavedStuff savedStuff = ... 
String symbol = savedStuff.getSymbol(); 

Invece di questo:

Map<String, Object> savedStuff = ... 
String symbol = savedStuff.get("symbol"); 

Il precedente esempio è molto meno fragile perché non stai indicizzando i dati con costanti String. Ti dà anche un posto dove aggiungere comportamenti in cima ai tuoi dati raggruppati, il che rende il tuo codice molto più orientato agli oggetti.

Answer 2

HashMap<String, Object> savedStuff = new HashMap<String, Object>(); 

Naturalmente, si dovrà ancora fare attenzione a utilizzare il giusto tipo durante l'estrazione di elementi.

Answer 3

Utilizzando HashMap<String, Object> è probabilmente il migliore che puoi fare se ti ostini a avere valori eterogenei nella stessa mappa - sarà necessario lanciare quelli di fare qualcosa di utile quando li si recupera (e come hai intenzione di sapete che tipo lanciare loro da a ...?), ma almeno sarete dattiloscritti rispetto alle chiavi .

Answer 4

è necessario utilizzare generics come illustrato di seguito:

Map<String, Object> savedStuff = new HashMap<String, Object>(); 

Answer 5

Qui è un approccio diverso:

classe

un aiutante che contiene una mappa e offre visuali diverse:

public class ValueStore { 


    /** 
    * Inner map to store values. 
    */ 
    private final Map<String,Object> inner = new HashMap<String,Object>(); 

    /** 
    * Returns true if the Value store contains a numeric value for this key. 
    */ 
    public boolean containsIntValue(final String key){ 
     return this.inner.get(key) instanceof Integer; 
    } 


    /** 
    * Returns true if the Value store contains a String value for this key. 
    */ 
    public boolean containsStringValue(final String key){ 
     return this.inner.get(key) instanceof String; 
    } 

    /** 
    * Returns the numeric value associated with this key. 
    * @return -1 if no such value exists 
    */ 
    public int getAsInt(final String key){ 
     final Object retrieved = this.inner.get(key); 
     return retrieved instanceof Integer ? ((Integer) retrieved).intValue() : -1; 
    } 


    /** 
    * Returns the String value associated with this key. 
    * @return null if no such value exists 
    */ 
    public String getAsString(final String key){ 
     final Object retrieved = this.inner.get(key); 
     return retrieved instanceof String ? (String) retrieved : null; 
    } 

    /** 
    * Store a string value. 
    */ 
    public void putAsInt(final String key, final int value){ 
     this.inner.put(key, Integer.valueOf(value)); 
    } 


    /** 
    * Store an int value. 
    */ 
    public void putAsString(final String key, final String value){ 
     this.inner.put(key, value); 
    } 

    /** 
    * Main method for testing. 
    */ 
    public static void main(final String[] args) { 
     final ValueStore store = new ValueStore(); 
     final String intKey = "int1"; 
     final String stringKey = "string1"; 
     final int intValue = 123; 
     final String stringValue = "str"; 

     store.putAsInt(intKey, intValue); 
     store.putAsString(stringKey, stringValue); 

     assertTrue(store.containsIntValue(intKey)); 
     assertTrue(store.containsStringValue(stringKey)); 
     assertFalse(store.containsIntValue(stringKey)); 
     assertFalse(store.containsStringValue(intKey)); 
     assertEquals(123, store.getAsInt(intKey)); 
     assertEquals(stringValue, store.getAsString(stringKey)); 
     assertNull(store.getAsString(intKey)); 
     assertEquals(-1, store.getAsInt(stringKey)); 
    } 

} 

Prima si dovrebbe recuperare un valore int, si dovrebbe controllare il valore di store.containsIntValue(intKey) e prima di recuperare un valore di stringa, dovresti controllare store.containsStringValue(stringKey). In questo modo non recupereresti mai i valori del tipo sbagliato.

(può ovviamente essere esteso per supportare altre tipologie pure)

Answer 6

Si tratta di semplice codice per l'utilizzo del HashMap. Lì userò la chiave come numero intero e valore come tipo di stringa. La mappa è molto utile quando la nostra funzionalità funziona su coppie di chiavi e valori. Di seguito è riportato un semplice esempio di utilizzo di hashmap. Spero sia molto utile per tutti.

public class CreateHashMap {

public static void main(String[] args) { 

Map<Integer,String> map = new HashMap<Integer,String>(); 

/* 
* Associates the specified value with the specified key in 
    this map (optional operation). If the map previously 
    contained a mapping for the key, the old value is 
    replaced by the specified value 
*/ 
    map.put(1,"ankush"); 
    map.put(2, "amit"); 
    map.put(3,"shivam"); 
    map.put(4,"ankit"); 
    map.put(5, "yogesh"); 

    //print hashmap 
    System.out.println("HashMap = "+map); 


} 

}

Riferimento: create and use of map