比较接口

导读

1. 自然排序：如String类、包装类或自己写的类已经实现了Comparable接口，并重写了compareTo方法，那么直接调用Arrays.sort( ) 方法，就可以实现排序
2. 定制排序：不想使用已经定义好的排序方法，可以使用Arrays.sort(T[] a, Comparator<? super T> c )方法，创建匿名内部实现类，根据实际情况，临时性的自定义排序顺序，以实现精确控制

00 引入​

• Java中的对象，正常情况下，只能进行比较：== 或 != , 不能进行 > 或 < 的 比较。 但在开发场景中，我们需要对多个对象进行排序，即需要比较对象的大小。因此，API提供了​ 两个比较接口 Comparable 和 Comparator，将需要进行排序的接口的类实现两个接口中的任意一个，​ 并配合Arrays.sort( ) 方法，即可实现对对象的排序

一、Comparable接口

1. 自然排序

   ① 像String、包装类等实现了Comparable接口，重写了compareTo( ) 方法，给出了比较两个对象大小的方式，方式是从小到大。
   ② 实现Comparable接口的对象列表（和数组），可以通过Collections.sort或Arrays.sort进行自动排序。

       @Test
       public void test(){
         
           String[] str = new String[]{
         "CC","JJ","MM","DD","GG"};
           Arrays.sort(str);
           System.out.println(Arrays.toString(str));
           // [CC, DD, GG, JJ, MM]
       }
   

2. 重写compareTo( ) 的规则：

   ① 如果当前对象this大于形参对象obj，则返回正整数；

   ② 如果当前对象this小于形参对象obj，则返回负整数；

   ③ 如果当前对象this等于形参对象obj，则返回 0

3. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写

   compareTo（Object obj）方法，在该方法中指明如何排序

   public class CompareTest {
         
      @Test
       public void test2(){
         
           Goods[] str = new Goods[5];
           str[0] = new Goods("lenovo",19);
           str[1] = new Goods("huawei",69);
           str[2] = new Goods("xiaomi",49);
           str[3] = new Goods("huawei",99);
           str[4] = new Goods("dell",99);
           Arrays.sort(str);
           System.out.println(Arrays.toString(str));
           /* 
             输出结果为：
             [{name='lenovo', price=19.0}, {name='xiaomi', price=49.0}, 
             {name='huawei', price=69.0}, {name='dell', price=99.0},
             {name='huawei', price=99.0}]   
            */
       }
   }
   class Goods implements Comparable{
         
       private String name;
       private double price;
   
       public Goods() {
         
       }
       public Goods(String name, double price){
         
           this.name = name;
           this.price = price;
       }
   
   
       @Override
       public String toString() {
         
           return "{" +
                   "name='" + name + '\'' +
                   ", price=" + price +
                   '}';
       }
   
       @Override
       public int compareTo(Object o) {
         
           System.out.println("-----------------");
           if (o instanceof Goods){
         
               Goods goods = (Goods)o;
               if (this.price > goods.price) {
         
                   return 1;
               }                
               if(this.price < goods.price) {
         
                   return -1;
               }
               return this.name.compareTo(goods.name);//将name属性也进行了排名
           }
           throw new RuntimeException("传入的数据类型不正确");
       }
   }
   
   

二、Comparator接口 - - - 定制排序

1. 背景

   当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的额操作，那么就可以考虑而用Comparator类型的对象来排序，强行对多个对象进行整体排序的比较

   也可以将Comaprator传递给sort方法（如Collections.sort 或 Arrays.sort）,从而允许在排序顺序上实现精确控制

2. 重写compare（Object o1 , Object o2）方法，比较o1和o2的大小

   ① 如果返回正整数，表示o1 > o2
   ② 如果返回负整数，表示o1 < o2
   ③ 如果返回 0 ，表示相等

3. 配合使用Arrays.sort(T[] a, Comparator<? super T> c )方法，此处Comparator实现类对象只使用一次，一般写为匿名实现类对象new Comparator( ) { }

   @Test
       public void test3(){
         
           Goods[] str1 = new Goods[6];
           str1[0] = new Goods("lenovo",18);
           str1[1] = new Goods("huawei",68);
           str1[2] = new Goods("xiaomi",48);
           str1[3] = new Goods("huawei",98);
           str1[4] = new Goods("dell",98);
           str1[5] = new Goods("oppo",298);
           // 接口在匿名内部类（假象的所谓内部类）实例化现象
           Arrays.sort(str1, new Comparator() {
         
       @Override
           public int compare(Object o1, Object o2) {
                    
               if (o1 instanceof Goods && o2 instanceof Goods){
         
                   Goods g1 = (Goods) o1;
                   Goods g2 = (Goods) o2;
                   //按照名字从大到小排
                   if (g1.getName().equals(g2.getName())){
         
                       return -Double.compare(g1.getPrice(),g2.getPrice());
                   }else
                       return -g1.getName().compareTo(g2.getName());
                   }
               throw new RuntimeException("输入数据结构异常");
               }
           });          
           System.out.println(Arrays.toString(str1));
           /* 
            输出的排序结果
            [{name='xiaomi', price=48.0}, {name='oppo', price=298.0}, 
            {name='lenovo', price=18.0}, {name='huawei', price=98.0}, 
            {name='huawei', price=68.0}, {name='dell', price=98.0}]
            */
           
           
       }
   

三、比较

• Comparable接口的方式一旦确定，保证Comparable接口的实现类的对象在任何位置都可以调用Arrays.sort( )方法进行大小比较
• Comparator接口属于临时性的比较

四、总结：

​ 只要涉及到对象排序，就是这两个比较类