Java编程语法——compartator在sort中的使用

最新推荐文章于 2023-12-05 17:28:45 发布

原创最新推荐文章于 2023-12-05 17:28:45 发布 · 793 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #编程

Java 同时被 2 个专栏收录

43 篇文章

订阅专栏

编程细节

9 篇文章

订阅专栏

本文深入探讨了Java中用于比较对象的两种主要方法：通过实现Comparable接口来赋予类天然的比较能力，以及通过创建实现Comparator接口的独立类来定制比较逻辑。文章通过具体例子展示了如何实现和应用这两种方法，并解决了一个排序问题，即根据成绩、姓名字母序和年龄对学生成绩进行排序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java中有两种方式来提供比较功能！

实现java.lang.Comparable接口，使类具有“天生”的比较能力。此接口很简单，只有public int compareTo(Object obj)一个方法（注意在具体使用时Object可以替换为具体的类）。此方法接收一个Object作为参数，如果当前对象（this）小于参数obj则返回负值，如果相等则返回0，如果当前对象大于参数则返回正值。在使用时由于类本身就具有比较功能，所以直接sort就行了。
创建一个实现了Comparator接口的单独的类。尽管这个类由compare和equals两个方法。但因为无论何时创建一个类，都是间接继承自Object，而Object带有equals方法，所以如果不是有特殊的性能需要，不必实现equals方法。注意这里要实现的是compare方法，而不是第一种方式下的compareTO方法，格式如下：
class MyCmp implements Comparator< CompType >{
public int compare(CompType o1,CompType o2){
””
//CompType是待比较的数据的类型
//注意return的是一个整型
}
}
由于是一个类，new一个对象，然后将其作为一个参数传到Arrays.sort()里实现排序功能！

题目：

题目描述：

    有N个学生的数据，将学生数据按成绩高低排序，如果成绩相同则按姓名字符的字母序排序，如果姓名的字母序也相
    同则按照学生的年龄排序，并输出N个学生排序后的信息。

输入：

    测试数据有多组，每组输入第一行有一个整数N（N<=1000），接下来的N行包括N个学生的数据。
    每个学生的数据包括姓名（长度不超过100的字符串）、年龄（整形数）、成绩（小于等于100的正数）。

输出：

    将学生信息按成绩进行排序，成绩相同的则按姓名的字母序进行排序。
    然后输出学生信息，按照如下格式：
    姓名 年龄 成绩

样例输入：

3
abc 20 99
bcd 19 97
bed 20 97

样例输出：

bcd 19 97
bed 20 97
abc 20 99

提示：

学生姓名的字母序区分字母的大小写，如A要比a的字母序靠前(因为A的ASC码比a的ASC码要小)。

使用第一种方法：


import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public double grade;
    public int compareTo(Student otherStudent) {
        // TODO Auto-generated method stub
        if(this.grade!=otherStudent.grade){
            if(this.grade>otherStudent.grade) return 1;
            else return -1;
        }
        else if(!this.name.equals(otherStudent.name))return this.name.compareTo(otherStudent.name);
        return this.age - otherStudent.age;
    }

}

/**
 * 
        有N个学生的数据，将学生数据按成绩高低排序，如果成绩相同则按姓名字符的字母序排序，如果姓名的字母序也相
        同则按照学生的年龄排序，并输出N个学生排序后的信息。
 * */
class Mycmp implements Comparator<Student>{

    public int compare(Student o1,Student o2) {
        // TODO Auto-generated method stub
        if(o1.grade!=o2.grade){
            if(o1.grade>o2.grade) return 1;
            else return -1;
        }
        else if(!o1.name.equals(o2.name))return o1.name.compareTo(o2.name);
        return o1.age - o2.age;
    }
}

public class Main {

    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            Student[] students = new Student[N+10];
            for(int i=0;i<N;i++){
                students[i] = new Student();
                students[i].name = in.next();
                students[i].age = in.nextInt();
                students[i].grade = in.nextDouble();
            }
            Arrays.sort(students,0,N);
            for(int i=0;i<N;i++){
                System.out.println(students[i].name+" "+students[i].age+" "+students[i].grade);
            }
        }
    }  
}

使用第二种方法：


import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class Student{
    public String name;
    public int age;
    public double grade;
}

class Mycmp implements Comparator<Student>{

    public int compare(Student o1,Student o2) {
        // TODO Auto-generated method stub
        if(o1.grade!=o2.grade){
            if(o1.grade>o2.grade) return 1;
            else return -1;
        }
        else if(!o1.name.equals(o2.name))return o1.name.compareTo(o2.name);
        return o1.age - o2.age;
    }
}

public class Main {

    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            Student[] students = new Student[N+10];
            for(int i=0;i<N;i++){
                students[i] = new Student();
                students[i].name = in.next();
                students[i].age = in.nextInt();
                students[i].grade = in.nextDouble();
            }
            Arrays.sort(students,0,N,new Mycmp());
            for(int i=0;i<N;i++){
                System.out.println(students[i].name+" "+students[i].age+" "+students[i].grade);
            }
        }
    }  
}

注意这两种方式实现的接口不同，接口要实现的方法也不同。
1.如果要类“天生”具有比较能力，实现comparable接口（很形象，形容词，说明这是一个具有比较能力的类），而要实现的方法则是只有一个参数的compareTo方法
2.如果是创建一个实现Comparator接口的单独的类，则implements的接口是comparator接口，实现的比较方法是有两个参数的compare方法。
3.注意一个类就算它实现了Comparable接口，在sort是依然可以传入另一个实现了comparator的类的对象，两者不会冲突。
4.implements是一个类实现一个接口用的关键字，它是用来实现接口中定义的抽象方法。
实现一个接口，必须实现接口中的所有方法。
5.升序，降序
public int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序，则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）《=》return o1 - o2;
如果要按照降序排序则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）《=》return o2 - o1;
test:


import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class A{
    public int x,y;
}

class Mycmp implements Comparator<A>{
    //按x升序，y降序
    public int compare(A a,A b){
        if(a.x!=b.x) return a.x-b.x;
        else return b.y - a.y;
    }
}
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        A[] arr = new A[5];
        for(int i=0;i<5;i++){
            arr[i] = new A();
            arr[i].x = in.nextInt();
            arr[i].y = in.nextInt();
        }
        Arrays.sort(arr, new Mycmp());
        for(A a:arr){
            System.out.println(a.x+","+a.y);
        }
    }

}


class Student implements Comparable<Student>{

    int id;
    public Student(int id) {
        // TODO Auto-generated constructor stub
        this.id = id;
    }
    @Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        return this.id - o.id;
    }
}

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student[] stu = new Student[10];
        Random rand = new Random();
        for(int i=0;i<10;i++){
            stu[i] = new Student(rand.nextInt(100));
        }
        //在类里声明一个，直接作为比较器传到sort里，不过好像必须是非基本类才能这么用
        Comparator<Student> cmp = new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                return o2.id - o1.id;
            }
        };
        Arrays.sort(stu);
        for(Student x:stu){
            System.out.println(x.id);
        }
        System.out.println("ffffff");
        Arrays.sort(stu,cmp);
        for(Student x:stu){
            System.out.println(x.id);
        }
    }

}