和氏璧

JAVA Comparable 和Comparator用法

JAVA Comparable 和Comparator用法--转载

名人名言：人类最大的不幸是他没有像眼睑制动器那样器官，使他能在需要时遮住或阻遏一种思想或所有的思想。 ——瓦莱里

ThreeSet可以或许对凑集中的对象排序，当TreeSet想凑集中参加一个对象时，会把它插入到有序的对象序列中。那么TreeSet是如何排序呢？TreeSet支撑两种排序体式格式:天然排序和客户化排序.在默认景象下TreeSet采取天然排序体式格式。
    先来介绍介绍什么是天然排序吧
1、天然排序
   在JDK类库中，有一项目组类实现了Comparable接口，如Integer Double和String等。
Comparable接口有一个comparTo（Object o）办法，它返回整数类型。对于表达式x.compareTo（y），若是返回值为0，则默示x和y相等，若是返回值大于0，则默示x大于y，若是返回值小于0，则默示x小于y.TreeSet凑集调用对象的compareTo（）办法斗劲凑集中的大小，重视鸟不是TreeSet调用它本身的comparTo（）办法而是它调用凑集中对象的comparTo（）办法.TreeSet类本身并没有实现Comparable接口，然掉队行升序分列，这种体式格式称为天然排序.
   有人可能要问TreeSet凑集怎么给对象排序的按对象的什么排序的？
   下面简单总结一哈
    JDK类库中实现了Comparable接口的一些类的排序体式格式

类 BigDecimal BigInteger Byte Double Float Integer Long Short 排序体式格式是	按数字大小排序
类 Character是	按字符的Unicode值的数字大小排序
类 String是	按字符中字符的Unicode值排序

这里必然要灰常重视:应用天然排序时只能向凑集中参加同类型的对象，并且这些对象的类必须实现Comparable接口
下面来说说Comparable接口和Comparator接口的差别
Comparator位于包java.util下，而Comparable位于包 java.lang下

Comparable 是一个对象本身就已经支撑自斗劲所须要实现的接口（如 String、Integer 本身就可以完成斗劲大小操纵，已经实现了Comparable接口）此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的天然排序，类的 compareTo 办法被称为它的天然斗劲办法。

比如你有一个Customer类想让这个类的实例参加凑集后主动就具有某种排序功能只要这些实例参加凑集后就会遵守你给Customer对象设定的体式格式排序
代码:

       Java代码    
     
 package hang.jihe;  
   
 import java.util.HashSet;  
 import java.util.Set;  
   
 public class Customer implements Comparable {  
     private String name;  
   
     private int age;  
   
     public Customer（String name， int age） {  
         this.age = age;  
         this.name = name;  
     }  
   
     public int getAge（） {  
         return age;  
     }  
   
     public void setAge（int age） {  
         this.age = age;  
     }  
   
     public String getName（） {  
         return name;  
     }  
   
     public void setName（String name） {  
         this.name = name;  
     }  
   
     ＠Override  
     public boolean equals（Object obj） {  
         if （this == obj）  
             return true;  
         if （!（obj instanceof Customer））  
             return false;  
         final Customer other = （Customer） obj;  
   
         if （this.name.equals（other.getName（）） && this.age == other.getAge（））  
             return true;  
         else  
             return false;  
     }  
   
     public static void main（String[] args） {  
         Set set = new HashSet（）;  
         Customer customer1 = new Customer（"Tom"， 15）;  
         Customer customer2 = new Customer（"Tom"， 15）;  
         set.add（customer1）;  
         set.add（customer2）;  
         System.out.println（set.size（））;  
     }  
   
     public int compareTo（Object o） {  
         Customer other = （Customer） o;  
   
         // 先遵守name属性排序  
         if （this.name.compareTo（other.getName（）） > 0）  
             return 1;  
         if （this.name.compareTo（other.getName（）） < 0）  
             return -1;  
   
         // 在遵守age属性排序  
         if （this.age > other.getAge（））  
             return 1;  
         if （this.age < other.getAge（））  
             return -1;  
         return 0;  
     }  
   
     ＠Override  
     public int hashCode（） {  
         int result;  
         result = （name == null ？ 0 : name.hashCode（））;  
         result = 29 * result + age;  
         return result;  
     }  
 }  

