Android 基于 Comparator 对象列表数组排序

Android 基于 Comparator 对象列表数组排序

iOS 版参看
iOS 数组排序

在特定的需求下，有时需要对数据进行排序。
一般如果是单一基本数据类型或者String对象，比较容易排序。但是实际开发中往往是对象数组的排序，排序条件为对象中的某个属性。
这种情况下，建议使用 Comparator 进行排序。

一、List< String > 和 Arrays 排序

基本数据类型和String对象的用法是一样的，以List为例排序。

List<String> listTemp = new ArrayList<String>();
listTemp.add("I");
listTemp.add("miss");
listTemp.add("you");
listTemp.add("so");
listTemp.add("much");
listTemp.add("tonight");

Log.e("排序前", listTemp.toString());
Collections.sort(listTemp);
Log.e("排序后", listTemp.toString());

// 倒序
Collections.sort(listTemp ,Collections.reverseOrder());
Log.e("倒序后", listTemp.toString());


// 数组的
String[] arrayTemp = new String[]{"I", "miss", "you", "so", "much", "tonight"};

Log.e("排序前", Arrays.toString(arrayTemp));
Arrays.sort(arrayTemp);
Log.e("排序后", Arrays.toString(arrayTemp));

Arrays.sort(arrayTemp, Collections.reverseOrder());
Log.e("倒序后", Arrays.toString(arrayTemp));


// 排序前: [I, miss, you, so, much, tonight]
// 排序后: [I, miss, much, so, tonight, you]
// 倒序后: [you, tonight, so, much, miss, I]

二、List< Vo >排序

自定义对象列表的排序，都是通过 Comparator 来完成。
实现上有两种方式：

1. 使用 Collections.sort(List< T > list, Comparator< ? super T> comparator) 方法。

2. 自定义对象（VO）实现 Comparable 接口，实现 compareTo 方法。

第1种方式 Collections.sort 用例如下：

public class VoteObject {  
    String name;  
    int age;  
    int voteNum;  

    public VoteObject(String name, int age, int voteNum) {  
        this.name = name;  
        this.age = age;  
        this.voteNum = voteNum;  
    }  
}  


...

List<VoteObject> listTemp = new ArrayList<VoteObject>();
listTemp.add(new VoteObject("哈密瓜", 20, 666));
listTemp.add(new VoteObject("苹果", 25, 999));
listTemp.add(new VoteObject("橙子", 25, 888));
listTemp.add(new VoteObject("水蜜桃", 22, 668));
listTemp.add(new VoteObject("芒果", 21, 668));
listTemp.add(new VoteObject("香蕉", 21, 898));

for (VoteObject obj : listTemp) {
    Log.e("排序前", obj.name + "  " + obj.age + "  " + obj.voteNum);
}

// 这里排序规则：按票数从高到低排，票数相同按年龄从低到高排
Comparator<VoteObject> comparator = new Comparator<VoteObject>() {
    public int compare(VoteObject o1, VoteObject o2) {
        int result = o2.voteNum - o1.voteNum; // 投票按降序

        if (result == 0) { // 票数相等，按年龄
            return o1.age - o2.age; // 排序按升序

        } else {
            return result;
        }
    }
};
Collections.sort(listTemp, comparator);

for (VoteObject obj : listTemp) {
    Log.e("排序后", obj.name + "  " + obj.age + "  " + obj.voteNum);
}

...

// 排序前: 哈密瓜  20  666
// 排序前: 苹果    25  999
// 排序前: 橙子    25  888
// 排序前: 水蜜桃  22  668
// 排序前: 芒果    21  668
// 排序前: 香蕉    21  898

// 排序后: 苹果  25  999
// 排序后: 香蕉  21  898
// 排序后: 橙子  25  888
// 排序后: 芒果  21  668
// 排序后: 水蜜桃  22  668
// 排序后: 哈密瓜  20  666

第2种方式 实现 Comparable 接口用例如下：

public class VoteObject implements Comparable<VoteObject> {
   String name;
    int age;
    int voteNum;

    public VoteObject(String name, int age, int voteNum) {
        this.name = name;
        this.age = age;
        this.voteNum = voteNum;
    }

    // 这里排序规则：按票数从高到低排，票数相同按年龄从低到高排
    @Override
    public int compareTo(@NonNull VoteObject another) { 
        // compare(VoteObject o1, VoteObject o2) {}
        // 这里this等于o1, another等于o2

        int result = another.voteNum - this.voteNum; // 投票按降序

        if (result == 0) { // 票数相等，按年龄
            return this.age - another.age; // 排序按升序

        } else {
            return result;
        }
    }
}
...
List<VoteObject> listTemp = new ArrayList<VoteObject>();
listTemp.add(new VoteObject("哈密瓜", 20, 666));
listTemp.add(new VoteObject("苹果", 25, 999));
listTemp.add(new VoteObject("橙子", 25, 888));
listTemp.add(new VoteObject("水蜜桃", 22, 668));
listTemp.add(new VoteObject("芒果", 21, 668));
listTemp.add(new VoteObject("香蕉", 21, 898));

for (VoteObject obj : listTemp) {
    Log.e("排序前", obj.name + "  " + obj.age + "  " + obj.voteNum);
}

Collections.sort(listTemp);

for (VoteObject obj : listTemp) {
    Log.e("排序后", obj.name + "  " + obj.age + "  " + obj.voteNum);
}


// 排序前: 哈密瓜  20  666
// 排序前: 苹果    25  999
// 排序前: 橙子    25  888
// 排序前: 水蜜桃  22  668
// 排序前: 芒果    21  668
// 排序前: 香蕉    21  898

// 排序后: 苹果  25  999
// 排序后: 香蕉  21  898
// 排序后: 橙子  25  888
// 排序后: 芒果  21  668
// 排序后: 水蜜桃  22  668
// 排序后: 哈密瓜  20  666

这里 compare 和 compareTo 方法返回值控制排序
返回正数( 1 )：o2在前，o1在后
返回 0：两个数相等
返回负数( -1 )：o1在前，o2在后

END