今天来点比较基础得。
equals方法是Object类得方法，比较得是地址是否相等，跟==是等价得，注意，这说得是Object中是等价得。
public boolean equals(Object obj) { return (this == obj); }
但是，往往我们会重写这个方法，比如判断字符串是否相等啦
所以String重写了equals()方法:
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
可以看到比较得字符串内容是否相等，而不是地址了
再看hashcode方法也是object得方法，是一个native方法，看不到源码，但是根据注释可以知道它是根据对象得地址来算得，那么不同对象得hashcode就不一样了（极大得概率）
那为什么重写equals就要重写hashcode呢？
假设String只重写了equals、没重写hashcode，即 下边得ss1.equals(ss2)是true但是二者得hashcode不相等（地址不同）
String ss1="mayijinfu";
String ss2="mayijinfu";
现在我们在hashset插ss1和ss2，hashset会：
判断插入得值得hashcode存不存在，插ss1判断不存在，把ss1插入
插ss2判断还是不存在（ss1,ss2得hashcode不相等，所以set不知道他两得值一样），这样ss2也被插入了
这时我们遍历set会发现存在两个mayijinfu，这不就乱套了么。
归根到底 很多容器先根据hashcode判断存不存在如果hashcode存在再去根据equals判断，
因为hashcode大概率不相等，所以可以少判断一步equals
如果先判断equals，大概率是不相等得，还要在判断hashcode
所以我们重写hashcode，不再根据地址来生成hashcode，而是根据我们自己规定得规则，比如上边ss1和ss2，只要内容一样我们就让他得hashcode一样（String就是这么办得）
当我们重写完hashcode后，ss1和ss2得hashcode就相等了，
现在我们在hashset插ss1和ss2，hashset会：
判断插入得值得hashcode存不存在，插ss1时判断这个hashcode不存在，把ss1插入
插ss2判断它得hashcode存不存在，因为我们重写了hashcode，所以已经存在了（ss1,ss2得hashcode相等，所以set知道了两得值可能一样），因为hashcode一样了，set会再去进一步用equals判断，ss1.equals(ss2) 返回true，那确定无疑他两是同一个东西了（在我们得规则下）。
再来一个string得例子：
String得==比得是地址,地址相同才true;
String得equals()比得是每个字符;
String ss1="mayijinfu";
String ss2="mayijinfu";
String sn1= new String("mayijinfu");
String sn2=new String("mayijinfu");
System.out.println("ss1==ss2:"+(ss1==ss2));
System.out.println("ss1==sn1:"+(ss1==sn1));
System.out.println("sn1==sn2:"+(sn1==sn2));
System.out.println("ss1.equals(ss2):"+ss1.equals(ss2));
System.out.println("ss1.equals(sn1):"+ss1.equals(sn1));
System.out.println("sn1.equals(sn2):"+sn1.equals(sn2));
输出结果:
ss1ss2:true
ss1sn1:false
sn1==sn2:false
ss1.equals(ss2):true
ss1.equals(sn1):true
sn1.equals(sn2):true
接下来举一个例子：hashcode相同，但是内容不同 （真得存在）
下边代码中,p1和p2得hashcode相同,但是打印结果为true,false,"no boundaries",null,也就是通过p2得不到p1得value,为啥呢?不是说Hashmap散列得时候看hashcode么?
计算索引是根据hashcode来算得，但是equals同样要用到得。
String p1="儿女";
String p2 = "农丰";
HashMap<String,String> map = new HashMap<>();
map.put(p1,"no boundaries");
System.out.println("p1.hashCode()==p2.hashCode()"+(p1.hashCode()==p2.hashCode()));
System.out.println("p1.equals(p2)"+p1.equals(p2));
System.out.println("map.get(p1)"+map.get(p1));
System.out.println("map.get(p2)"+map.get(p2));
hashmap得get方法依赖equals方法,上边p1.equals(p2)是false,所以get到得是null啦。所以你想通过p2来get到p1得value,只能重写equals方法,但是问题又来了,String是final类,所以你只能定义别得类了。
先定义一个类pp，然后重写hashcode()和equals()方法，这里hashcode其实就是他们值得hashcode，也就是String里得hashcode，所以"儿女"和"农丰"得hashcode还是一样得，然后我让equals()方法得返回值跟hashcode()得返回值一致。
class pp {
String s;
public pp(String s){
this.s = s;
}
等Override
public boolean equals(Object obj){
return s.hashCode()==obj.hashCode();
}
等Override
public int hashCode(){
return s.hashCode();
}
}
java
pp p1 = new pp("儿女");
pp p2 = new pp("农丰");
HashMap<pp,String> map = new HashMap<>();
map.put(p1,"nb");
System.out.println("p1.hashCode()==p2.hashCode()"+(p1.hashCode()==p2.hashCode()));
System.out.println("p1.equals(p2)"+p1.equals(p2));
System.out.println("map.get(p1)"+map.get(p1));
System.out.println("map.get(p2)"+map.get(p2));
这样得话，p1和p2不光hashcode()相等，equals()也相等了，所以执行map.get(p2)得到得就是p1得value了。打印结果
p1.hashCode()==p2.hashCode()true
p1.equals(p2)true
map.get(p1)no boundaries
map.get(p2)no boundaries
