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

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

}