最近工作上遇到一個要求兩個不同list物件合併後並排序，網上有很多相關文章，但都是相同的list物件合併在排序，可是我遇到不同的list物件合併後並排序。於是自己動手寫了一個。大家可以參考。

問題描述

從資料庫中查詢兩張表的當天資料，並對這兩張表的資料，進行合併，然後根據時間排序。

思路

從資料庫中查詢到的資料放到各自list中，先遍歷兩個list，存到主list中，然後根據各自list的物件屬性time屬性排序。

需要技術

Java API針對集合型別排序提供了兩種支援：
Java.util.Collections.sort(java.util.List)
Java.util.Collections.sort(java.util.List, java.util.Comparator)

第一個方法要求所排序的元素類必須實現java.lang.Comparable介面。
第二個方法要求實現一個java.util.Comparator介面。
這兩個介面不但可以用於集合元素排序，還可以用於陣列排序。如果陣列或集合元素是String型別，則可以利用Java APIComparator物件String.CASE_INSENSITIVE_ORDER為容器元素排序。

程式碼演示

編寫物件 Bill.java

public class Bill {

    private Integer id ;
    private String card ;
    private String money ;
    private
 
 Timestamp conDateTime ;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCard() {
        return card;
    }
    public void setCard(String card) {
        this.card = card;
    }
    public String getMoney() {
        return
 
 money;
    }
    public void setMoney(String money) {
        this.money = money;
    }
    public Timestamp getConDateTime() {
        return conDateTime;
    }
    public void setConDateTime(Timestamp conDateTime) {
        this.conDateTime = conDateTime;
    }

}

編寫物件 Recharge .java

public class Recharge {
    private Integer id ;
    private String amount ;
    private String money ;
    private String conType ;
    private Timestamp rechargeTime ;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getAmount() {
        return amount;
    }
    public void setAmount(String amount) {
        this.amount = amount;
    }
    public String getMoney() {
        return money;
    }
    public void setMoney(String money) {
        this.money = money;
    }
    public String getConType() {
        return conType;
    }
    public void setConType(String conType) {
        this.conType = conType;
    }
    public Timestamp getRechargeTime() {
        return rechargeTime;
    }
    public void setRechargeTime(Timestamp rechargeTime) {
        this.rechargeTime = rechargeTime;
    }
}

編寫一個測試判斷條件 ComparatorTime .java

public class ComparatorTime implements Comparator {
    /**
     * 
     * TODO 以物件Time判斷兩個list物件排序（可選）.
     * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
     */
    @Override
    public int compare(Object arg0, Object arg1) {
        Bill cb ;
        Recharge rd ;
        Bill cb1 ;
        Recharge rd1 ;
        if(arg0 instanceof Bill){
            cb=(Bill)arg0;
            if(arg1 instanceof Recharge){
                rd=(Recharge)arg1;
                return cb.getConDateTime().compareTo(rd.getRechargeTime()); 
            }else{
                cb1=(Bill)arg1;
                return cb.getConDateTime().compareTo(cb1.getConDateTime()); 
            }
        }else{
            rd1=(Recharge)arg0;
            if(arg1 instanceof Recharge){
                rd=(Recharge)arg1;
                return rd1.getRechargeTime().compareTo(rd.getRechargeTime()); 
            }else{
                cb=(Bill)arg1;
                return rd1.getRechargeTime().compareTo(cb.getConDateTime()); 
            }
        }
    }

}

編寫測試類，由於從資料庫查詢程式碼比較多，我們直接寫死資料。

通過實現Comparable介面實現個性化排序測試。
升序排列：Collection.sort(list)
降序排列：Collections.sort(list, Collections.reverseOrder());
反轉排序：Collections.reverse(list);

public class Test {
    public static void main(String[] args) {
        Bill cb1 = new Bill() ;
        cb1.setId(1);
        cb1.setCard("1111");
        cb1.setMoney("1111");
        cb1.setConDateTime(Timestamp.valueOf("2016-09-28 16:00:00.0"));
        Bill cb2 = new Bill() ;
        cb2.setId(2);
        cb2.setCard("2222");
        cb2.setMoney("2222");
        cb2.setConDateTime(Timestamp.valueOf("2016-09-28 10:00:00.0"));
        Recharge rd1 = new Recharge() ;
        rd1.setId(3);
        rd1.setAmount("3333");
        rd1.setConType("3333");
        rd1.setMoney("3333");
        rd1.setRechargeTime(Timestamp.valueOf("2016-09-28 8:00:00.0"));
        Recharge rd2 = new Recharge() ;
        rd2.setId(4);
        rd2.setAmount("4444");
        rd2.setConType("4444");
        rd2.setMoney("4444");
        rd2.setRechargeTime(Timestamp.valueOf("2016-09-28 12:00:00.0"));
        List<Bill> listBill = new ArrayList<Bill>() ;
        listBill.add(cb1) ;
        listBill.add(cb2) ;
        List<Recharge> listRecharge = new ArrayList<Recharge>() ;
        listRecharge.add(rd1) ;
        listRecharge.add(rd2) ;
        List list = new ArrayList() ;
        Iterator it1 = listRecharge.iterator() ;
        while(it1.hasNext()) {
            list.add(it1.next()) ;
        }
        Iterator it2 = listBill.iterator() ;
        while(it2.hasNext()) {
            list.add(it2.next()) ;
        }
        //排序前
        System.out.println("排序前："+new Gson().toJson(list));
        //排序後
        ComparatorTime comparator=new ComparatorTime();  
        Collections.sort(list, comparator); 
        System.out.println("正序："+new Gson().toJson(list));
        //排序後逆序
        Collections.reverse(list);
        System.out.println("逆序："+new Gson().toJson(list));
    }
}

測試結果