Java——对象比较

前言

---

本篇博客主要梳理一下Java中对象比较的需要注意的地方，将分为以下几个方面进行介绍:

==和equals()方法

hashCode()方法和equals()方法

Comparator接口和Comparable接口

---

在前面对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[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Java中很多类都自身重写了equals()方法，但是要使我们自定义的对象能正确比较，我们就需要重写equals()方法。

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
    }
}

以上重写的equals方法是考虑最为全面的，在重写时最好是照着这种格式来。若是使用eclipse，则有快捷键帮助我们自动生成此格式的equals方法。

---

可以从上图中看出，hashCode()和equals()是配套自动生成的，为什么要附加生成hashCode()呢。

hashCode()是根类Object中的默认方法，查看JDK：

hashCode()方法与equals()方法没有任何关系，hashCode()的存在是为了服务于建立在散列表基础上的类，如Java集合中的HashMap, HashSet等。hashCode()方法获取对象的哈希码（散列码）。哈希码是一个int型的整数，用于确定对象在哈希表（散列表）中的索引位置。

hashCode()方法会根据不同的对象生成不同的哈希值，默认情况下为了确保这个哈希值的唯一性，是通过将该对象的内部地址转换成一个整数来实现。

下面我们看一个例子：

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中的不同的位置。

对象存储在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]
*/

---

我们使用equals()方法可以实现比较我们自定义类的对象是否相等，但是却无法得到对象谁大谁小。Java中提供了两种方式来使得对象可以比较，实现Comparator接口或者Comparable接口。

Comparable接口

以able结尾的接口都表示拥有某种能力。若是某个自定义类实现了comparable接口，则表示该类的实例化对象拥有可以比较的能力。
实现comparable接口需要覆盖其中的compareTo()方法（是一个泛型方法）。

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)(name为String对象)，但是这样修改类结构会显得十分麻烦，万一在以后的程序中遇到的是别人封装好的类不能直接改类结构又该怎么办。

有没有其他方便的比较方法，实现对象的大小比较。
办法是有的，那就是实现Comparator接口。

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)

---

简单总结一下本篇关于Java中对象比较的内容：要比较自定义类的对象是否相等需要重写equals()方法；
当对象要存储在建立在哈希表基础上的集合中时，还需要重写hashCode()方法用于判定对象在集合中的存储位置；
以某种依据比较对象的大小，可以实现Comparable接口或者Comparator接口，前者需要在类中实现表示该类拥有可以比较的能力，后者是在类外实现一个比较器，可以使用多种规则对对象进行比较，更灵活。

参考博文:https://juejin.im/entry/586c6a6061ff4b006407e2b9