Java——对象比较

==和equals()方法

在前面对

String

==

equals()

==

equals()

equals()方法是根类Object的默认方法,查看Object中equals()的默认实现:

public boolean equals(Object obj) {
return (this == obj);
}

可以看出没有重写过的equals()方法和==是一样的，都是比较两个对象引用指向的内存地址是否一样判断两个对象是否相等。

在介绍String时，我们发现并没有重写过equals()方法，但是可以使用equals()正确判断两个字符串对象是否相等。查看String源码可以发现是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 != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}

public class Student{
private String name;
private int age;

public Student(String name, int age) {
this.name = name;
this.age = age;
}

@Override  //此关键字可以帮助我们检查是否重写合乎要求
public boolean equals(Object obj) {
if (this == obj)    //检测this与obj是否指向同一对象。这条语句是一个优化，避免直接去比较同一对象的各个域
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass()) // 比较this和obj是否属于同一个类 若是两个对象都不是同一个类的 则不相等
return false;

Student other = (Student) obj;  //将obj转换成相应的Student类型
//对所有需要比较的域进行比较 基本类型使用== 对象域使用equal 数组类型的域，可以使用静态的Arrays.equals方法检测相应的数组元素是否相等
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

public static void main(String[] args) {
Student stu1 = new Student("sakura",20);
Student stu2 = new Student("sakura",20);
System.out.println(stu1.equals(stu2));    //output: true
}
}

hashCode()

equals()

public static void main(String[] args) {
Student stu1 = new Student("sakura",20);
Student stu2 = new Student("sakura",20);
HashSet<Student> stuSet = new HashSet<>();
stuSet.add(stu1);
stuSet.add(stu2);
System.out.println(stu1.equals(stu2));
System.out.println(stu1);
System.out.println(stu2);
System.out.println(stuSet);
}
/*
output:
true
prcatice.Student@7852e922
prcatice.Student@4e25154f
[prcatice.Student@7852e922, prcatice.Student@4e25154f]
*/

HashSet不会存储相同的对象。按理来说，stu1和stu2是相等的，不应该被重复放进stuSet里面。但是结果显示，出现了重复的对象。

但是stu1和stu2的hashCode()返回值不同，那么它们将会被存储在stuSet中的不同的位置。

[i]对象存储在HashSet中时，先会根据对象的哈希值来查看是否哈希表中相应的索引位置是否有对象，若是没有则直接将对象插入；若是该位置有对象，则使用equals判断该位置上的对象与待插入的对象是否为相同对象，两个对象相等则不插入，不相等就将待插入对象挂在已存在对象的后面（就像链表一样挂载）。

总结来说就是：依据哈希值找位置，若是该位置没有对象则直接插入；若是有则比较，相等则不插入，不相等则悬挂在后面。

所以，要使stu1和stu2不能都被插入stuSet中，则要在Student中重写hashCode()方法。

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

在hashCode中为什么加入31这个奇素数来计算哈希值，总的目的是为了减少哈希冲突（在同一位置插入多个数）。详细理由可以参考此篇博文：为什么在定义hashcode时要使用31这个数呢?

然后我们在运行一次程序的输出如下：

/*
true
prcatice.Student@c9c6a694
prcatice.Student@c9c6a694
[prcatice.Student@c9c6a694]
*/

Comparator接口和Comparable接口

Comparator

Comparable

Comparable接口

以

able

int compareTo(T o)

返回负数：当前对象小于指定比较的对象；返回0，两个对象相等；返回正数，当前对象大于指定比较的对象。

public class Student implements Comparable<Student>{
private String name;
private int age;

public Student(String name, int age) {
this.name = name;
this.age = age;
}

//重写comparaTo方法 以age作为标准比较大小
@Override
public int compareTo(Student o) {
return this.age-o.age;//本类接收本类对象，对象可以直接访问属性(取消了封装的形式)
}

@Override
public String toString() {
return "name:" +name + " age:"+age;
}

public static void main(String[] args) {
Student stu1 = new Student("sakura",20);
Student stu2 = new Student("sakura",21);
Student stu3 = new Student("sakura",19);
//TreeSet会对插入的对象进行自动排序，所以要求知道对象之间的大小
TreeSet<Student> stuSet = new TreeSet<>();
stuSet.add(stu1);
stuSet.add(stu2);
stuSet.add(stu3);
//使用foreach(), lambda表达式输出stuSet中的值 forEach()方法从JDK1.8才开始有
stuSet.forEach(stu->System.out.println(stu));
}
}
/*
output:
name:sakura age:19
name:sakura age:20
name:sakura age:21
*/

实现了comparaTo()方法使用age为标准升序排序。也可以以name为标准排序，或者其他自定义的比较依据。

但是当Student已经实现了以age为依据从小到大排序后，我们又想以name为依据排序，在这个简单的程序中可以直接将

return this.age-o.age

return this.name.compareTo(o.name)

Comparator接口

实现Comparator接口需要重写其中的compare()方法（一个泛型方法）。

int compare(T o1,T o2)

根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数，通常使用-1, 0, +1表示。

需要注意，Comparator接口中也有一个equals方法，但是这是判断该比较器与其他Comparator比较器是否相等。

public class Student {
private String name;
private int age;

public Student(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Student stu1 = new Student("sakuraamy",20);
Student stu2 = new Student("sakurabob",21);
Student stu3 = new Student("sakura",19);

ArrayList<Student> stuList = new ArrayList<>();
stuList.add(stu1);
stuList.add(stu2);
stuList.add(stu3);

//没有必要去创建一个比较器类 采用内部类的方式实现Comparator接口
Collections.sort(stuList, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.age-o2.age;
//return o1.name.compareTo(o2.name);
}
});
//或者使用lambda表达式
//Collections.sort(stuList, (o1,o2)->o1.age-o2.age);
System.out.println(stuList);
}
}
/*
[name:sakura age:19, name:sakuraamy age:20, name:sakurabob age:21]
*/

由上可见，实现Comparator接口比较对象比实现Comparable接口简单和灵活。

使用这两个接口比较对象都需要注意几点：

对称性：若存在compare(x, y)>0 则 compare(y, x) <0，反之亦然
• 传递性：((compare(x, y)>0) && (compare(y, z)>0)) 可以推导出compare(x, z)>0
• 相等替代性：compare(x, y)==0可以推导出compare(x, z)==compare(y, z)

小结