Comment utiliser correctement HashMap?

Je ne suis pas sûr de ce que vous essayez de faire, mais depuis que l'exemple que vous avez fourni utilise des chaînes codées en dur pour indexer les données, il semble que vous savez quelles sont les données que 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 de l'communément regroupées donné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 de ceci:

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

L'ancien exemple est beaucoup moins fragile parce que vous n'êtes pas de l'indexation des données avec des constantes de Chaîne. Il vous donne aussi une place pour ajouter un comportement sur le dessus de vos données groupées, ce qui rend votre code plus orientée objet.

Vous devez utiliser les génériques comme indiqué ci-dessous :

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

Ici est une Approche différente:

Une classe d'assistance qui contient une carte et offre différents points de vue:

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 de vous permettrait de récupérer une valeur int, vous vérifiez la valeur de store.containsIntValue(intKey) et avant de récupérer une valeur de Chaîne, vous devez cocher store.containsStringValue(stringKey). De cette façon, vous ne jamais récupérer des valeurs de type incorrect.

(Peut évidemment être étendu pour prendre en charge d'autres types d')