對List排序一般採用兩種方法：
（1）實體類實現Comparable<T>介面,完成compareTo(T o)方法。
（2）建立一個Comparator<T>的實現類，完成compare(T o1, T o2)方法，然後利用這個比較器對List進行排序。
詳情可以看一下我的這篇文章。
當我們書寫compareTo(T o)或compare(T o1, T o2)方法時，我們知道：當第一個引數小於第二個引數時返回負整數；當第一個引數等於第二個引數時返回0；當第一個引數大於第二個引數時返回正整數。
但一定要記住3個原則：
1. 確保：sgn(compare(x, y)) == -sgn(compare(y, x)).

sgn(expression)是一個數學正負號函式，根據expression是負數、0、正數分別返回-1、0、1。

可以不實現equals()方法，也不一定要求(compare(x, y)==0) == (x.equals(y))。但建議正確實現各個方法。

由於JDK7之前Collections.sort

Exception in thread “main” java.lang.IllegalArgumentException: Comparison method violates its general contract!
at java.util.TimSort.mergeHi(Unknown Source)
at java.util.TimSort.mergeAt(Unknown Source)
at java.util.TimSort.mergeForceCollapse(Unknown Source)
at java.util.TimSort.sort(Unknown Source)
at java.util.Arrays.sort(Unknown Source)
at java.util.ArrayList.sort(Unknown Source)
at java.util.Collections.sort(Unknown Source)
at cn.test.JDK7.main(JDK7.java:32)

該異常並不是總會出現，只有當集合中元素順序影響到演算法排序時才會出現（如TimSort在Merge過程中出觸發了“勝利N次”優化，並且A[base1]==A[base1+x])&&(A[base1+x]==B[base2]時，具體可以看一下原始碼中mergeLo()和mergeHi()方法的實現），所以在開發環境下很難復現這個異常，通常只會在產品環境下發現。所以為了遵循原則，也是為了養成良好的程式設計習慣，一定要正確實現比較器。
下面是一個會出現異常的Case：

package cn.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class JDK7 {

    private static final String SORT_TIME_VALUE = "sort_time_value";
    private static final String PRICE_DOLLAR = "price_dollar";
    private static ArrayList<GameBean> gameBeans = new ArrayList<>();

    public static void main(String[] args) {
        add("0", 7);
        add("3", 1);
        add("0", 25);
        add("1", 2);
        add("0", 2);
        add("1", 1);
        add("0", 1);
        add("1", 1);
        add("0", 4);
        add("1", 1);
        add("0", 2);
        add("1", 1);
        add("0", 3);
        add("2", 1);
        add("1", 1);
        Collections.sort(gameBeans, new GameComparator(SORT_TIME_VALUE, 1));
        for (GameBean gameBean : gameBeans) {
            System.out.println(gameBean.getTime());
        }
    }

    private static void add(String time, int count) {
        for (int i = 0; i < count; i++) {
            GameBean gameBean0 = new GameBean();
            gameBean0.setTime(time);
            gameBean0.setPrice(time);
            gameBeans.add(gameBean0);
        }
    }

    static class GameComparator implements Comparator<GameBean> {

        String mSortField;
        int mSortType;// 1：升序 -1：降序

        public GameComparator(String sortField) {
            this(sortField, 1);
        }

        public GameComparator(String sortField, int sortType) {
            this.mSortField = sortField;
            this.mSortType = sortType;
        }

        @Override
        public int compare(GameBean lhs, GameBean rhs) {
            int ret = 0;
            if (SORT_TIME_VALUE.equals(mSortField)) {
                Long x = Long.valueOf(lhs.getTime());
                Long y = Long.valueOf(rhs.getTime());
                ret = mSortType * x.compareTo(y);
            } else if (PRICE_DOLLAR.equals(mSortField)) {
                Float x = Float.valueOf(lhs.getPrice());
                Float y = Float.valueOf(rhs.getPrice());
                ret = mSortType * x.compareTo(y);
            }
            return ret;
            // return (Integer.valueOf(lhs.getTime()) > Integer.valueOf(rhs.getTime())) ? 1 : -1;
        }
    }

    static class GameBean {

        private String time;
        private String price;

        public String getTime() {
            return time;
        }

        public void setTime(String time) {
            this.time = time;
        }

        public String getPrice() {
            return price;
        }

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

    }

}

注意：

• 不要用三目運算子返回. o1 > o2 ? 1 : -1沒有考慮相等的情況，如果o1等於o2就違背了3條原則。
• 不要將long強轉成int. 如果long超過了int最大值會導致資料錯誤，進而影響排序。
• 不要忽略比較的傳遞性. 尤其是比較邏輯很複雜時。

想了解更多，可以看一下下面幾篇文章：