Java中Collections.sort()案例讲解

1、是什么：

Collections是一个工具类，sort是其中的静态方法，是用来对List类型的数据进行排序的。

2、默认排序

（1）普通类型

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(0,5,3,2,6);
        System.out.println("排序前如下：");
        for(Integer fac : list){
            System.out.print(fac+"--");
        }
        System.out.println();
        System.out.println("排序后如下：");
        Collections.sort(list);
        for(Integer fac : list){
            System.out.print(fac+"--");
        }
    }
}

运行结果： 

Collections.sort方法，默认情况下对List中的元素升序排序。其中，对于List中元素为Integer、Long等类型的数组，直接调用sort就可以进行升序排序。查看这些包装类可以发现他们都实现了Comparable接口并实现了接口中的compareTo方法，比较规则也就是在compareTo方法中定义的。

所以，如果想自己定义排序规则的话，就需要自己重写compareTo方法，在此方法中定义如何进行排序。

当List中的元素类型是自定义类时，需要让此类也实现Comparable接口并重写接口的compareTo方法来自定义排序规则。

 

3、自定义排序

（1）普通类型

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(0,5,3,2,6);
        System.out.println("排序前如下：");
        for(Integer fac : list){
            System.out.print(fac+"--");
        }
        System.out.println();
        System.out.println("排序后如下：");
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for(Integer fac : list){
            System.out.print(fac+"--");
        }
    }
}

此处自定义排序规则是通过在调用sort方法传入第二个参数时，通过Comparator中的compare方法来自定义的排序规则

（2）引用类型

import java.util.*;

public class Main {
    public static void main(String[] args) {
        RabbitBB ra = new RabbitBB(18,"rabbitbb");
        RabbitBB nini = new RabbitBB(15,"nini");
        RabbitBB wang = new RabbitBB(16,"wang");
        RabbitBB hello = new RabbitBB(12,"hello");
        List<RabbitBB> raList = Arrays.asList(ra,nini,wang,hello);
        Collections.sort(raList);
        System.out.println("按照年龄降序排序如下：");
        for(RabbitBB fac : raList){
            System.out.print(fac.getAge()+"--");
        }
    }
}
class RabbitBB implements Comparable<RabbitBB>{
    int age;
    String name;
    // 降序排序
    @Override
    public int compareTo(RabbitBB o) {
        return o.getAge() - this.getAge();
    }
    public RabbitBB(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

此处新建了一个RabbtiBB类，它实现了Comparable接口并重写了compareTo方法

// 降序排序
@Override
public int compareTo(RabbitBB o) {
    return o.getAge() - this.getAge();
}

如果想升序排序，修改compare方法如下：

// 升序排序
@Override
public int compareTo(RabbitBB o) {
    return this.getAge() - o.getAge();
}

除了上述通过类实现Comparable接口并实现compare方法来自定义排序规则外，也可以在sort方法中出入两个参数，第一个是list，第二个是new Comparator，在此Comparator中重写compare方法来自定义排序规则。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        RabbitBB ra = new RabbitBB(18,"rabbitbb");
        RabbitBB nini = new RabbitBB(15,"nini");
        RabbitBB wang = new RabbitBB(16,"wang");
        RabbitBB hello = new RabbitBB(12,"hello");
        List<RabbitBB> raList = Arrays.asList(ra,nini,wang,hello);
        Collections.sort(raList, new Comparator<RabbitBB>() {
            @Override
            public int compare(RabbitBB o1, RabbitBB o2) {
                // 降序排序
                return o2.getAge() - o1.getAge();
            }
        });
        System.out.println("按照年龄降序排序如下：");
        for(RabbitBB fac : raList){
            System.out.print(fac.getAge()+"--");
        }
    }
}
class RabbitBB {
    int age;
    String name;
    public RabbitBB(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

4、总结

（1）对于String、Integer和Long这些已经实现Comparable接口的包装类来说，可以直接使用Collections.sort方法传入list参数来实现默认方式（正序）排序；

（2）如果不想使用默认方式（正序）排序，可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则，要重写compare方法；

（3）对于自定义类型，有两种实现自定义排序的方式，可以通过让自定义类实现Comparable接口并重写接口中compareTo方法来进行；也可以不让类实现Comparable接口，而是通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则；