main办法的类

       Java代码    
     
 package hang.jihe;  
   
 import java.util.Iterator;  
 import java.util.Set;  
 import java.util.TreeSet;  
   
 public class CustomerTester {  
     public static void main（String[] args） {  
         Set set = new TreeSet（）;  
         set.add（new Customer（"Tom"，15））;  
         set.add（new Customer（"Tom"，20））;  
         set.add（new Customer（"Tom"，15））;  
         set.add（new Customer（"Mike"，15））;  
           
         Iterator it = set.iterator（）;  
         while（it.hasNext（））{  
             Customer customer = it.next（）;  
             System.out.println（customer.getName（）+" "+customer.getAge（））;  
         }  
     }  
 }  

       Java代码    
     
 //打印成果  
 Mike 15  
 Tom 15  
 Tom 20  

有人会问重写hashCode（）办法 equals办法干嘛别急慢慢道来

实际上，所有实现 Comparable 的 Java 核心类都具有与 equals 一致的天然排序。java.math.BigDecimal 是个例外，它的天然排序将值相等但正确度不合的 BigDecimal 对象（比如 4.0 和 4.00）视为相等。为了包管TreeSet能正确地排序，请求Customer类的compareTo（）办法与equals（）办法按雷同的规矩斗劲两个Customer对象是否相等.也就是说，若是customer1.equals（customer2）为True，那么customer1.compareTo（customer2）为0。既然重写了equals办法就得重写hashCode（）办法这个大师都知道
大师看一眼成果便知这个遵守升序排序的春秋也是遵守升序

还有要重视哦，对于TreeSet中已经存在的Customer对象，若是批改了它们的name属性或age属性，则TreeSet不会对凑集进行从头排序.例如下边的代码先把customer1和customer2 对象参加到TreeSet凑集中，然后批改customer1的age属性
代码:

       Java代码    
     
 package hang.jihe;  
   
 import java.util.Iterator;  
 import java.util.Set;  
 import java.util.TreeSet;  
   
 public class TreeSetTest {  
     public static void main（String[] args） {  
         Set set = new TreeSet（）;  
         Customer customer1 = new Customer（"Tom"，15）;  
         Customer customer2 = new Customer（"Tom"，16）;  
         set.add（customer1）;  
         set.add（customer2）;  
         //customer1.setAge（20）;//批改customer1实例的age  
           
         Iterator it=set.iterator（）;  
         while（it.hasNext（））{  
             Customer customer=it.next（）;  
             System.out.println（customer.getName（）+" "+customer.getAge（））;  
         }  
     }  
 }  

上边我先把

       Java代码    
     
 customer1.setAge（20）;  

这句注释掉
打印成果是:

       Java代码    
     
 Tom 15  
 Tom 16  

这个是我们要的成果 name 和age都是遵守升序排序的
然后我们把那句作废注释之后的打印成果是:

       Java代码    
     
 Tom 20  
 Tom 16  

Tom 20若是遵守升序应当鄙人边然则却在上边申明TreeSet没有给它从头排序哦在实际应用中Customer对象的name属性和age属性必然应当是可以被批改的，是以不适实用TreeSet来排序。那大师也应当能想到最适实用TreeSet排序的就是不成变类了呗比如Integer，Double，String等所谓不成变类，是指当创建了这个类的实例后，就不容许批改它的属性值。大师今后用还是警惕点好儿！

   客户化排序
   Comparator这个单词啥意思？你知道不？斗劲器的意思学好英语还是挺好滴
   除了天然排序，TreeSet还支撑客户化排序.java.util.Comparator接口供给具体的排序体式格式，指定被斗劲的对象的类型，Comparator有个compar（Type x，Type y）办法，用于斗劲两个对象的大小，当compare（x，y）大于0时默示x大于y，小于0默示x小于y
