Is it better to use Objects or integers as HashMap keys?

Question

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?

You just need to make sure that HashKey Integer or String is unique. Searching is O(1) in `Big O Notation`. It goes straight to it based on the key. This O(1) is the main point of using a HashMap. — Peter_James, Nov 19 '13 at 14:17
I do wonder why none of the answers yet have mentioned the `Big O Notation` about searching a HashMap yet. — Peter_James, Nov 19 '13 at 14:21
@user2860598 I wonder why you mentioned it with such a faulty and confusing example. "HashKey Integer or String is unique". "It goes straight to it based on the key". I would downvote your comments if it were possible. — Kayaman, Nov 19 '13 at 14:28

Sergey Kalinichenko · Accepted Answer · 2013-11-19T15:10:04.113

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.

René Link · Answer 2 · 2013-11-19T16:23:53.747

Keep in mind that two strings with the same hash code might not be equal.

If you use the string's hashCode instead of the string itself then two different strings can produce the same map's key and that might result in a strange behavior.

Try this code and see what I mean.

Map<Integer, String> map = new HashMap<Integer, String>();
map.put("FB".hashCode(), "FB");
map.put("Ea".hashCode(), "Ea");

System.out.println(map.get("FB".hashCode()));

will output

Ea

because

"FB".hashCode() == "Ea".hashCode() // is true

Thus you should better use the String as the key.

score 4 · Answer 3 · edited May 23 '17 at 10:30

You shouldn't care about the efficiency of this. What you need to care about is the use case you have. Use Integers and Strings where they are appropriate.

If you wish to understand how it works internally look at What issues should be considered when overriding equals and hashCode in Java?. It is basically all about the implementation of hashCode() and equals(). Please note that a key must also be immutable.

score 0 · Answer 4 · answered Nov 19 '13 at 14:19

It depends. If you know that you will be only using it for Integers then just use Integer. If you plan on filling with all sorts of data/objects then use Object and probably some sort of a value resolver for it.

tl;dr: Is it going to be filled with only Integers? --> Define it as an Integer map, otherwise use Object.

Is it better to use Objects or integers as HashMap keys?

4 Answers4