Is it better to use Objects or integers as HashMap keys?
hash, hashmap, java, key, string
Solution
The first thing to get right should be correctness, not the efficiency: this code
HashMap<Integer, Object> hashes = new HashMap<Integer, Object>();
hashes.put(str.hashCode(), helloObject);
is incorrect (in addition to being inefficient *).
Recall that hash codes are not unique. The only requirement as per Java documentation is for hash codes of equal objects to be the same. However, objects with the same hash code are not necessarily equal. As the result, changing your hash map's key from `String` to `Integer` changes the semantics: two entirely different objects may be considered the same key absolutely arbitrarily, based on their hash code.
* In case you are curious why the above code snippet is inefficient, there is an autoboxing going on: `hashCode()` returns a primitive `int`, which is wrapped in a `java.lang.Integer` by the compiler. This often leads to creating an unwanted object in a situation where no additional object is created when you use a `String`.
Problem
How does hashing of objects work in java's HashMap? I was thinking if it is more efficient to use integers as keys compared to Strings or if it does not matter. If I have: ``` String str = "hello"; Object helloObject = new Object(); ``` What is better in case of String? Use integer key: ``` HashMap<Integer, Object> hashes = new HashMap<Integer, Object>(); hashes.put(str.hashCode(), helloObject); ``` or use String key? ``` HashMap<String, Object> hashes = new HashMap<String, Object>(); hashes.put(str, helloObject); ``` What is more efficient from point of inserting and what from point of searching?