便是0默示x便是y
   来个例子若是欲望TreeSet遵守Customer对象的name属性进行降序分列，可以先创建一个实现Comparator接口的类
代码:

       Java代码    
     
 package hang.jihe;  
   
 import java.util.Comparator;  
 import java.util.Iterator;  
 import java.util.Set;  
 import java.util.TreeSet;  
   
 public class CustomerComparator implements Comparator{  
   
     public int compare（Customer c1， Customer c2） {  
         if（c1.getName（）.compareTo（c2.getName（））>0）return -1;  
         if（c1.getName（）.compareTo（c2.getName（））<0）return 1;  
           
         return 0;  
     }  
       
     public static void main（String args[]）{  
         Set set = new TreeSet（new CustomerComparator（））;  
           
         Customer customer1= new Customer（"Tom"，15）;  
         Customer customer3= new Customer（"Jack"，16）;  
         Customer customer2= new Customer（"Mike"，26）;  
         set.add（customer1）;  
         set.add（customer2）;  
         set.add（customer3）;  
           
         Iterator it = set.iterator（）;  
         while（it.hasNext（））{  
             Customer customer = it.next（）;  
             System.out.println（customer.getName（）+" "+customer.getAge（））;  
         }  
     }  
   
 }  

以上main办法在机关TreeSet的实例时，调用了它的TreeSet（Comparator comparator）机关办法.

       Java代码    
     
 Set set = new TreeSet（new CustomerComparator（））;  

这是干甚？其实就是指定一个斗劲器 TreeSet凑集里边的对象遵守这个斗劲器的规矩进行排序我把TreeSet类的这个机关办法搞上来看看就熟悉打听了 TreeSet里边有如许一个机关办法
TreeSet
public TreeSet（Comparator<？ super E> comparator）机关一个新的空 TreeSet，它按照指定斗劲器进行排序。插入到该 set 的所有元素都必须可以或许由指定斗劲器进行彼此斗劲：对于 set 中的随便率性两个元素 e1 和 e2，履行 comparator.compare（e1， e2）都不得抛出 ClassCastException。若是用户试图将违背此束缚的元素添加到 set 中，则 add 调用将抛出 ClassCastException。

参数：
comparator - 将用来对此 set 进行排序的斗劲器。若是该参数为 null，则应用元素的天然次序。
最后的打印成果是:

       Java代码    
     
 Tom 15  
 Mike 26  
 Jack 16  

是倒序 ...

那你如今是不知道了comparable接口和comparable接口的差别了并且也能更好的应用TreeSet凑集了
总结一下吧
单点申明吧：用自定义类实现Comparable接口，那么这个类就具有排序功能，Comparable和具体你要进行排序的类的实例邦定。而Comparator斗劲灵活，只须要经由过程机关办法指定一个斗劲器就行了实现它的自定义类仅仅定义了一种排序体式格式或排序规矩。不问可知，这种体式格式斗劲灵活。我们的要排序的类可以分别和多个实现Comparator接口的类绑定，从而达到可以按本身的意愿实现按多种体式格式排序的目标。Comparable&＃8212;&＃8212;&＃8220;静态绑定排序&＃8221;，Comparator&＃8212;&＃8212;&＃8220;动态绑定排序&＃8221;。

在多墨迹一点说说编写java类时应当养成一些好习惯吧
一: 若是java类从头定义了equals办法，那么这个类也必须从头定义hashCode（）办法，并且包管当两个对象用equals办法斗劲成果为true时，这两个对象的hashCode（）办法的返回值相等.

