java：对象比较的三种方法equals()方法，Comparator接口，Comparable接口

一、java中对象的比较 方法：

1、==和equals方法（只能比较是否相等，无法比较大小）

2、hashCode()和equals（）方法（可比大小，或用来排序）

3、Comparator接口和Comparable接口（可比大小，或用来排序）

二、详细的代码实现

1、== 和 equals方法。

在String介绍时，==和equals去比较对象是否相等的问题。==比较的是对象的地址是否一致，即比较的是否为同一个对象。equals方法，是根据对象的值进行判定是否相等。

equals方法是Object类的默认方法，查看Object源码

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

原始的equals方法是和==一样的，比较的对象所指向的内存地址是否相同，来判断是否为同一个对象。

String类，并没有重写equals方法，但可以使用equals方法正确判断两个字符串对象是否相等。看源码，发现是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方法。

class StudentClass{
    private String name;
    private int age;

    public StudentClass(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 (this.getClass() != obj.getClass())//检测this和obj是否为同一个类
            return false;

        StudentClass studentClass = (StudentClass)obj;
        //对所有需要比较的域进行比较 基本类型使用== 对象域使用equal 数组类型的域，可以使用静态的Arrays.equals方法检测相应的数组元素是否相等

        if (age != studentClass.age)
            return false;
        if (name == null){
            if (studentClass.name != null)
                return false;
        }else if (!name.equals(studentClass.name)){
            return false;
        }
        return true;
    }
}

Main
public static void main(String[] args) {
    StudentClass studentClass = new StudentClass("sxl",20);
    StudentClass studentClass1 = new StudentClass("sxl",20);
    System.out.println(studentClass.equals(studentClass1));
}

同时，eclipse，idea这些编译器也有快捷方式，快速的生成hashCode 和equals方法

例如
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    StudentClass that = (StudentClass) o;
    return age == that.age &&
            Objects.equals(name, that.name);
}

@Override
public int hashCode() {

    return Objects.hash(name, age);
}

2、hashCode和equals方法

hashCode和equals方法，是配套生成的。hashCode是根类Object中的默认方法，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里面。但最终结果，出现了重复对象。因为stu和stu1的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;
}

重新运行，结果如下
/*
true
prcatice.Student@c9c6a694
prcatice.Student@c9c6a694
[prcatice.Student@c9c6a694]
*/

3、Comparator接口和Comparable接口

equals（）方法可以实现比较自定义类的对象是否相等，无法得到对象谁大谁小。java中提供了两种方式使得对象的大小可以比较，实现Comparator接口或者Comparable接口。

1、Comparable接口：

以able结尾的接口都表示拥有某种能力。如某个自定义类实现了comparable接口，则表示该类有比较的能力。

实现comparable接口需要覆盖其中的compareTo（）方法。

int compareTo（T o）

1、返回负数：当前对象小于指定要比较的对象

2、返回0：俩对象相等

3、返回正数，当前对象大于指定比较对象

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

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

    @Override
    public int compareTo(Tea o){
        return (this.age<o.age ? -1 :(this.age == o.age ? 0:1));
    }

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

Main：
Tea tea = new Tea("longjing",20);
Tea tea1 = new Tea("longjing",51);
Tea tea2 = new Tea("longjing",23);
//TreSet会对插入的对象进行自动排序，所以必须知道对象之间的大小

TreeSet<Tea> teas = new TreeSet<>();
teas.add(tea);
teas.add(tea1);
teas.add(tea2);

teas.forEach(te->System.out.println(te));
//  //使用foreach(), lambda表达式输出stuSet中的值 forEach()方法从JDK1.8才开始有

/*输出：
name: +longjingage: +20
name: +longjingage: +23
name: +longjingage: +51*/

实现了compareTo（）方法使用age为标准升序排序，也可以以name为标准排序，或者其他自定义排序。

但是当Student已经实现了以age为依据从小到大排序后，我们又想以那么排序，那么可以直接将return this.age-o.age变为return this.name.compareTo(o.name)(name为String对象)。即可。

但是这样修改类结构很麻烦，为了解决之后可能遇到的 别人封装好的类，不能直接改类结构的时候，可以考虑实现Comparator接口

2、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;
	}
	
	@Override
	public String toString() {
		return "name:"+name + " 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 ? -1 : (o1.age == o2.age ? 0 : 1));
				//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接口，重写compare方法

class StudentComparator implements Comparator<Student>{  
  
    @Override  
    public int compare(Student o1, Student o2) {  
        // TODO Auto-generated method stub  
        if(o1.getScore()>o2.getScore())  
            return -1;  
        else if(o1.getScore()<o2.getScore())  
            return 1;  
        else{  
            if(o1.getAge()>o2.getAge())  
                return 1;  
            else if(o1.getAge()<o2.getAge())  
                return -1;  
            else   
                return 0;  
        }  
    }  
      
}  
  
public class ComparableDemo02 {  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
  
        Student stu[]={new Student("zhangsan",20,90.0f),  
                new Student("lisi",22,90.0f),  
                new Student("wangwu",20,99.0f),  
                new Student("sunliu",22,100.0f)};  
        java.util.Arrays.sort(stu,new StudentComparator());  
        for(Student s:stu)  
        {  
            System.out.println(s);  
        }  
    } 

上面依然是对student对象数组进行排序，用的都是Array.sort方法，不同的是实现comparator接口时，sort方法需要传进来两个参数，即stu对象数组，以及重写的实现了comparator比较方法类。

总结：

1、==和equals方法，

    前者比较地址（this），后者比较内容（可重写，只能比较是否相等）

2、hashCode()和equals（）方法

    hashCode多用在集合相关的，要是不牵扯到集合，可以不重写

    equals是重写Object类的，比较是否相等

3、Comparator接口和Comparable接口  可比较大小，以某种形式排序

    前者是写比较器，传入两个比较对象，重写compare方法，

    后者是比较this和传参，重写compareTo方法。后者可能会比较麻烦

参考链接：

【Java】对象比较

java的Comparator接口详解