java对象之间的比较（详细）

本文与大家分享一下在java中怎么比较两个对象中的成员变量

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
    }
}

​

假设我们要比较student1和student2，那么我们如果直接比较：

会发现是行不通的

注意：在java中，是不能直接比较引用类型的

本文提供以下方法：

1.compareTo方法

同理，如果我们定义两个字符串，也是不能直接比较的。那么我们查看String提供的方法时，会发现提供了comparetTo方法

可以帮助我们比较两个字符串

那么我们观察·compareTo方法，可以发现：

可以发现实际上他是在一个接口中使用的，而String类定义的时候，也是实现了这个接口的

说明：我们要想通过compareTo比较student类，必须实现Comparable接口

接下来是代码体现：

​
class Student implements Comparable<Student>//比较谁就写谁{
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
        if(student1.compareTo(student2) > 0)
        {
            System.out.println("student1 > student2");
        }else{
 System.out.println("student1 <= student2");
        }
    }
}

​

这里是通过年龄比较的，如果要通过名字比较，改一下重写的compareTo方法即可

@Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }

2.Array.sort

学数组的时候，在排序整型数组的时候，我们应该都使用过Array.sort方法进行排序，那么student类可以吗？ 答案是不能直接使用

 public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
        Student[] students = new Student[]{
                student1,student2
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

当我们运行时，会报错！

我们点开第一个报错的点

at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)

会发现实际上Array.sort方法会将数组里面每一个元素强转为Comparable类型，但是student类和Comparable接口没有任何关系，怎么能随意强转？

那么我们在Student类后面实现Comparable接口就好了

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
        Student[] students = new Student[]{
                student1,student2,student3
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

同样，想通过年龄比较，修改类中重写的compareTo方法即可

为什么整型类型的数组可以直接排序？？

实际上是因为在调用的时候会将int包装成包装类

 

甚者，我们可以自己实现排序：

public class Test2 {
    public static void mySort(Comparable[] comparables) {
        for (int i = 0; i < comparables.length-1; i++) {
            for (int j = 0; j <comparables.length-1-i; j++) {
                if(comparables[j].compareTo(comparables[j+1]) > 0)
                {
                   Comparable tmp = comparables[j];
                   comparables[j] = comparables[j + 1];
                   comparables[j + 1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
        Student[] students = new Student[]{
                student1,student2,student3
        };
        mySort(students);
        System.out.println(Arrays.toString(students));
    }
}

 3.比较器——更加灵活

class AgeCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
class NameCompare implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test2 {
    public static void mySort(Comparable[] comparables) {
        for (int i = 0; i < comparables.length-1; i++) {
            for (int j = 0; j <comparables.length-1-i; j++) {
                if(comparables[j].compareTo(comparables[j+1]) > 0)
                {
                   Comparable tmp = comparables[j];
                   comparables[j] = comparables[j + 1];
                   comparables[j + 1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
        AgeCompare ageCompare1 = new ageCompare();
        System.out.println(ageCompare1.compare(student3, student1));
        NameCompare nameCompare1 = new NameCompare();
        System.out.println(nameCompare1.compare(student3, student2));    
    }
}

其中Comparator接口原理与上述Comparable接口相同

 甚者，当我们打开Array.sort时，会发现

 实际上sort是可以传比较器的，那么我们就可以这样运用：

Student student1 = new Student("zhangsan",18);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",16);
         Student[] students = new Student[]{
             student1,student2,student3
        };
        nameCompare nameCompare2 = new nameCompare();
        Arrays.sort(students,nameCompare2);
        System.out.println(Arrays.toString(students));

 

 

以上就是与大家分享的java当中对象之间的比较

你我都加油