二:若是java类实现了Comparable接口，那么这个类应当从新定义compareTo（） equals（）和hashCode（）办法，包管compareTo（）和equals（）办法采取雷同的斗劲规矩来斗劲两个对象是否相等，并且包管当两个对象用equals（）办法斗劲的成果为true时，这两个对象的hashCode（）办法的返回值相等.
   HashSet和HashMap具有较好的机能，是Set和Map首选实现类，只有在须要排序的场合，才推敲应用TreeSet和TreeMap. LinkedList 和 ArrayList各有优毛病，若是经常对元素履行插入和删除操纵，那么可以用LinkedList，若是经常随机接见元素，那么可以用ArrayList.
ThreeSet可以或许对凑集中的对象排序，当TreeSet想凑集中参加一个对象时，会把它插入到有序的对象序列中。那么TreeSet是如何排序呢？TreeSet支撑两种排序体式格式:天然排序和客户化排序.在默认景象下TreeSet采取天然排序体式格式。
    先来介绍介绍什么是天然排序吧
1、天然排序
   在JDK类库中，有一项目组类实现了Comparable接口，如Integer Double和String等。
Comparable接口有一个comparTo（Object o）办法，它返回整数类型。对于表达式x.compareTo（y），若是返回值为0，则默示x和y相等，若是返回值大于0，则默示x大于y，若是返回值小于0，则默示x小于y.TreeSet凑集调用对象的compareTo（）办法斗劲凑集中的大小，重视鸟不是TreeSet调用它本身的comparTo（）办法而是它调用凑集中对象的comparTo（）办法.TreeSet类本身并没有实现Comparable接口，然掉队行升序分列，这种体式格式称为天然排序.
   有人可能要问TreeSet凑集怎么给对象排序的按对象的什么排序的？
   下面简单总结一哈
    JDK类库中实现了Comparable接口的一些类的排序体式格式

类 BigDecimal BigInteger Byte Double Float Integer Long Short 排序体式格式是	按数字大小排序
类 Character是	按字符的Unicode值的数字大小排序
类 String是	按字符中字符的Unicode值排序

       Java代码    
     
 package hang.jihe;  
   
 import java.util.HashSet;  
 import java.util.Set;  
   
 public class Customer implements Comparable {  
     private String name;  
   
     private int age;  
   
     public Customer（String name， int age） {  
         this.age = age;  
         this.name = name;  
     }  
   
     public int getAge（） {  
         return age;  
     }  
   
     public void setAge（int age） {  
         this.age = age;  
     }  
   
     public String getName（） {  
         return name;  
     }  
   
     public void setName（String name） {  
         this.name = name;  
     }  
   
     ＠Override  
     public boolean equals（Object obj） {  
         if （this == obj）  
             return true;  
         if （!（obj instanceof Customer））  
             return false;  
         final Customer other = （Customer） obj;  
   
         if （this.name.equals（other.getName（）） && this.age == other.getAge（））  
             return true;  
         else  
             return false;  
     }  
   
     public static void main（String[] args） {  
         Set set = new HashSet（）;  
         Customer customer1 = new Customer（"Tom"， 15）;  
         Customer customer2 = new Customer（"Tom"， 15）;  
         set.add（customer1）;  
         set.add（customer2）;  
         System.out.println（set.size（））;  
     }  
   
     public int compareTo（Object o） {  
         Customer other = （Customer） o;  
   
         // 先遵守name属性排序  
         if （this.name.compareTo（other.getName（）） > 0）  
             return 1;  
         if （this.name.compareTo（other.getName（）） < 0）  
             return -1;  
   
         // 在遵守age属性排序  
         if （this.age > other.getAge（））  
             return 1;  
         if （this.age < other.getAge（））  
             return -1;  
         return 0;  
     }  
   
     ＠Override  
     public int hashCode（） {  
         int result;  
         result = （name == null ？ 0 : name.hashCode（））;  
         result = 29 * result + age;  
         return result;  
     }  
 }  