对象属性的排序

  主要是利用jakarta的common提供的方面来进行排序。具体演示看代码

 1、创建一个需要排序的对象

1. public class SignMessage {
2.     
3.     private long id;
4.     
5.     private String name;
6.     
7.     private int count;
9.     public long getId() {
10.         return id;
11.     }
13.     public void setId(long id) {
14.         this.id = id;
15.     }
17.     public String getName() {
18.         return name;
19.     }
21.     public void setName(String name) {
22.         this.name = name;
23.     }
25.     public int getCount() {
26.         return count;
27.     }
29.     public void setCount(int count) {
30.         this.count = count;
31.     }
33. }

创建我们的排序类，将分为对单个属性的升序降序排列。对多个属性的升序降序排列，对多个属性的升序降序排列将采用自我实现比较接口的方式和使用排序chain方式进行实现

1. package com.kongqz.test;
3. import java.util.ArrayList;
4. import java.util.Collections;
5. import java.util.Comparator;
6. import java.util.List;
7. import org.apache.commons.beanutils.BeanComparator;
8. import org.apache.commons.collections.comparators.ComparatorChain;
9. import org.apache.commons.collections.comparators.ReverseComparator;
10. /**
11.  * 针对javabean的某个属性或者多个属性做排序处理
12.  * @author kongqz
13.  * @date 2008-09-22
14.  * 
15.  * */
16. public class CompareTest {
17.     
18.     /**
19.      * 初始化一个需要排序的集合
20.      * */
21.     public List<SignMessage> initData(){
22.         
23.         List<SignMessage> tmp = new ArrayList();
24.         for(int i=100;i>0;i--){
25.             
26.             SignMessage sm = new SignMessage();
27.             sm.setId(i);
28.             if(i<50){
29.                 sm.setCount(i+10000);
30.             }else{
31.                 sm.setCount(i+9950);
32.             }
33.             
34.             sm.setName("kongqz"+i);
35.             tmp.add(sm);
36.             
37.         }
38.         for(SignMessage sm:tmp){
39.             System.out.println(sm.getName()+"-["+sm.getCount()+"]");
40.         }
41.         return tmp;
42.     }
43.     /**
44.      * 对对象的单个属性count进行排序
45.      * @author kongqz
46.      * */
47.     public List<SignMessage> orderSM(List<SignMessage> smList){
48.         //创建针对某个属性的升序比较
49.         Comparator countCompare = new BeanComparator("count");
50.         //默认的是升序，整一个降序
51.         countCompare=new ReverseComparator(countCompare);
52.         //开始排序
53.         Collections.sort(smList,countCompare);
54.         return smList;
55.     }
56.     
57.     /**
58.      * 直接实现排序的Comparator接口。重构其比较函数，让我们的业务逻辑直接写入
59.      * @author kongqz
60.      * */
61.     public List<SignMessage> orderMutiSM(List<SignMessage> smList){
62.         
63.         Comparator ccc =new Comparator() {
64.             public int compare(Object o1, Object o2) {
66.                 SignMessage sm1 = (SignMessage) o1;
67.                 SignMessage sm2 = (SignMessage) o2;
68.                 
69.                 //请在此处扩展你的计算逻辑
70.                 int count1 = sm1.getCount();
72.                 int count2 = sm2.getCount();
73.                 
74.                 Integer ct1 = new Integer(count1);
76.                 Integer ct2 = new Integer(count2);
78.                 if(count1!=count2){
79.                      //升序降序通过ct2和ct1谁在前控制
80.                      return ct2.compareTo(ct1);
81.                 }else{
82. //                  System.out.println("调用id比较了");
83.                     Integer id1=new Integer(sm1.getId()+"");
84.                     Integer id2=new Integer(sm2.getId()+"");
85.                     //升序降序通过id1和id2谁在前控制
86.                     return id1.compareTo(id2);
87.                 }
88.                
89.             }
90.         };
91.         //将属性值为null的时候就是根据实现的Comparator来进行比较了，此处可以查看commons-beanutils源代码确认
92.         Comparator objCompare = new BeanComparator(null,ccc );
94.         //这个默认的是升序
95.         Collections.sort( smList, objCompare );
96.         
97.         return smList;
98.     }
99.     /**
100.      * order　by count desc,id asc方式的排序
101.      * @author kongqz
102.      * 此排序调用已有的jakarta的接口实现
103.      * */
104.     public List<SignMessage> sortMutiSM(List<SignMessage> smList){
105.         //创建多属性排序链
106.         ComparatorChain cc = new ComparatorChain();
107.         //第一个参数是指定排序的属性，第二个参数指定降序升序
108.         cc.addComparator(new BeanComparator("count"),true);
109.         cc.addComparator(new BeanComparator("id"),false);
110.         Collections.sort( smList, cc );
111.         return smList;
112.     }
113.     
114.     public static void main(String[] args){
115.         CompareTest ct = new CompareTest();
116.         
117.         System.out.println("----------------单个javabean属性的排序-------------------------");
118.         List<SignMessage> singleList = ct.initData();
119.         List<SignMessage> singleTmpList=ct.orderSM(singleList);
120.         System.out.println("-----------------javabean的单个属性排序，排序后-------------------");
121.         for(SignMessage sm:singleTmpList){
122.             System.out.println(sm.getName()+" ["+sm.getCount()+"]");
123.         }
124.         
125.         
126.         System.out.println("----------------重载接口进行多属性的排序-------------------------");
127.         //初始化一个需要排序的集合
128.         List<SignMessage> smList = ct.initData();
129.         List<SignMessage> tmpList = ct.orderMutiSM(smList);
130.         System.out.println("-------------------------直接实现多属性的排序，排序后------------");
131.         for(SignMessage sm:tmpList){
132.             System.out.println(sm.getName()+" ["+sm.getCount()+"]");
133.         }
134.         
135.         System.out.println("----------------使用jakarta方法进行排序-------------------------");
136.         //初始化一个需要排序的集合
137.         List<SignMessage> sList = ct.initData();
138.         //进行排序
139.         List<SignMessage> tmpList1 = ct.sortMutiSM(sList);
140.         System.out.println("-------------------------使用jakarta提供的排序chain进行排序，排序后------------");
141.         for(SignMessage sm:tmpList1){
142.             System.out.println(sm.getName()+" ["+sm.getCount()+"]");
143.         }
144.     }
146. }

 

运行main函数，控制台看具体执行效果