java实现两个不同list对象合并后并排序

最近工作上遇到一个要求两个不同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));
    }
}

测试结果

代码仅供大家学习参考 转载请注明来处：http://blog.csdn.net/wenteryan