Obey the general contract when overriding equals
先了解equals 和 == 的区别,如果不重写equals, equals比较的仅仅只是是否引用同一个对象,==更多的是比较基本数值。当我们创建一些对象的时候。
当对象是单例模式不需要进行 equals 重写。
Reflexive: For any non-null reference values x,x.equals(x) must return true.
Symmetric:For any non-null reference values x
and y
,x.equals(y)
must return true
if and only if y.equals(x)
returns true
Transitive:For any non-null reference values x
,y
,z
,if x.equals(y)
returns true
and y.equals(z)
returns true
, then x.equals(z)
must return true
.
Consistent: For any non-null reference values x
and y
, multiple invocations of x.equals(y)
consistently return true
or consistently return false
, provided no information used in equals
comparisons on the objects is modified.
For any non-null reference value x
,x.equals(null)
must return false
.
以及,要明白hashcode的作用,与equals的关系。
package all; import java.util.Collection;
import java.util.HashSet; public class Test5 { public static void main(String[] args) {
// TODO Auto-generated method stub
Collection c = new HashSet ();
Address s1 = new Address("05");
Address s2 = new Address("05");
c.add(s1);
c.add(s2);
//HashSet()有这个机制,当add的对象发现它hashcode和自己里面已经有的已经相等,自己就会进行相等的对象equals判断,判断为
//相等,set不会储存相同的值,所以就当只存了一个对象。hashcode是用于散列数据的快速存取,如利用HashSet/HashMap/Hashtable类来存储数据时,都是根据存储对象的hashcode值来进行判断是否相同的。
//详情 http://www.importnew.com/8701.html 关键点 一些collection的比较先从hashcode开始,所以才能快速。
System.out.println("----------------");
System.out.println(s1.equals(s2));
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(c); }
} class Address{
private String addressName;
public Address(String addressName){
this.addressName=addressName;
} public String toString(){
return this.addressName;
} @Override
public boolean equals (Object o){
if (this==o){//对象自身相等原则
return true;
}
if (o==null){//空值返回false 原则
return false;
}
if (o.getClass()!=getClass()){// 类型相同原则
return false;
} Address addr = (Address) o;//之后是实例化进行逻辑比较
if (!addr.addressName.equals(this.addressName)){
return false;
} System.out.println("Use equals!");
return true;
} @Override
public int hashCode(){//hashcode值 很重要,尤其是涉及collection。
return this.addressName.hashCode();
}
}
/*
输出以下:
Use equals!
----------------
Use equals!
true
1541
1541
[05]
会发现在分割线之上凭空多一个 use equals? 这是因为在 hashset 添加的时候,会先进行hashcode 进行比较,一样hashcode值得对象调用equals
比较得出完全一样的对象,根据hashset不重复的特性,最后只有一个值 05 ,如果试着把hashcode 方法去掉 ,则在第一步hashcode值判断就会不一样,
不会进行下一步的 equals 判断,则会输出两个 05,而实际我们希望他们是同一个对象。 */
但是如果集合中已经存在一万条数据或者更多的数据,如果采用equals方法去逐一比较,效率必然是一个问题。此时hashCode方法的作用就体现出来了,当集合要添加新的对象时,先调用这个对象的hashCode方法,得到对应的hashcode值,实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值,如果table中没有该hashcode值,它就可以直接存进去,不用再进行任何比较了;如果存在该hashcode值, 就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散列其它的地址,所以这里存在一个冲突解决的问题,这样一来实际调用equals方法的次数就大大降低了,说通俗一点:Java中的hashCode方法就是根据一定的规则将与对象相关的信息(比如对象的存储地址,对象的字段等)映射成一个数值,这个数值称作为散列值。
也就是说对于两个对象,如果调用equals方法得到的结果为true,则两个对象的hashcode值必定相等;
如果equals方法得到的结果为false,则两个对象的hashcode值不一定不同;
如果两个对象的hashcode值不等,则equals方法得到的结果必定为false;
如果两个对象的hashcode值相等,则equals方法得到的结果未知。
Cosider implementing Comparable
Comparable 接口的重写有利于 排序,在遇见一些Collection 的时候 。 除了Comparable 还有Comparator ,前者是比较接口 在类中实现,一个是比较器,创建一个类来实现,代码如下。
public class Cat implements Comparable<Cat> {
private int age;
private String name;
public Cat(int age,String name){
this.name=name;
this.age=age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
} @Override
public int compareTo(Cat o) {//重写比较接口
// TODO Auto-generated method stub return (this.age-o.age);
} } public class MyComparator implements Comparator<Cat>{//比较器的扩展 @Override
public int compare(Cat arg0, Cat arg1) {
// TODO Auto-generated method stub
return (arg1.getAge()-arg0.getAge());
} } public class Test2 { public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ArrayList<Cat> list = new ArrayList<Cat>();
list.add(new Cat(1,"1"));
list.add(new Cat(5,"5"));
list.add(new Cat(2,"2"));
list.add(new Cat(4,"4"));
list.add(new Cat(3,"3"));
Collections.sort(list);
for (Cat a:list){
System.out.println(a.getAge());
}
Collections.sort(list, new MyComparator());
for (Cat a:list){
System.out.println(a.getAge());
} } } /*
输出
1
2
3
4
5
5
4
3
2
1
*/