引用类型的自定义数据排序——高淇JAVA300讲笔记

自定义类的排序

1.实体类

　　实现java.lang.Comparable接口，重写compareTo方法

2.业务排序类

　　实现java.util.Comparator接口，重写compare方法。一般工作中推荐使用这种，因为比较灵活，可以为每一个单独的排序方法写一个业务排序类。

案例一：实现Comparable接口进行排序

　　有一个新闻类，要求按时间降序+点击量升序+标题降序。

　　 先写一个新闻类，这个类实现了java.lang.Comparable接口，并重写了compareTo()方法。

package com.bjsxt.sort.refType;

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

/**
 * 新闻条目实体类
 *
 */
public class NewsItem implements java.lang.Comparable<NewsItem>{
    //标题
    private String title;
    //点击量
    private int hits;
    //时间
    private Date pubTime;

    //无参构造器
    public NewsItem() {
        super();
    }
    //带参构造器
    public NewsItem(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;
    }
    
    //时间降序+点击量升序+标题降序
    @Override
    public int compareTo(NewsItem o) {
        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;
    }
    @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("
");
        return sb.toString();
    }

}

　　然后再写一个类使用Collections进行排序：

package com.bjsxt.sort.refType;

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

/**
 * 使用Collections
 *
 */
public class NewsItemApp {

    public static void main(String[] args) {
        List<NewsItem> news = new ArrayList<NewsItem>();
        news.add(new NewsItem("美国后怕了，逃跑了悲剧了",50,new Date(System.currentTimeMillis()-1000*60*60)));
        news.add(new NewsItem("中国登上钓鱼岛了，全国欢呼了",100,new Date()));
        news.add(new NewsItem("小日本终于听话了，泪流满面笑了",60,new Date(System.currentTimeMillis()-1000*60*60)));
        System.out.println("排序前：" + news);
        //排序
        Collections.sort(news);
        System.out.println("排序后：" + news);
        
    }
}

　　运行结果：

排序前：[标题：美国后怕了，逃跑了悲剧了，时间：2018-01-21 11:04:57，点击量：50
, 标题：中国登上钓鱼岛了，全国欢呼了，时间：2018-01-21 12:04:57，点击量：100
, 标题：小日本终于听话了，泪流满面笑了，时间：2018-01-21 11:04:57，点击量：60
]
排序后：[标题：中国登上钓鱼岛了，全国欢呼了，时间：2018-01-21 12:04:57，点击量：100
, 标题：美国后怕了，逃跑了悲剧了，时间：2018-01-21 11:04:57，点击量：50
, 标题：小日本终于听话了，泪流满面笑了，时间：2018-01-21 11:04:57，点击量：60
]

 案例二：实现Comparator接口进行排序

　　可以分别按照商品的价格、收藏量排序。

　　先写一个商品的实体类，在这里实体类就不用实现接口了，比较独立。

package com.bjsxt.sort.refType;

/**
 * 实体类
 *
 */
public class Goods {
    //商品名称
    private String name;
    //价格
    private double price;
    //收藏量
    private int fav;
    
    //无参构造器
    public Goods() {
        super();
    }
    
    //有参构造器
    public Goods(String name, double price, int fav) {
        super();
        this.name = name;
        this.price = price;
        this.fav = fav;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getFav() {
        return fav;
    }
    public void setFav(int fav) {
        this.fav = fav;
    }
    
    @Override
    public String toString() {
        return "商品名："+name+"，收藏量："+this.fav+"，价格："+this.price+"
";
    }
    
}

　　然后写业务比较器，在这里实现java.util.Comparator接口，然后重写compare方法。这里分别写了按价格降序，按收藏量升序。如果自己想要其他的排序方式，可以另外单独再写业务比较器，非常灵活。

package com.bjsxt.sort.refType;

/**
 * 按价格排序的业务类（降序）
 *
 */
public class GoodsPriceComp implements java.util.Comparator<Goods>{

    @Override
    public int compare(Goods o1, Goods o2) {
        return -(o1.getPrice()-o2.getPrice()>0?1:(o1.getClass()==o2.getClass()?0:-1));
    }

}

package com.bjsxt.sort.refType;

/**
 * 按收藏量排序的业务类（升序）
 *
 */
public class GoodsFavComp implements java.util.Comparator<Goods>{

    @Override
    public int compare(Goods o1, Goods o2) {
        return o1.getFav()-o2.getFav();
    }

}

　　最后用Collections进行排序：

package com.bjsxt.sort.refType;

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

public class GoodsApp {
    public static void main(String[] args) {
        List<Goods> list = new ArrayList<Goods>();
        list.add(new Goods("老马视频",100,2000));
        list.add(new Goods("老高视频",50,2000));
        list.add(new Goods("老裴视频",1000,1000));
        System.out.println("排序前："+list);
//        Collections.sort(list,new GoodsPriceComp());
        Collections.sort(list,new GoodsFavComp());
        System.out.println("排序后："+list);
        
    }
}

运行结果：

排序前：[商品名：老马视频，收藏量：2000，价格：100.0
, 商品名：老高视频，收藏量：2000，价格：50.0
, 商品名：老裴视频，收藏量：1000，价格：1000.0
]
排序后：[商品名：老裴视频，收藏量：1000，价格：1000.0
, 商品名：老马视频，收藏量：2000，价格：100.0
, 商品名：老高视频，收藏量：2000，价格：50.0
]