java编程排序之自定义类型的集合，按业务需求排序

自定义引用类型放入集合中，按实际业务需求进行排序的两种思路

第一种思路：

　　（1）自定义实体类实现java.lang.Comparable接口，重写public int compareTo(Object obj)方法。自定义业务比较规则

　　（2）利用java.util.Collections类的静态方法sort（List<自定义类型> list）进行排序（默认升序）或者。自己编写排序工具类。冒泡+compareTo(obj)方法

　例子：新闻条目的排序

　　需要排序的实体类，实现Comparable接口，重写方法，自定义排序规则

 package com.zdxy.shangxiaofei;

 import java.text.SimpleDateFormat;
 import java.util.Collections;
 import java.util.Date;

 import javax.tools.JavaCompiler;

 /**
  * 新闻条目的实体类
  * 按时间，点击量，标题。排序
  * 【1】时间降序
  * 【2】时间相同，点击量升
  * 【3】时间相同，点击量相同，标题长度降序。
 * @ClassName: NewItem
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-8 下午6:53:18
 *
  */
 public class NewItem implements java.lang.Comparable<NewItem>{
     private String title;//标题
     private int hits;//点击量
     private Date pubTime;//发布时间

     public NewItem() {
         super();
     }

     /**
      * 第一种思路：实体类实现java.lang.Comparable接口，compareTo方法，在方法中写排序规则
      *
      * 时间降序+点击量升序+标题降序
     * @Title: compareTo
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @author 尚晓飞
     * @date 2014-8-8 下午6:59:03
     * @param o
     * @return
     * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     @Override
     public int compareTo(NewItem o) {
         // TODO Auto-generated method stub
         int result=0;
         //比较发布时间（降序）(内置时间类，有排序功能，但是是升序)
         result=-this.pubTime.compareTo(o.pubTime);
         //如果发布时间相同，则按点击量排序
         if(0==result){
             //比较点击量(升序)
             result=this.hits-o.hits;
             //如果点击量相同，则按标题长度排序（降序）
             if(0==result){
                 //比较标题(长度降序)
                 result=-this.title.compareTo(o.title);
                 return result;
             }else{
                 return result;
             }
         }else{
             return result;
         }
     }

     /**
      * 重写toString方法，方便测试打印
     * @Title: toString
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @author 尚晓飞
     * @date 2014-8-8 下午7:20:55
     * @return
     * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         StringBuilder sb=new StringBuilder();
         sb.append("标题：").append(this.title);
         sb.append("---发布时间：").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime));//将时间按某种格式输出
         sb.append("---点击量：").append(this.hits).append("\n");//加一个回车

         return sb.toString();

     }

     public NewItem(String title, int hits, Date pubTime) {
         super();
         this.title = title;
         this.hits = hits;
         this.pubTime = pubTime;
     }

     public String getTitle() {
         return title;
     }

     public void setTitle(String title) {
         this.title = title;
     }

     public int getHits() {
         return hits;
     }

     public void setHits(int hits) {
         this.hits = hits;
     }

     public Date getPubTime() {
         return pubTime;
     }

     public void setPubTime(Date pubTime) {
         this.pubTime = pubTime;
     }

 }

　　利用Collections工具类，对实体类的集合进行排序

 package com.zdxy.shangxiaofei;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;

 /**
  * 使用Collections进行集合排序（Collections中的排序默认是升序）
 * @ClassName: Test
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-8 下午7:12:03
 *
  */
 public class Test {
     public static void main(String[] args) {
         List<NewItem> news=new ArrayList<NewItem>();
         news.add(new NewItem("小日本，听话，泪流满面",60,new Date(System.currentTimeMillis()-1000*60*60)));
         news.add(new NewItem("中国登上钓鱼岛了,全国欢呼",100,new Date()));
         news.add(new NewItem("美国后怕了，逃跑了悲剧了", 50, new Date(System.currentTimeMillis()-1000*60*60)));

         //要求，先按时间降序，再按点击量升序，后按标题降序

         //排序前
         System.out.println("排序前："+news);

         //排序
         Collections.sort(news);

         //排序后
         System.out.println("排序后："+news);

         /**
          * 打印结果
          * 排序前：[标题：小日本，听话，泪流满面---发布时间：2014-08-08 18:35:14---点击量：60
             , 标题：中国登上钓鱼岛了,全国欢呼---发布时间：2014-08-08 19:35:14---点击量：100
             , 标题：美国后怕了，逃跑了悲剧了---发布时间：2014-08-08 18:35:14---点击量：50
             ]
             排序后：[标题：中国登上钓鱼岛了,全国欢呼---发布时间：2014-08-08 19:35:14---点击量：100
             , 标题：美国后怕了，逃跑了悲剧了---发布时间：2014-08-08 18:35:14---点击量：50
             , 标题：小日本，听话，泪流满面---发布时间：2014-08-08 18:35:14---点击量：60]
             */
     }
 }

　　

第二种思路

　　（1）自己编写业务比较规则类。实体类不用实现任何借口。业务比较规则类实现java.util.Comparator接口。重写public int compare(String o1, String o2)方法，编写排序规则

　　（2）利用java.util.Collections类的静态方法sort（List<自定义类型> list）进行排序（默认升序）或者。自己编写排序工具类。冒泡+compareTo(obj)方法　

一般推荐使用第二种思路。

第二种思路（1）排序规则和实体类解耦。当业务发生变化，可以灵活改变。

　　　　　（2）如果项目是接手别的公司，实体类无源代码，则可以编写排序规则业务类。

例子：淘宝商品的排序

实体类+自定义的排序业务类

 package com.zdxy.shangxiaofei;
 /**
  *按商品的收藏量降序
  *按商品的价格升序
  *按商品的名字降序
 * @ClassName: Goods
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-8 下午7:45:28
 *
  */
 public class Goods {
     private int fav;//收藏量
     private double price;//价格
     private String name;//商品名

     public Goods() {
         super();
     }

     public Goods(int fav, double price, String name) {
         super();
         this.fav = fav;
         this.price = price;
         this.name = name;
     }

     /**
      * 重写toString()便于测试
     * @Title: toString
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @author 尚晓飞
     * @date 2014-8-8 下午7:49:03
     * @return
     * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         return "商品名："+this.name+"---收藏量"+this.fav+"---价格:"+this.price;
     }

     public int getFav() {
         return fav;
     }

     public void setFav(int fav) {
         this.fav = fav;
     }

     public double getPrice() {
         return price;
     }

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

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

 }

 /**
  * 只按收藏量进行降序排序的排序业务类
 * @ClassName: FavComparator
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-11 上午8:54:22
 *
  */
 public class FavComparator implements java.util.Comparator<Goods> {

     @Override
     public int compare(Goods o1, Goods o2) {
         // TODO Auto-generated method stub
         int o1Fav=o1.getFav();
         int o2Fav=o2.getFav();
         return -(o1Fav-o2Fav);//因为Collections.sort(list,comparator)默认是升序，所以需要加-号
     }

 }

 /**
  * 自定义业务排序类，与实体类解耦。
  * 业务需求：
  * 【1】先按收藏量进行降序
  * 【2】收藏量相同，则按价格升序
  * 【3】收藏量和价格都相同，则按名字降序
 * @ClassName: AllComparator
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-11 上午9:05:38
 *
  */
 public class AllComparator implements java.util.Comparator<Goods> {

     @Override
     public int compare(Goods o1, Goods o2) {

         int result=0;
         //先按收藏量进行排序（降序）
         result=-(o1.getFav()-o2.getFav());
         //如果收藏量相同，相减为O，则按价格升序
         if(result==0){
             //按价格进行排序(升序)
             result=o1.getPrice()-o2.getPrice()>0?1:(o1.getPrice()-o2.getPrice()==0?0:-1);
             //如果价格相同，则按，名字进行降序
             if(result==0){
                 //名字降序
                 result=-(o1.getName().compareTo(o2.getName()));
             }
         }

         return result;
     }

 }

利用Collections工具类，对装有商品对象的集合类进行排序

 package com.zdxy.shangxiaofei;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 /**
  *
 * @ClassName: Test2
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author 尚晓飞
 * @date 2014-8-8 下午7:52:40
 *
  */
 public class Test2 {
     public static void main(String[] args) {
         List<Goods> list=new ArrayList<Goods>();
         list.add(new Goods(10, 100, "面包"));

         list.add(new Goods(50, 200, "a"));
         list.add(new Goods(50,200,"k"));
         list.add(new Goods(50, 200, "z"));
         list.add(new Goods(100, 300, "包子油条"));
         list.add(new Goods(50, 100, "牛奶"));
         //排序前
         System.out.println("排序前:"+list);

         //排序
         Collections.sort(list, new AllComparator());

         //排序后()
         System.out.println("排序后："+list);
     }

     //只按收藏量进行排序的业务类的测试
     public static void testSort1(List list){
         //排序前
                 System.out.println("排序前:"+list);

                 //排序
                 Collections.sort(list, new FavComparator());

                 //排序后(收藏量的降序)
                 System.out.println("排序后："+list);
     }
 }