Wie verwende ich HashMap richtig?

Question

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

gibt mir die Warnung:

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

Answer 1

Ich bin mir nicht sicher, was Sie zu tun versuchen, aber da das Beispiel vorausgesetzt, Sie verwendet hartcodierte Strings indizieren die Daten, die sie, scheint zu wissen, welche Daten Sie zusammen gruppieren möchten. Wenn das der Fall ist, dann ist eine Map wahrscheinlich keine gute Wahl. aus den allgemein gruppierten Daten der bessere Ansatz wäre eine Klasse zu machen:

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

Diesen Ihr Client-Code erlaubt, dies zu tun:

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

Anstatt dies:

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

Das vorherige Beispiel ist viel weniger fragil, weil Sie Daten nicht mit String-Konstanten indizieren. Es bietet Ihnen auch die Möglichkeit, Verhalten zu Ihren gruppierten Daten hinzuzufügen, wodurch Ihr Code viel objektorientierter wird. Hier

Answer 2

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

Natürlich, werden Sie noch vorsichtig sein müssen, um die richtige Art zu verwenden, wenn Elemente zu extrahieren.

Answer 3

HashMap<String, Object> Verwendung ist wahrscheinlich das beste können Sie tun, wenn Sie auf mit heterogenen Werte in der gleichen Karte bestehen - Sie werden diejenigen werfen müssen, um zu tun, was nützlich, wenn man sie abrufen (und wie wollen Sie wissen, welchen Typ sie zu werfen zu ...?), aber zumindest werden Sie in Bezug auf die Schlüssel typsicher sein.

Answer 4

Sie müssen generics verwenden, wie unten dargestellt:

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

Answer 5

ist ein anderer Ansatz:

eine Hilfsklasse, die eine Karte enthält und bietet verschiedene Ansichten davon:

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

} 

Bevor Sie einen int-Wert abzurufen, würden Sie den Wert store.containsIntValue(intKey) überprüfen würde Bevor Sie einen String-Wert abrufen, überprüfen Sie store.containsStringValue(stringKey). Auf diese Weise würden Sie nie Werte des falschen Typs abrufen.

Answer 6

Dies ist einfacher Code zur Verwendung von hashmap

(anderen Arten zu unterstützen und kann natürlich verlängert werden). Dort verwende ich key als Integer und value als string type. Map ist sehr nützlich, wenn unsere Funktionalität mit Schlüssel- und Wertepaaren funktioniert. Unten ist ein einfaches Beispiel für die Verwendung von hashmap. Ich hoffe, es ist sehr nützlich für alle.

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


} 

}

Referenz: create and use of map