集合框架学习之排序Comparable&Comoarator

1、内置引用数据类型比较（常用）

1.1  Comparable

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

2、字符：比较的Unicode码只差

3、字符串：

1）如果其中一个是另外一个其实开始的子传，返回长度子差

2）否则返回第一个不相等的Unicode码之差

4、java.util.Date:根据日期的长整形数比较

例1：

 /**
  * 引用数据类型的排序
  * @author qjc
  *
  * 2016-3-10
  */
 public class ComparableDemo {
     /**
      * 数组排序（使用泛型方法）
      * @param arr
      */
     public static <T extends Comparable<T>> void sort(T[] arr){
         boolean sortede = true; //有序标示则不用比较
         for (int i = 0; i < arr.length-1; i++) {
             for (int j = 0; j < arr.length-1-i; j++) {
                 sortede = true;
                 if(((Comparable)arr[j]).compareTo(arr[j+1]) > 0){
                     T temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                     sortede = false;
                 }
                 if(sortede){ //减少趟数
                     break;
                 }
             }
         }
     }
     public static void main(String[] args) {
         String[] arr = {"abc","ab","a"};
         sort(arr);
         for(String s : arr){
             System.out.println(s);
         }
         //结果： a ab abc
     }
 }

1.2  Comparator

提供排序的比较器，业务比较器

实现java.util.Comparator接口

重写public intcompare(T o1,T o2)

作用：

解耦：独立于实体类

方便：便于应用各种排序规则

例2：

 /**
  * 排序规则的业务类
  * @author qjc
  *
  * 2016-3-10
  */
 public class StringComp implements java.util.Comparator {
     /**
      * 按长度比较大小
       *     正数: >0
       *     负数： <0
       *     0   ：==
      */
     @Override
     public int compare(Object o1, Object o2) {
         int len1 = ((String) o1).length();
         int len2 = ((String) o2).length();
         return len1 - len2;
     }
 }

 /**
  * Comparator排序
  * @author qjc
  *
  * 2016-3-10
  */
 public class ComparatorDemo {
     /**
      * 数组的排序（升序）+Comparator接口
      * @param arr
      * @param comm
      */
     public static <T> void sort(Object[] arr,Comparator<T> comm){
         boolean sorted = true;
         for (int i = 0; i < arr.length-1; i++) {
             for (int j = 0; j < arr.length-1-i; j++) {
                 if(comm.compare((T)arr[j], (T)arr[j+1]) > 0){
                     Object temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                     sorted = false;
                 }
                 if(sorted){
                     break;
                 }
             }
         }
     }
     @Test
     public void testSort(){
         String[] arr = {"dss","fdss","fefeef"};
         sort(arr, new StringComp());
         System.out.println(Arrays.toString(arr));
         //输出结果： [dss, fdss, fefeef]
     }
 }

1.3 Collections之排序

Collections工具类，此类完全由在collection 上进行操作或返回 collection 的静态方法组成。

提供了大量便于处理容器的方法

关于排序：

1、public static <T extends Comparable<?super T>> void sort(List<T> list)

2、public static<T> void sort(List<T> list,Comparator<? super T> c)

2、引用类型（自定义）

2.1  Comparable

按业务规则排序：

1、实体类：java.lang.Comparable + compareTo

例3：

新闻信息排序：按时间（第一排序）、点击量（第二排序）、标题（第三排序）

/**
 * 新闻条目实体类
 * @author qjc
 *
 * 2016-3-10
 */
