Comment utiliser correctement HashMap?

Question

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

me donne l'avertissement:

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

Answer 1

Je ne sais pas ce que vous essayez de faire, mais comme l'exemple que vous avez fourni utilise des chaînes codées en dur pour indexer les données, semble que vous savez quelles données vous voulez regrouper. Si c'est le cas, alors une carte n'est probablement pas un bon choix. La meilleure approche serait de faire une classe sur les données généralement groupées:

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

Cela permet à votre code client pour ce faire:

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

Plutôt que ceci:

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

L'exemple précédent est beaucoup moins fragile car vous n'indexez pas les données avec des constantes String. Il vous donne également un endroit pour ajouter un comportement au-dessus de vos données groupées, ce qui rend votre code beaucoup plus orienté objet.

Answer 2

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

Bien sûr, vous devrez toujours faire attention à utiliser le bon type lors de l'extraction des éléments.

Answer 3

L'utilisation HashMap<String, Object> est probablement le meilleur que vous pouvez faire si vous insistez pour avoir des valeurs hétérogènes dans la même carte - vous aurez besoin de jeter les faire quelque chose d'utile lorsque vous les récupérer (et comment allez-vous savez-vous quel type pour les lancer à ...?), mais au moins vous serez de typeafe par rapport aux touches.

Answer 4

Vous devez utiliser generics comme indiqué ci-dessous:

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

Answer 5

Voici une autre approche:

Une classe Helper qui contient une carte et fournit des vues différentes de celui-ci:

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

} 

Avant récupérerez une valeur int, vous vérifiez la valeur de store.containsIntValue(intKey) et avant de récupérer une valeur String, vous devez vérifier store.containsStringValue(stringKey). De cette façon, vous ne récupérerez jamais les valeurs du mauvais type.

(peut bien sûr être étendu pour supporter d'autres types) ainsi

Answer 6

Ce code simple est pour l'utilisation de hashmap. Là, j'utiliserai la clé comme entier et la valeur comme type de chaîne. La carte est très utile lorsque notre fonctionnalité fonctionne sur des paires de clés et de valeurs. Voici un exemple simple d'utilisation de hashmap. J'espère que c'est très utile pour tous.

CreateHashMap public class {

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


} 

}

Référence: create and use of map