Comparable和Comparator

Comparable

　　常用的内置引用数据类型比较：

　　　　1. Integer、Float、Double直接比较基本数据类型的大小

　　　　2. 字符比较Unicode码之差

　　　　3. 如果其中一个是另外一个起始开始的子串，返回长度之差否则返回第一个不相等的unicode码之差

　　　　4. java.util.Date：根据日期的长整型比较

　　自定义实体类比较：

　　　　1. 实体类需要实现java.lang.Comparable接口

　　　　2. 重写compareTo方法

 1 /**
 2  * 新闻条目实体类
 3  * @author Administrator
 4  *
 5  */
 6 public class NewsItem implements java.lang.Comparable<NewsItem>{
 7     //标题
 8     private String title;
 9     //点击量
10     private int hits;
11     //时间
12     private Date pubTime;
13     public NewsItem() {
14     }
15     
16     
17     public NewsItem(String title, int hits, Date pubTime) {
18         super();
19         this.title = title;
20         this.hits = hits;
21         this.pubTime = pubTime;
22     }
23 
24 
25     public String getTitle() {
26         return title;
27     }
28     public void setTitle(String title) {
29         this.title = title;
30     }
31     public int getHits() {
32         return hits;
33     }
34     public void setHits(int hits) {
35         this.hits = hits;
36     }
37     public Date getPubTime() {
38         return pubTime;
39     }
40     public void setPubTime(Date pubTime) {
41         this.pubTime = pubTime;
42     }
43 
44     //时间降序 +点击量升序+标题降序
45     @Override
46     public int compareTo(NewsItem o) {
47         int result =0;
48         //比较 时间
49         result =-this.pubTime.compareTo(o.pubTime); //降序
50         if(0==result){ //时间相同
51             //点击量 
52             result =this.hits-o.hits; //升序
53             if(0==result){ //点击量相同
54                  //标题
55                 result=-this.title.compareTo(o.title);//降序
56             }
57         }        
58         
59         return result;
60     }
61     
62     @Override
63     public String toString() {
64         StringBuilder sb =new StringBuilder();
65         sb.append("标题:").append(this.title);
66         sb.append(",时间:").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime));
67         sb.append(",点击量:").append(this.hits).append("\n");
68         return sb.toString();
69     }
70     
71 }
示例代码

Comparator比较器

　　作用：

　　　　1. 解耦：独立于实体类

　　　　2. 方便应对各种排序规则

　　自定义实体类比较器：

　　　　1. 实体类需要实现java.util.Comparator接口

　　　　2. 重写compare方法

 1 /**
 2  * 实体类
 3  * @author Administrator
 4  *
 5  */
 6 public class Goods {
 7     //商品名称
 8     private String name;
 9     //价格
10     private double price;
11     //收藏量
12     private int fav;
13     public Goods() {
14         // TODO Auto-generated constructor stub
15     }
16     
17     
18     
19     public Goods(String name, double price, int fav) {
20         super();
21         this.name = name;
22         this.price = price;
23         this.fav = fav;
24     }
25 
26 
27 
28     public String getName() {
29         return name;
30     }
31     public void setName(String name) {
32         this.name = name;
33     }
34     public double getPrice() {
35         return price;
36     }
37     public void setPrice(double price) {
38         this.price = price;
39     }
40     public int getFav() {
41         return fav;
42     }
43     public void setFav(int fav) {
44         this.fav = fav;
45     }
46     
47     
48     @Override
49     public String toString() {
50         return "商品名:"+name+",收藏量"+this.fav+",价格:"+this.price+"\n";
51     }
52 }
53 
54 /**
55  * 按收藏量排序的业务类 （升序）
56  * @author Administrator
57  *
58  */
59 public class GoodsFavComp implements java.util.Comparator<Goods> {
60 
61     @Override
62     public int compare(Goods o1, Goods o2) {
63         return o1.getFav()-o2.getFav();
64     }
65 }
示例代码

　　

  1 /**
  2  * 排序
  3  * @author Administrator
  4  *
  5  */
  6 public class Utils {
  7        /**
  8         * List的排序+比较器
  9         * @param list
 10         * @param com
 11         */
 12        public static  <T> void sort(List<T> list,Comparator<T> com){
 13               //第一步:转成数组
 14               Object[] arr =list.toArray();
 15               sort(arr,com);
 16               //第二步:改变容器中对应的值
 17               for(int i=0;i<arr.length;i++){
 18                      list.set(i, (T)(arr[i]));
 19               }
 20        }
 21        
 22        
 23        /**
 24         * 数组的排序 （降序）+Comparator接口
 25         * @param arr
 26         */
 27        public static <T> void sort(Object[] arr,Comparator<T> com){
 28               //从大到小排序 降序
 29                      boolean sorted= true;
 30                      int len =arr.length;
 31                      for(int j=0;j<len-1;j++){ //趟数
 32                             sorted =true; //假定有序
 33                             for(int i=0;i<len-1-j;i++){ //次数
 34                                    if(com.compare((T)arr[i], (T)arr[i+1])<0){
 35                                           Object temp = arr[i];
 36                                           arr[i] =arr[i+1];
 37                                           arr[i+1] =temp;
 38                                           sorted =false; //假定失败
 39                                    }
 40                             }
 41                             if(sorted){ //减少趟数
 42                                    break;
 43                             }
 44                      }
 45        }
 46        
 47        
 48        
 49        /**
 50         * 容器排序 (使用泛型方法)
 51         */
 52        public static <T extends Comparable<T>> void sort(List<T> list){
 53               //第一步:转成数组
 54               Object[] arr =list.toArray();
 55               sort(arr);
 56               //第二步:改变容器中对应的值
 57               for(int i=0;i<arr.length;i++){
 58                      list.set(i, (T)(arr[i]));
 59               }
 60               
 61        }
 62        
 63        
 64        /**
 65         * 数组排序 (使用泛型方法)
 66         */
 67        public static <T extends Comparable<T>> void sort(T[] arr){
 68               //从大到小排序 降序
 69               boolean sorted= true;
 70               int len =arr.length;
 71               for(int j=0;j<len-1;j++){ //趟数
 72                      sorted =true; //假定有序
 73                      for(int i=0;i<len-1-j;i++){ //次数
 74                             if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
 75                                    T temp = arr[i];
 76                                    arr[i] =arr[i+1];
 77                                    arr[i+1] =temp;
 78                                    sorted =false; //假定失败
 79                             }
 80                      }
 81                      if(sorted){ //减少趟数
 82                             break;
 83                      }
 84               }
 85        }    
 86        
 87        /**
 88         * 数组的排序 （降序）
 89         * @param arr
 90         */
 91        public static void sort(Object[] arr){
 92               //从大到小排序 降序
 93               boolean sorted= true;
 94               int len =arr.length;
 95               for(int j=0;j<len-1;j++){ //趟数
 96                      sorted =true; //假定有序
 97                      for(int i=0;i<len-1-j;i++){ //次数
 98                             if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
 99                                    Object temp = arr[i];
100                                    arr[i] =arr[i+1];
101                                    arr[i+1] =temp;
102                                    sorted =false; //假定失败
103                             }
104                      }
105                      if(sorted){ //减少趟数
106                             break;
107                      }
108               }
109               
110        }
111        
112        
113 }
数组排序工具类

 

posted @ 2018-05-29 03:38  jqbai  阅读(101)  评论(0)    收藏  举报