public class NewItem implements java.lang.Comparable<NewItem>{
    //标题
    private String title;
    //点击量
    private int hits;
    //时间
    private Date pubTime;
    //时间降序（第一排序） + 点击量升序（第二排序） + 标题降序
    @Override
    public int compareTo(NewItem ntm) {
        int result = 0;
        //比较时间
        result = - this.pubTime.compareTo(ntm.pubTime); //降序
        if(0 == result){
            //点击量
            result = this.hits - ntm.hits; //升序
            //点击量相同
            if(0 == result){
                //标题
                result = - this.title.compareTo(ntm.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("\n");
        return sb.toString();
    }
    //getter and setter...
}

/**
 *
 * @author qjc
 *
 * 2016-3-10
 */
public class NewItemApp {

    @Test
    public void test(){
        List<NewItem> news = new ArrayList<>();
        news.add(new NewItem("袁贵仁：十三五期间9年义务教育不会延长",100,
                new Date(System.currentTimeMillis()-1000*60*60)));
        news.add(new NewItem("沪指收跌2.02%危及2800点 分析:三因素影响A股",999,
                new Date()));
        news.add(new NewItem("女足回京球迷献吻 盼奥运进四强拿牌",888,
                new Date(System.currentTimeMillis()+1000*60*60)));
        System.out.println("排序前："+news);
        System.out.println("====================================");
        //Collections工具类排序（默认升序）
        Collections.sort(news);
        System.out.println("排序后："+news);
    }
}

 输出结果：

排序前：

[标题：袁贵仁：十三五期间9年义务教育不会延长时间：2016-03-10 21:33:28点击量：100

,标题：沪指收跌2.02%危及2800点分析:三因素影响A股时间：2016-03-10 22:33:28点击量：999

,标题：女足回京球迷献吻盼奥运进四强拿牌时间：2016-03-1023:33:28点击量：888

]

====================================

排序后：

[标题：女足回京球迷献吻盼奥运进四强拿牌时间：2016-03-10 23:33:28点击量：888

,标题：沪指收跌2.02%危及2800点分析:三因素影响A股时间：2016-03-10 22:33:28点击量：999

,标题：袁贵仁：十三五期间9年义务教育不会延长时间：2016-03-1021:33:28点击量：100

]

2.2  Comparator

2、业务排序类：java.util.Comparator + compare

优点：

• 解耦：与实体类分类
• 方便：应对多变排序规则

例4：

按商品价格排序

 /**
  * 商品类
  * @author qjc
  *
  * 2016-3-10
  */
 public class Goods {
     //商品名
     private String name;
     //收藏量
     private int fav;
     //价格
     private double price;
     @Override
     public String toString() {
         return "商品名："+this.name+",收藏量"+this.fav+",价格"+this.price+"\n";
     }
     //getter and setter...
 }

 /**
  * 按价格排序的业务类（降序）
  * @author qjc
  *
  * 2016-3-10
  */
 public class GoodsPriceComp implements java.util.Comparator<Goods>{

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

 /**
  *
  * @author qjc
  *
  * 2016-3-10
  */
 public class GoodsApp {
     @Test
     public void test(){
         List<Goods> list = new ArrayList<>();
         list.add(new Goods("iphone 5SE",1800,3888));
         list.add(new Goods("iphone 7",1998,5888));
         list.add(new Goods("Galaxy S7",2000,4888));
         System.out.println("排序前："+list);
         //排序
         Collections.sort(list,new GoodsPriceComp());
         System.out.println("排序后："+list);
     }
 }

输出结果：

排序前：

[商品名：iphone 5SE,收藏量1800,价格3888.0

,商品名：iphone 7,收藏量1998,价格5888.0

,商品名：Galaxy S7,收藏量2000,价格4888.0

]

排序后：

[商品名：iphone 7,收藏量1998,价格5888.0

,商品名：Galaxy S7,收藏量2000,价格4888.0

,商品名：iphone 5SE,收藏量1800,价格3888.0

]

3.3  TreeSet和TreeMap集合排序

3.3.1 TreeSet:
     数据元素可以排序且不可以重复

• 确保元素实体可以排序
• 排序比较器

publicTreeSet(Compartor<? super E> comparator)

对比Set接口：HashSet,元素必须重写hashcode和equals方法。

去重:比较等于0即重复

例5：使用TreeSet无参构造实体类实现Comparable

/**
 * 实体类实现Comparable
 * @author qjc
 *
 * 2016-3-11
 */
public class Worker implements java.lang.Comparable<Worker>{
    //工种
    private String type;
    //工资
    private double salary;
    //按工资升序
    @Override
    public int compareTo(Worker o) {
        return this.salary>o.salary?1:this.salary==o.salary?0:-1;
    }
    //getter and setter..
}

/**
 * 使用Comparable排序
 * @author qjc
 *
 * 2016-3-11
 */
public class TreeSetDemo2 {
    public static void main(String[] args) {
        Worker w1 = new Worker("教师",12000);
        Worker w2 = new Worker("公务员",8000);
        Worker w3 = new Worker("程序猿",6000);
        TreeSet<Worker> employeess = new TreeSet<>();
        employeess.add(w1);
        employeess.add(w2);
        employeess.add(w3);
        System.out.println(employeess);
    }
}

例6：使用TreeSet带参构造使用Comparator比较器

 public class Person {
     private String name;
     //帅气指数
     private int handsome;
     //geter and setter..
 }

 /**
  * 提供解耦方式排序
  * @author qjc
  *
  * 2016-3-11
  */
 public class TreeSetDemo {
     public static void main(String[] args) {
         Person p1 = new Person("刘德华", 2000);
         Person p2 = new Person("梁朝伟", 2200);
         Person p3 = new Person("鹿晗", 1500);
         //依次放到TreeSet容器中，使用排序的业务类（内部类）
         TreeSet<Person> persons = new TreeSet<>(
                 new java.util.Comparator<Person>(){
                     @Override
                     public int compare(Person o1, Person o2) {
                         //降序
                         return -(o1.getHandsome() - o2.getHandsome());
                     }
                 }
                 );
         //TreeSet 在添加数据时排序
         persons.add(p1);
         persons.add(p2);
         persons.add(p3);
         System.err.println(persons);
     }
 }
  

注意：

在添加数据时排序，数据更改不会影响原来的顺序，不要修改数据，否则可能重复。 ---可以使用final修饰

3.3.2 TreeMap:

• 确保key可以排序
• 提供比较器

publicTreeMap(Comparator<? super K> comparator)

例：与TreeSet同理

总结：

相同点：

Comparable和Comparator都是用来实现集合、数组中元素的比较、排序的

不同点：

1、Comparable是在集合内部定义的方法实现的排序，而Comparator是在集合外部实现的排序，

所以，如想实现排序，就需要在集合外定义 Comparator接口的方法或在集合内实现 Comparable接口的方法。

Comparator位于包java.util下，而Comparable位于包java.lang下

2、Comparable是一个对象，本身就已经支持自比较所需要实现的接口（如Integer、String、Float、Double、Date等底层都实现了Comparable接口 自己就可以完成比较大小操作）

自定义的类要在加入list容器中后能够排序，可以实现Comparable接口，在用Collections类的sort方法排序时，如果不指定Comparator，那么就以自然顺序排序，这里的自然顺序就是实现Comparable接口设定的排序方式，并且是升序。

3、Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

Comparator 与实体类分类于系统解耦优点，比如说例4按商品排序，如果需要按名称排序（或改升序、降序），只需要在业务类修改，在应变多变规则时方便程序修改和维护。所以推荐使用Comparator。