Java的Comparable和Comparator比较器

目录

1.Comparable 自然排序

2.Comparator 定制排序

3.重写Comparable 和Comparator的方式

   1.创建类

   2.匿名内部类

   3.lambda表达式

---

1.Comparable 自然排序

1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。

2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列

public void Test1(){

         String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
         
         Arrays.sort(arr);

         System.out.println(Arrays.toString(arr)); //[AA, CC, DD, GG, JJ, KK, MM]

         Integer[] s1 = new Integer[10];
         for(int i = 9; i >= 0; i --){
             s1[i] = i;
         }
         Arrays.sort(s1);
         System.out.println(Arrays.toString(s1));//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
} 

3. 重写compareTo(obj)的规则：

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

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

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

4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。

在compareTo(obj)方法中指明如何排序

 @override
public compareTo(Object obj){
     if(obj instanceof 子类类型){
         子类类型 o = (子类类型)obj //向下转型
         //  从小到大排序
         if(this.age > o.age) return 1;
         else if(this.age < o.age) return -1;
         else return 0
         // return this.age - o.age; 第二种写法比较简单


         //从大到小排序
         if(this.age > o.age) return -1;
         else if(this.age < o.age) return 1;
         else return 0;
         // return o.age - this.age; 同样第二种方法比较简单

     }
 }

2.Comparator 定制排序

Comparator接口的使用：定制排序

1.背景：

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，

或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，

那么可以考虑使用 Comparator 的对象来排序

public class Test3(){

        String[] str = new String[]{"aa","DD","ff","CC","ZZ"};
              Arrays.sort(str,new Comparator<String>{
              @Override
              public int compare(String o1, String o2){
              return -o1.compareTo(o2); 

//         String类型这里只能这样用，内部的compareTo方法不能修改,升序操作
           
}       
}
          System.out.println(Arrays.toString(s));
}

2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小：

如果方法返回正整数，则表示o1大于o2；

如果返回0，表示相等；

返回负整数，表示o1小于o2。

public void Test2(){
       

     Arrays.sort(p,new Comparator<Person>{
         
         @Override
         public int compare(Object o1, Object o2){

           if(o1 instanceof Person && o2 instanceof Person){
              Person s1 = (Person) o1;
              Person s2 = (Person) o2;
              return o1.age - o2.age; // 升序
           // return 02.age - o1.age  // 降序排列   

         }
      }
    }
}

3.重写Comparable 和Comparator的方式

  1.Comparable接口通常是在类的内部。属于一次创建持久使用，创建类继承Comparable接口

  2.Comparator接口属于一次使用，如同一次性筷子一样。可以使用匿名类创建

  1.创建类

public void Test(){
   Integer[] s = new Integer[10];
   for(int i = 10; i >= 1; i --){
     s[i] = i;      //自动装箱  int类的变量转成了一个Integer类型对象
   }
    
   Arrays.sort(s,new Compare()) //
   
   System.out.println(Arrays.toString(s));
}

public class implements Comparator<Integer>{

        @Override
        public int compare(Integer o1, Integer o2){
         return o1 - o2; //升序
         //return o2 - o1 降序
      }

}

   2.匿名内部类

public class Test3(){

        String[] str = new String[]{"aa","DD","ff","CC","ZZ"};
              Arrays.sort(str,new Comparator<String>{
              @Override
              public int compare(String o1, String o2){
              return -o1.compareTo(o2); 

//         String类型这里只能这样用，内部的compareTo方法不能修改,升序操作
           
}       
}
          System.out.println(Arrays.toString(s));
}

 3.lambda表达式

public class Test {
  public static void main(String[] args) {
    //
    int n=10;
    Integer[] num=new Integer[n];
    for(int i=0;i<n;i++)
      num[i]=i+1;
    Arrays.sort(num,((o1, o2) -> o2-o1));
    System.out.println(Arrays.toString(num));
  }
}