Reputation: 5141
I have Map<Date, String
. I have two Date objects a, b
that are equal. I put a string value to the map associated with key a
. Then I try to get map value associated with keys a
and b
but only a
returns value that I've put. Is it possible to get my value with b
key. I know this is possible when keys are simple strings. Why this doesn't work with other type of objects?
public class Main {
public static void main(String[] args) {
Map<Date, String> map = new HashMap<Date, String>();
Date a = new Date(20131105);
Date b = new Date(20131105);
map.put(a, "sweet");
System.out.println(map.get(a));
System.out.println(map.get(b));
}
static class Date {
private int ymd;
public Date(int ymd) {
this.ymd = ymd;
}
public int getYmd() {
return ymd;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Date) {
return ((Date) obj).ymd == ymd;
}
return false;
}
}
}
The output is:
sweet
null
Upvotes: 4
Views: 2857
Reputation: 132
Because String,Integer and all wrapper class override hasCode and equals both the method. But In your case equals() method will return true but you have not override hasCode() method so it will generate different hashcode for both a and b .So map.get(b) will return null value.
Upvotes: 0
Reputation: 93842
Since you're using an HashMap
for storing your date objects, you have to override the hashCode()
method because the key objects are stored in the data structure using their hashCode.
Very basic hashCode()
overriden (just for illustration):
@Override
public int hashCode(){
return ymd;
}
Output :
sweet
sweet
Upvotes: 5
Reputation: 26094
You need to implement hashCode()
method in your Date
class
Add below code in your Date class
@Override
public int hashCode() {
return ymd;
}
output
sweet
sweet
Upvotes: 1
Reputation: 70929
A hashmap hashes the elements using their hashCode
function. For most types the hash code is computed using the reference of the object and this is the case with Date. While in your case the two dates have same value, they are not the same object. Thus they have different references and so their hash codes differ. When you lookup an element in a HashMap
its hashCode is used and so as b
's hashCode
is different from a
's hashCode
you can not find an element with key a
by using b
.
Upvotes: 2