自定义引用类型放入集合中，按实际业务需求进行排序的两种思路
第一种思路：
（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);
}
}
