Как правильно использовать HashMap?

Я не уверен, что вы пытаетесь сделать, но поскольку в приведенном вами примере используются жестко закодированные строки для индексации данных, похоже, вы знаете, какие данные вы хотите сгруппировать. Если это так, то карта, вероятно, не лучший выбор. Лучшим подходом было бы создание класса из часто сгруппированных данных:

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

Это позволяет вашему клиентскому коду делать следующее:

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

Вместо этого:

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

Первый пример гораздо менее уязвим, потому что вы не индексируете данные с помощью строковых констант. Это также дает вам место для добавления поведения поверх ваших сгруппированных данных, что делает ваш код гораздо более объектно-ориентированным.

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

Конечно, вам все равно нужно быть осторожным, чтобы использовать правильный тип при извлечении элементов.

Вам необходимо использовать универсальные шаблоны, как показано ниже:

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

Использование HashMap<String, Object>, вероятно, лучшее, что вы можете сделать, если вы настаиваете на наличии разнородных значений на одной и той же карте — вам нужно будет преобразовать тех, чтобы сделать что-нибудь полезное при их извлечении (и как вы собираетесь чтобы знать, к какому типу их привести в...?), но, по крайней мере, вы будете типобезопасны в отношении ключей.

Вот другой подход:

Вспомогательный класс, содержащий карту и обеспечивающий ее различные представления:

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

}

Перед получением значения int вы должны проверить значение store.containsIntValue(intKey), а перед получением значения String вы должны проверить store.containsStringValue(stringKey). Таким образом, вы никогда не получите значения неправильного типа.

(Конечно, можно расширить для поддержки других типов)

Это простой код для использования hashmap. Там я буду использовать ключ как целое число и значение как строковый тип. Карта очень полезна, когда наша функциональность работает с парами ключ-значение. Ниже приведен простой пример использования hashmap. Я надеюсь, что это очень полезно для всех.

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


    }

}

Ссылка : создание и использование карты