谁能介绍下集合中的comparable接口和comparator接口

Question

我要实现排序功能!是不是可以用题目中的两种方法!大家介绍下这两种方法!
写两个小例子最好

Answer 1

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

Answer 2

要实现排序功能,一般有两种途径,这里对基本类型不适用,基本类型一般有Arrays中的静态方法.1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
有关Comparable: http://blog.csdn.net/treeroot/archive/2004/09/09/99613.aspx
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.看一下Comparator的全部内容:public interface Comparator {
　　int compare(Object o1, Object o2);
　　boolean equals(Object obj);
} 
定义了两个方法,其实我们一般都只需要实现compare方法就行了,因为类都是默认从Object继承
所以会使用Object的equals方法.
Comparator一般都作为一个匿名类出现,对于没有实现Comparable的对象的集合,排序的时候
需要指定一个Comparator.这里举例说明
对于实现了Comparable的类我们就用最简单的Integer
List list=new ArrayList();
list.add(new Integer(3));
list.add(new Integer(53));
list.add(new Integer(34));
Collections.sort(list);对于没有实现Comparable的,我们就用Object,按照hashCode大小来排序.
List list= new ArrayList();
list.add(new Object());
list.add(new Object());
list.add(new Object());
Collections.sort(list,new Comparator(){ public int compare(Object o1, Object o2){
　　　　　　　　　　　　　　　　　　　　return (o1.hashCode()-o2.hashCode());}}); 
对集合排序的例子 
 
import java.util.ArrayList;import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/*
 * 
 * 
 *//**
 * 
 */class BookType{
 String idsn;
 String name;
 /**
  * @param idsn
  * @param name
  */
 public BookType(String idsn, String name)
 {
  super();
  this.idsn = idsn;
  this.name = name;
 }
 /**
  * @return Returns the idsn.
  */
 public String getIdsn()
 {
  return idsn;
 }
 /**
  * @param idsn The idsn to set.
  */
 public void setIdsn(String idsn)
 {
  this.idsn = idsn;
 }
 /**
  * @return Returns the name.
  */
 public String getName()
 {
  return name;
 }
 /**
  * @param name The name to set.
  */
 public void setName(String name)
 {
  this.name = name;
 }
}
public class TestCollections
{ public static void main(String[] args)
 {
  List list=new ArrayList();
  list.add(new BookType("1","k"));
  list.add(new BookType("5","z"));
  list.add(new BookType("4","g"));
  
  Comparator OrderIsdn = new Comparator(){
   public int compare(Object o1, Object o2){
    BookType b1=(BookType)o1;
    BookType b2=(BookType)o2;
    return (b1.getIdsn().hashCode()-b2.getIdsn().hashCode());
   }
  };
  
  Comparator OrderName = new Comparator(){
   public int compare(Object o1, Object o2){
    BookType b1=(BookType)o1;
    BookType b2=(BookType)o2;
    return (b1.getName().hashCode()-b2.getName().hashCode());
   }
  };
  
  Collections.sort(list,OrderName); 
  Collections.reverse(list);
  
  for(int i=0;i   BookType ss=(BookType)list.get(i);
   System.out.print(ss.getIdsn());
   System.out.println(ss.getName());
  }
  
 }
}

Answer 3

public class CompareToImplementsComparator implements Comparator {
　　　 public int compare(Object o1, Object o2) {
　　　　　　int i=(Integer)o1;
　　　　　 　int j=(Integer)o2;
　　　　　 　if(i>j){
　　　　　　　　return 1;
　　　　　　 　}
　　　　　return 0;
　　　　　}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
　List<Integer> list=new ArrayList();
　for(int i=10;i>0;i--){
　　　　　 list.add(i);
　}
　Collections.sort(list, new CompareToImplementsComparator());
　　for(int j=0;j<list.size();j++){
　　　　　 　System.out.println(list.get(j));
　}
}
}

Answer 4

前者将比较代码嵌入自身类中，而后者在一个独立的类中实现比较（策略模式，类似STL中的函数对象）。public class Test implements Comparable{            private int value = 0;//使用Object，而不是Test，否则不形成对Comparable接口中compareTo方法的实现public int compareTo(Object obj){          if((Test)obj.value > value){               return -1;}else if((Test)obj.value == value){      return 0;}else{    return 1;}}} public class MyComparator implements Comparator
{  //传入的两个对象的比较        public int compare(Object o1,Object o2){                  if((Test)o1.value < (Test)o2.value){                                       return –1;                              }else if((Test)o1.value == (Test)o2.value){                                       return 0;                              }else{                                       return 1;  }}   //跟其它Comparator比较，一般不覆盖，直接使用Object的equals方法                           public boolean equals(Object obj){  }       } Test[]  tests = new Test[10];Arrays.sort(tests);Arrays.sort(tests,new MyComparator()); 理解和收集到的我认为很经典的解释整理如下:   comparable是通用的接口，用户可以实现它来完成自己特定的比较，而comparator可以看成一种算法的实现，在需要容器集合 collection需要比较功能的时候，来指定这个比较器，这可以看出一种设计模式，将算法和数据分离，就像C++ STL中的函数对象一样。
前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。可以说前者属于“静态绑定”，而后者可以“动态绑定”。   一个类实现了Camparable接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样，这个类对象组成的集合就可以使用Sort方法排序了。
   而Comparator的作用有两个：
  1. 如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过  Comparator来实现比较算法进行排序
  2. 为了使用不同的排序标准做准备，比如：升序、降序或其他什么序