【JAVA-Arrays之使用Comparator接口自定义排序方法详解及实例】

请仔细查看下列实例

package Exception012.Arithmetic;

import java.sql.Array;
import java.util.Arrays;
import java.util.Comparator;

public class paixu {
    public static void main(String[] args) {
        int[] arr = {10, -20, 30, 1, 50, -23, 14};
        //因为是静态方法可以直接调用静态方法比较方便调用，所以:
        bubble(arr, new Comparator() {//这里生成了一个匿名内部类，并且迅速生成了一个对象
            @Override
            //原始compare方法就只含2个形参，这里我们重写一下
            public int compare(Object o1, Object o2) {
                int i1=(int) o1;
                int i2=(int) o2;
                return i1-i2;//比较两个数据大小，会返回-1 0 1   看谁大了。。重写这个的目的就是比较大小
            }
        });
        //上面过程执行完就排完序了 现在输出
        System.out.println(Arrays.toString(arr));
    }
        //如果只重写compare方法，没法对int数组排序，因此下面这个方法，目的就是实现对int数组排序
        //在主函数中只要调用就行了
    public static void bubble(int[] arr, Comparator comparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (comparator.compare(arr[j],arr[j+1]) > 0) {
                    //这一步对象comparator会根据数据动态绑定来寻找调用哪个方法
                    //因为它是在上面那个匿名内部类中产生的对象，所以它会直接找匿名内部类中名为compare的方法
                    //即根据你重写的方法规则返回的数值在if里面判断
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

对比只重写compare方法

package Exception012.Arithmetic;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

public class paixu2 {
    public static void main(String[] args) {
        //如果只重写compare方法，那么只能返回的是Integer，因为int是基本类型不能当作类型实参
        Integer[] arr={1,10,-20,0,55,10};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(arr));
    }

}

最后一个例子，巩固一下自己

package Exception012.Arithmetic;

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

public class paixu3 {
    public static void main(String[] args) {
        Book[] books=new Book[4];
        books[0]=new Book("我",100);
        books[1]=new Book("我是",90);
        books[2]=new Book("我是中",5);
        books[3]=new Book("我是中国人",300);
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                double i1=o1.getPrice();
                double i2=o2.getPrice();
                //反正return的目的是比较两者大小返回-1 0 1而已所以只要return的是int类型就行
                //所以我通过大小来return一下-1 0 1不就行了吗哈哈哈
                double s=i1-i2;
                if(s<0){
                    return -1;
                }else if(s>0){
                    return 1;
                }else {
                    return 0;
                }
            }
        });
        //调用 哦 对 要重写一下tostring
        System.out.println(Arrays.toString(books));
        //再重写一下 以字符串长度来输出
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                int i1=o1.getName().length();
                int i2=o2.getName().length();
                //这里因为直接就是int 可以直接return
                return i1-i2;
            }
        });
        //调用一下
        System.out.println(Arrays.toString(books));
    }
}
class Book{
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}
输出：
[Book{name='我是中', price=5.0}, Book{name='我是', price=90.0}, Book{name='我', price=100.0}, Book{name='我是中国人', price=300.0}]
[Book{name='我', price=100.0}, Book{name='我是', price=90.0}, Book{name='我是中', price=5.0}, Book{name='我是中国人', price=300.0}]

sort方法实现Comparator接口

class Student implements Comparable<Student>{  
    private String name;  
    private int age;  
    private float score;  
      
    public Student(String name, int age, float score) {  
        this.name = name;  
        this.age = age;  
        this.score = score;  
    }  
      
    public String toString()  
    {  
        return name+"\t\t"+age+"\t\t"+score;  
    }  
  
    @Override  
    public int compareTo(Student o) {  
        // TODO Auto-generated method stub  
        if(this.score>o.score)//score是private的，为什么能够直接调用,这是因为在Student类内部  
            return -1;//由高到底排序  
        else if(this.score<o.score)  
            return 1;  
        else{  
            if(this.age>o.age)  
                return 1;//由底到高排序  
            else if(this.age<o.age)  
                return -1;  
            else  
                return 0;  
        }  
    }  
}  
  
public class ComparableDemo01 {  
  
    /** 
     * @param args 
     */  
    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);  
        for(Student s:stu)  
        {  
            System.out.println(s);  
        }  
    }  
}  

return 0 表示相等。在上面的程序中，实现了Comparable接口，并重写了compareTo方法，将学生先按成绩由大到小排名，成绩相同时候按照年龄由低到高排序。