CODEWITHSUNDEEP
javahashmapkey
yoto
yoto

Reputation: 21

Setting key type in HashMap, how?

hi I want to create a HashMap (java) that stores Expression, a little object i've created. How do I choose what type of key to use? What's the difference for me between integer and String? I guess i just don't fully understand the idea behind HashMap so i'm not sure what keys to use. Thanks!

Upvotes: 2

Views: 8591

Answers (4)

Jack
Jack

Reputation: 133609

Java HashMap relies on two things:

  • the hashCode() method, which returns an integer that is generated from the key and used inside the map
  • the equals(..) method, which should be consistent to the hash calculated, this means that if two keys has the same hashcode than it is desiderable that they are the same element.

The specific requirements, taken from Java API doc are the following:

  • Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
  • If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
  • It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

If you don't provide any kind of specific implementation, then the memory reference of the object is used as the hashcode. This is usually good in most situations but if you have for example:

Expression e1 = new Expression(2,4,PLUS);
Expression e2 = new Expression(2,4,PLUS);

(I don't actually know what you need to place inside your hashmap so I'm just guessing)

Then, since they are two different object although with same parameters, they will have different hashcodes. This could be or not be a problem for your specific situation.

In case it isn't just use the hasmap without caring about these details, if it is you will need to provide a better way to compute the hashcode and equality of your Expression class.

You could do it in a recursive way (by computing the hashcode as a result of the hashcodes of children) or in a naive way (maybe computing the hashcode over a toString() representation).

Finally, if you are planning to use just simple types as keys (like you said integers or strings) just don't worry, there's no difference. In both cases two different items will have the same hashcode. Some examples:

assert(new String("hello").hashCode() == new String("hello").hashCode());
int x = 123;
assert(new Integer(x).hashCode() == new Integer(123).hashCode());

Mind that the example with strings is not true in general, like I explained you before, it is just because the hashcode method of strings computes the value according to the content of the string itself.

Upvotes: 5

corsiKa
corsiKa

Reputation: 82589

The key is what you use to identify objects. You might have a situation where you want to identify numbers by their name.

Map<String,Integer> numbersByName = new HashMap<String,Integer>();

numbersByName.put("one",Integer.valueOf(1));
numbersByName.put("two",Integer.valueOf(2));
numbersByName.put("three",Integer.valueOf(3));
... etc

Then later you can get them out by doing

Integer three = numbersByName.get("three");

Or you might have a need to go the other way. If you know you're going to have integer values, and want the names, you can map integers to strings

Map<String,Integer> numbersByValue = new HashMap<String,Integer>();

numbersByValue.put(Integer.valueOf(1),"one");
numbersByValue.put(Integer.valueOf(2),"two");
numbersByValue.put(Integer.valueOf(3),"three");
... etc

And get it out

String three = numbersByValue.get(Integer.valueOf(3));

Upvotes: 1

Ingo
Ingo

Reputation: 36349

If you do not want to look up the expressions, why do you want them to store in a map? But if you want to, then the key is that item you use for lookup.

Upvotes: 0

Christopher Armstrong
Christopher Armstrong

Reputation: 7953

Keys and their associated values are both objects. When you get something from a HashMap, you have to cast it to the actual type of object it represents (we can do this because all objects in Java inherit the Object class). So, if your keys are strings and your values are Integers, you would do something like:

Integer myValue = (Integer)myMap.get("myKey");

However, you can use Java generics to tell the compiler that you're only going to be using Strings and Integers:

HashMap<String,Integer> myMap = new HashMap<String,Integer>();

See http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html for more details on HashMap.

Upvotes: 0

Related Questions