欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA中Arrays.sort()使用Comparable或Comparator接口对数组排序(转)

程序员文章站 2022-05-23 14:03:43
...


一、描述

自定义的类要按照一定的方式进行排序,比如一个Person类要按照年龄进行从小到大排序,比如一个Student类要按照成绩进行由高到低排序。

这里我们采用两种方式,一种是使用Comparable接口:让待排序对象所在的类实现Comparable接口,并重写Comparable接口中的compareTo()方法,缺点是只能按照一种规则排序。

另一种方式是使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法,在调用Arrays的sort()时将排序类对象作为参数传入:public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的(也就是说,对于数组中的任何 e1 和 e2 元素而言,c.compare(e1, e2) 不得抛出 ClassCastException)。

优点是可以按照多种方式排序,你要按照什么方式排序,就创建一个实现Comparator接口的排序方式类,然后将该排序类的对象传入到Arrays.sort(待排序对象,该排序方式类的对象)


二、源代码

方式1:使用Comparable接口

  1. package tong.day4_27.systemUse;  
  2.   
  3. import java.util.Arrays;  
  4. /** 
  5.  * 使用Comparable接口:让待排序对象所在的类实现Comparable接口,并重写Comparable接口中的compareTo()方法 
  6.  * 缺点是只能按照一种规则排序 
  7.  * @author tong 
  8.  * 
  9.  */  
  10. public class ObjectSort {  
  11.   
  12.     public static void main(String[] args) {  
  13.         Person[] persons = new Person[5];  
  14.         persons[0] =new Person(“tom”,45);  
  15.         persons[1] =new Person(“jack”,12);  
  16.         persons[2] =new Person(“bill”,21);  
  17.         persons[3] =new Person(“kandy”,34);  
  18.         persons[4] =new Person();  
  19.         Arrays.sort(persons);  
  20.         for (Person person:persons) {  
  21.             System.out.println(person);  
  22.         }  
  23.   
  24.     }  
  25.   
  26. }  
  27. class Person implements Comparable<Person>{  
  28.     private String name;  
  29.     private int age;  
  30.       
  31.     public Person(String name,int age){  
  32.         this.name = name;  
  33.         this.age = age;  
  34.     }  
  35.     public Person(){  
  36.         this(“unknown”0);  
  37.     }  
  38.     //重写该类的compareTo()方法,使其按照从小到大顺序排序  
  39.     @Override  
  40.     public int compareTo(Person o) {  
  41.          return age-o.age;  
  42.           
  43.     }  
  44.     //重写Student类的toString()方法,在输入对象时按照以下方式输出  
  45.     @Override  
  46.     public String toString() {        
  47.         return “Person[name:”+name+“,age:”+age+“]”;  
  48.     }  
  49.       
  50. }  
package tong.day4_27.systemUse;

import java.util.Arrays;
/**
 * 使用Comparable接口:让待排序对象所在的类实现Comparable接口,并重写Comparable接口中的compareTo()方法
 * 缺点是只能按照一种规则排序
 * @author tong
 *
 */
public class ObjectSort {

    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] =new Person("tom",45);
        persons[1] =new Person("jack",12);
        persons[2] =new Person("bill",21);
        persons[3] =new Person("kandy",34);
        persons[4] =new Person();
        Arrays.sort(persons);
        for (Person person:persons) {
            System.out.println(person);
        }

    }

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

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(){
        this("unknown", 0);
    }
    //重写该类的compareTo()方法,使其按照从小到大顺序排序
    @Override
    public int compareTo(Person o) {
         return age-o.age;

    }
    //重写Student类的toString()方法,在输入对象时按照以下方式输出
    @Override
    public String toString() {      
        return "Person[name:"+name+",age:"+age+"]";
    }

}
运行结果:

JAVA中Arrays.sort()使用Comparable或Comparator接口对数组排序(转)


