JavaSE | Cellection.sort() 的使用

最近在学java的一些基础知识，快速入门或者实践项目都可以看看这个网站 how2j教程，整理得挺好的。

---

 

本文目录

方式一：实现Comparable接口

1、类型参数实现 Comparable接口：

2、调用排序函数

方式二：取用Comparator参数

1、写一个自己的比较类，该类应该实现Comparator泛型接口，接口的类型参数应该是我们要排序集合中的对象

2、实例化一个比较类，调用排序函数

 

两种方式的对比：

另外补充：

end 

---

 

集合类都继承于 Collection 类，Cllection类中有写好的排序方法。所以对于实现了 List接口 的类，如：ArrayList、LinkedList、Vector，我们可以直接调用用 Collection.sort 方法进行排序。

通过查看源码，Collection.sort 有两种方式，我一一总结如下：

---

方式一：实现Comparable接口

首先看看Cellection.sort()方法对应的源码，有两个信息点：

1. 传入的参数即待排序集合，必须是 List泛型类 的对象，而且这个对象的 类型参数 必须实现 Comparable接口
2. 该方法是调用 list.sort 实现的

    public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
    }

1、类型参数实现 Comparable接口：

🔺comparable接口的源码：

public interface Comparable<T> {
    public int compareTo(T o);
}

可见，我们只需要覆盖一个 compareTo 方法即可：

compareTo方法将会从 T（类型参数）类中调用，传入参数为其他 T类对象 o。重写方法时，方法体内直接 return 一个数，而return什么需要看你的排序方式决定：当你的排序规则是希望 当前对象this 排在 传入对象 o之前时，应当返回负数；反之，应该返回正数。（一般，return后经常会调用其他的比较方式，让他们的比较结果当作返回值返回）

下面我对一个自己写的 song 类实现Comparable接口：

这里覆盖compareTo方法时，是通过调用String类中的compareTo方法来实现对排序方式的控制。

class Song implements Comparable<Song> {
    String name;

    public Song(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return name;
    }

    @Override
    public int compareTo(Song temp) {
        return this.getName().compareTo(temp.getName());  //从小到大排序
    }
}

还重写了Object类的 tostring 方法，是为了之后的输出方便，具体可以看这一篇文章： JavaSE | toString() 方法

2、调用排序函数

对于上面已经实现了comparable接口的song类，这里我们创建一个类型参数为song的 ArrayList 泛型对象，并使用Cellection.sort() 方法对其排序。下面是完整代码：

package MyCode;

import java.util.ArrayList;
import java.util.Collections;

public class hahah {

    public static void main(String[] args) {
        ArrayList<Song> songList = new ArrayList<>();
        songList.add(new Song("d23aaa"));
        songList.add(new Song("3d23aa"));
        songList.add(new Song("z23aaa"));
        songList.add(new Song("a23aaaa"));
        songList.add(new Song("a23aaa"));

        Collections.sort(songList);  //排序
        System.out.println(songList);
    }
}

class Song implements Comparable<Song> {
    String name;

    public Song(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return name;
    }

    @Override
    public int compareTo(Song temp) {
        return this.getName().compareTo(temp.getName());  //从小到大排序
    }
}

运行结果：

 

---

方式二：取用Comparator参数

看看Cellection.sort() 方法对应的第二种方法的源码：

有两个信息点：

1. 传入的参数1即待排序集合，参数2是Comparator（泛型）对象
2. 该方法是调用 list.sort 实现的

public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
    }

 

1、写一个自己的比较类，该类应该实现Comparator泛型接口，接口的类型参数应该是我们要排序集合中的对象

先看看Comparator源码：

public interface Comparator<T> {
    int compare(T o1, T o2);
}

有两个信息点：

1. Comparator是一个泛型接口，类型参数为 T
2. 该接口只有一个抽象方法，传入的参数为两个 T 对象

通俗来说，实现了comparator接口的类是一个比较器（和c++中的cmp函数很像），下面写一个这样的比较类：

class NameCompare implements Comparator<Song> {
    @Override
    public int compare(Song o1, Song o2) {
        return o1.getName().compareTo(o2.getName());  //从小到大排序
    }
}

将该比较类实例化后，就是Cellection.sort() 中需要传入的第二个参数 。

2、实例化一个比较类，调用排序函数

下面是完整代码：

package MyCode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class hahah {

    public static void main(String[] args) {

        ArrayList<Song> songList = new ArrayList<>();
        songList.add(new Song("d23aaa"));
        songList.add(new Song("3d23aa"));
        songList.add(new Song("z23aaaa"));
        songList.add(new Song("a23aaa"));
        songList.add(new Song("a23aaa"));

        NameCompare nameCompare = new NameCompare();  //实例化一个比较类
        Collections.sort(songList, nameCompare);  //排序
        System.out.println(songList);
    }
}

class NameCompare implements Comparator<Song> {
    @Override
    public int compare(Song o1, Song o2) {
        return o1.getName().compareTo(o2.getName());  //从小到大排序
    }
}

class Song {
    String name;

    public Song(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return name;
    }
}

输出结果：

 

---

 

两种方式的对比：

取用comparator版的sort()方法会用Comparator而不是元素内置的compareTo()方法来比较顺序。也就是说，如果sort()方法带有comparator，它就不会调用元素的compareTo()方法，而会取调用Comparator的compare()方法。

所以规则是是这样的：

• 调用单一参数的sort(List o)方法代表由List元素上的compareTo()方法来决定顺序。因此元素必须要实现Compara这个接口
• 调用sort(List o, comparator c) 方法代表不会调用List元素上的compareTo()方法，而会使用Comparator的compare()方法。这意味着list元素不需要实现Comparable接口。

其实取用comparator版的sort()方法会更加实用，因为它可以多样化排序：

使用compareTo方法时，list中的元素只能有一种将自己和同类型另一个元素比较的方法。但是Comparator是独立于所有比较元素类型之外的——它是独立的类。因此可以写出各种比较方法，来实现不同的排序方式。

---

另外补充：

上面已经指出，不管是方式一还是方式二，Cellection.sort()方法都是调用 list.sort 实现的。那么再具体看看代码，其实会用更多收获：其和 Arrays.sort() 方法的实现最终都是相同的：不论是Collections.sort方法或者是Arrays.sort方法，底层实现都是TimSort实现的，这是jdk1.7新增的，以前是归并排序。TimSort算法就是找到已经排好序数据的子序列，然后对剩余部分排序，然后合并起来。

具体的分析可以看看这篇文章：Arrays.sort和Collections.sort实现原理解析

---

---

 

end 

欢迎关注个人公众号“ 鸡翅编程 ”，这里是认真且乖巧的码农一枚。

---- 做最乖巧的博客er，做最扎实的程序员 ----

旨在用心写好每一篇文章，平常会把笔记汇总成推送更新~