Java集合中Comparable和Comparator辨析

转载自：http://blog.csdn.net/longshengguoji/article/details/41598741

一.Comparable和Comparator简介

在对集合元素进行比较时一般使用TreeSet.对于简单的数据类型，TreeSet可以直接进行比较。但是对于复杂的数据类型，比如自己定义的数据类型或者类，就需要自己设置比较方法与比较规则了，这时就需要使用Comparable和Comparator。 Comparable和Comparator都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现排序，而Comparator是在集合外部实现的排序。所以如果想对结合排序，需要在集合外定义Comparator接口的方法或在集合内部实现Comparable接口的方法。
一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的结合就可以直接使用sort方法排序。
Comparator是策略模式，就是在不改变对象自身，而用一种策略对象来改变它的行为，将算法和数据分离，Comparator还可以在下面两种环境下使用：
1.类在设计时没有考虑到比较问题而没有实现Comparable接口，则可以通过Comparator来实现排序而不必修改原来的类代码。
2.类设计时实现了Comparable接口，但是后面的使用者却想用一种新的比较规则对类进行比较

二. 用法示例

Comparable排序：
首先定义实现Comparable接口的Item类

package com.collection;
import java.util.Objects;

/**
 * 定义实现Comparable接口的Item类
 *
 */
public class Item implements Comparable<Item>{
    private String description;
    private int partNumber;

    public Item(String aDescription, int aPartNumber)
    {
       description = aDescription;
       partNumber = aPartNumber;
    }

    public String getDescription()
    {
       return description;
    }

    public String toString()
    {
       return "[description="+description+",partNumber="+partNumber+"]";
    }

    public boolean equals(Object otherObject)
    {
       if(this == otherObject)
           return true;
       if(otherObject == null)
           return false;
       if(getClass()!=otherObject.getClass())
           return false;
       Item other = (Item)otherObject;
       return Objects.equals(description, other.description) &&partNumber == other.partNumber;
    }

    public int hashCode()
    {
       return Objects.hash(description,partNumber);
    }

    //重载compareTo方法，设定Item对象的比较方法
    @Override
    public int compareTo(Item other)
    {

       return Integer.compare(partNumber, other.partNumber);      
    }
}

定义对Item进行排序的类，对集合进行排序是使用TreeSet或TreeMap,此处用TreeSet存放集合元素。

package com.collection;
import java.util.TreeSet;
public class ListSortWithComparable
{
    public static void main(String[] args)
    {
       TreeSet<Item> set = new TreeSet<>();
       set.add(new Item("zhuwei",26));
       set.add(new Item("yinyuchun",24));
       set.add(new Item("xiaobai",25));
       set.add(new Item("chun",24));
       for(Item it : set)
       {
           System.out.println(it.toString());
       }
    }
}

Comparator排序实现示例：
首先定义需要排序的类People

package com.collection;

public class People
{
    private String name;
    public String getName()
    {
       return name;
    }
    public void setName(String name)
    {
       this.name = name;
    }
    public int getAge()
    {
       return age;
    }
    public void setAge(int age)
    {
       this.age = age;
    }
    private int age;

    public People(String name,int age)
    {
       this.name = name;
       this.age = age;
    }
    public String toString()
    {
       return ("name:"+this.name+",age:"+this.age);
    }
}

接着建立对People进行排序的类，利用Comparator进行排序有两种方法，第一种方法是把需要排序的People对象放在List集合中，然后调用Collection.sort(list,comparator)方法进行排序；第二中排序方法是直接把Comparator对象传递给TreeSet的构造器，并重载Comparator类的compara方法，指定排序规则，这种方法不需要让People类实现Comparator接口，且其代码较简洁。

Comparator

package com.collection; 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class ListSortWithComparator
{  
    publicstatic void main(String[] args)
    {
       /*
        * 使用comparator进行排序的第一种方法，
        * 定义一个实现Comparator接口的类，并重载compara方法，设定比较规则
        * 利用Collection.sort(list,comparator)方法实现排序，
        * Collection.sort(list,comparator)方法的第一个参数为List类型，因此要排序的元素需要放在List集合中
        */
       List<People>list = new ArrayList<>();
       list.add(newPeople("zhuwei",26));
       list.add(newPeople("yinyuchun",25));
       list.add(newPeople("xiaobai",26));

       MComparatorcomparator = new MComparator();

       Collections.sort(list,comparator);

       for(Peoplep:list)
       {
           System.out.println(p.toString());
       }


       /*
        * 使用comparator进行排序的第二种方法，
         * 该方法不需要People实现Comparator接口
        * 直接Comparator对象传递给TreeSet的构造器，
        * 并重载Comparator类的compara方法，指定排序规则
        */
//     SortedSet<People>set = new TreeSet<>(
//            newComparator<People>()
//            {
//
//                //重载Comparator类的compara方法，设定比较规则:按名字降序排列
//                @Override
//                publicint compare(People people1, People people2)
//                {
//                   //TODO Auto-generated method stub
//                   if(people1.getName().compareTo(people2.getName())>0)
//                   {
//                       return-1;
//                   }
//                   else
//                   {
//                       return1;
//                   }
//                  
//                }
//               
//            }
//            );
//     set.addAll(list);
//     System.out.println("输出按降序排列的结果：");
//     for(Peoplep: set)
//     {
//         System.out.println(p.toString());
//     }
    }
}