方式2:使用Comparator接口

  1. package tong.day4_27.systemUse;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.Comparator;  
  5.   
  6. /** 
  7.  * 使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法 
  8.  * public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的 
  9.  * (也就是说,对于数组中的任何 e1 和 e2 元素而言,c.compare(e1, e2) 不得抛出 ClassCastException)。 
  10.  * 优点是可以按照多种方式排序,你要按照什么方式排序,就创建一个实现Comparator接口的排序方式类,然后将该排序类的对象传入到Arrays.sort(待排序对象,该排序方式类的对象) 
  11.  * @author tong 
  12.  * 
  13.  */  
  14.   
  15. public class ComparatorUse {  
  16.   
  17.       
  18.     public static void main(String[] args) {  
  19.         Student[] persons = new Student[5];  
  20.         persons[0] =new Student(“tom”,1,88,45);  
  21.         persons[1] =new Student(“jack”,6,80,12);  
  22.         persons[2] =new Student(“bill”,4,68,21);  
  23.         persons[3] =new Student(“kandy”,2,98,34);  
  24.         persons[4] =new Student(“lily”,5,94,20);  
  25.         System.out.println(”排序前的数据:”);  
  26.         for (Student student:persons) {  
  27.             System.out.println(student);  
  28.         }  
  29.         //创建SortByNumber对象,将其作为参数传入Arrays.sort(persons,sortByNumber)方法中  
  30.         SortByNumber sortByNumber = new SortByNumber();  
  31.         Arrays.sort(persons,sortByNumber);  
  32.         System.out.println(”根据学生编号由低到高排序:”);  
  33.         for (Student student:persons) {  
  34.             System.out.println(student);  
  35.         }  
  36.         SortByScore sortByScore = new SortByScore();  
  37.         Arrays.sort(persons,sortByScore);  
  38.         System.out.println(”根据学生成绩由高到低排序:”);  
  39.         for (Student student:persons) {  
  40.             System.out.println(student);  
  41.         }  
  42.   
  43.   
  44.     }  
  45.   
  46. }  
  47.   
  48. class Student {  
  49.     private String name;  
  50.     private int number;  
  51.     private int score;  
  52.     private int age;  
  53.       
  54.     public Student(String name,int number,int score,int age){  
  55.         this.name = name;  
  56.         this.number = number;  
  57.         this.score = score;  
  58.         this.age = age;  
  59.     }  
  60.     //重写Student类的toString()方法,在输入对象时按照以下方式输出  
  61.     @Override  
  62.     public String toString() {        
  63.         return “Student[name:”+name+“,age:”+age+“,number:”+number+“,score:”+score+“]”;  
  64.     }  
  65.   
  66.     public String getName() {  
  67.         return name;  
  68.     }  
  69.   
  70.     public void setName(String name) {  
  71.         this.name = name;  
  72.     }  
  73.   
  74.     public int getNumber() {  
  75.         return number;  
  76.     }  
  77.   
  78.     public void setNumber(int number) {  
  79.         this.number = number;  
  80.     }  
  81.   
  82.     public int getScore() {  
  83.         return score;  
  84.     }  
  85.   
  86.     public void setScore(int score) {  
  87.         this.score = score;  
  88.     }  
  89.   
  90.     public int getAge() {  
  91.         return age;  
  92.     }  
  93.   
  94.     public void setAge(int age) {  
  95.         this.age = age;  
  96.     }  
  97.       
  98.       
  99.       
  100. }  
  101. //按照学号由低到高排列,创建SortByNumber类,该类实现Comparator,重写该接口的compare()  
  102. class SortByNumber implements Comparator<Student>{  
  103.     //重写该接口的compare()使其按照学号由小到大排序(前者减去后者)  
  104.     @Override  
  105.     public int compare(Student o1, Student o2) {  
  106.         return o1.getNumber()-o2.getNumber();  
  107.           
  108.     }  
  109.       
  110. }  
  111. //按照分数由高到低排列,创建SortByScore类,该类实现Comparator,重写该接口的compare()  
  112. class SortByScore implements Comparator<Student>{  
  113.     //重写该接口的compare()使其按照分数由高到低排序(后者减去前者)  
  114.     @Override  
  115.     public int compare(Student o1, Student o2) {  
  116.         return o2.getScore()-o1.getScore();  
  117.           
  118.     }  
  119.       
  120. }  
package tong.day4_27.systemUse;

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

/**
 * 使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法
 * public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的
 * (也就是说,对于数组中的任何 e1 和 e2 元素而言,c.compare(e1, e2) 不得抛出 ClassCastException)。
 * 优点是可以按照多种方式排序,你要按照什么方式排序,就创建一个实现Comparator接口的排序方式类,然后将该排序类的对象传入到Arrays.sort(待排序对象,该排序方式类的对象)
 * @author tong
 *
 */

public class ComparatorUse {


    public static void main(String[] args) {
        Student[] persons = new Student[5];
        persons[0] =new Student("tom",1,88,45);
        persons[1] =new Student("jack",6,80,12);
        persons[2] =new Student("bill",4,68,21);
        persons[3] =new Student("kandy",2,98,34);
        persons[4] =new Student("lily",5,94,20);
        System.out.println("排序前的数据:");
        for (Student student:persons) {
            System.out.println(student);
        }
        //创建SortByNumber对象,将其作为参数传入Arrays.sort(persons,sortByNumber)方法中
        SortByNumber sortByNumber = new SortByNumber();
        Arrays.sort(persons,sortByNumber);
        System.out.println("根据学生编号由低到高排序:");
        for (Student student:persons) {
            System.out.println(student);
        }
        SortByScore sortByScore = new SortByScore();
        Arrays.sort(persons,sortByScore);
        System.out.println("根据学生成绩由高到低排序:");
        for (Student student:persons) {
            System.out.println(student);
        }


    }

}

class Student {
    private String name;
    private int number;
    private int score;
    private int age;

    public Student(String name,int number,int score,int age){
        this.name = name;
        this.number = number;
        this.score = score;
        this.age = age;
    }
    //重写Student类的toString()方法,在输入对象时按照以下方式输出
    @Override
    public String toString() {      
        return "Student[name:"+name+",age:"+age+",number:"+number+",score:"+score+"]";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



}
//按照学号由低到高排列,创建SortByNumber类,该类实现Comparator,重写该接口的compare()
class SortByNumber implements Comparator<Student>{
    //重写该接口的compare()使其按照学号由小到大排序(前者减去后者)
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getNumber()-o2.getNumber();

    }

}
//按照分数由高到低排列,创建SortByScore类,该类实现Comparator,重写该接口的compare()
class SortByScore implements Comparator<Student>{
    //重写该接口的compare()使其按照分数由高到低排序(后者减去前者)
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getScore()-o1.getScore();

    }

}
运行结果:

JAVA中Arrays.sort()使用Comparable或Comparator接口对数组排序(转)