自然排序
    Comparable接口得使用举例：
    1、像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了两个对象大小；
    2、像String、包装类重写compareTo()方法以后，进行了从小到大的排列
    3、重写compareTo()的规则：
    如果当前对象this大于形参对象obj，则返回正整数，
    如果当前对象this小于形参对象obj，则返回负整数，
    如果当前对象this等于形参对象obj，则返回零。
    4、对于自定义类，需要排序，可以用自定义类实现Comparable接口，重写comparaTo()方法。
    代码：

    1. package com.ComparableTest;
    3. import org.junit.Test;
    5. import java.util.Arrays;
    7. public class CompareTest {
    9.     @Test
    10.     public void test1(){
    11.         String[] arr = new String[]{"AA","CC","MM","KK","GG","JJ","DD"};
    12.         Arrays.sort(arr);
    13.         System.out.println(Arrays.toString(arr));
    14.     }
    16.     @Test
    17.     public void test2(){
    18.         Goodss[] arr = new Goodss[5];
    19.         arr[0] = new Goodss("lianxiangMouse",34);
    20.         arr[1] = new Goodss("dellMouse",43);
    21.         arr[2] = new Goodss("xiaomiMouse",12);
    22.         arr[3] = new Goodss("huaweiMouse",65);
    23.         arr[4] = new Goodss("microsoftMouse",43);
    25.         Arrays.sort(arr);
    27.         System.out.println(Arrays.toString(arr));
    28.     }
    30. }
    34. package com.ComparableTest;
    36. public class Goodss implements Comparable{
    38.     private String name;
    39.     private double price;
    41.     public Goodss() {
    42.     }
    44.     public Goodss(String name, double price) {
    45.         this.name = name;
    46.         this.price = price;
    47.     }
    49.     public String getName() {
    50.         return name;
    51.     }
    53.     public double getPrice() {
    54.         return price;
    55.     }
    57.     @Override
    58.     public String toString() {
    59.         return "Goodss{" +
    60.                 "name='" + name + '\'' +
    61.                 ", price=" + price +
    62.                 '}';
    63.     }
    65.     // 指明商品比较大小的方式
    66.     @Override
    67.     public int compareTo(Object o) {
    68.         if(o instanceof Goodss){
    69.             Goodss goods = (Goodss)o;// 输入的所有对象都是Object类或者其子类
    70.             if(this.price > goods.price) {
    71.                 return 1;
    72.             }else if (this.price < goods.price) {
    73.                 return -1;
    74.             }else{
    75.                 return this.name.compareTo(goods.name);// 相等按字母排序
    76.             }
    78.         }
    79.         throw new RuntimeException("传入数据类型一致");
    80.     }
    81. }

    注意构造器和get、toString等方法的快捷生成。

    定制排序：
    1、背景：当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码， 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那 么可以考虑使用Comparator 的对象来排序。
    2、 重写compare(Object o1,Object o2)方法，比较01和o2的大小：
    相等返回0；01大返回正正是，01小返回负整数。

    代码：

    1. @Test
    2.     public void test4(){
    3.         Goodss[] arr = new Goodss[5];
    4.         arr[0] = new Goodss("lianxiangMouse",34);
    5.         arr[1] = new Goodss("dellMouse",43);
    6.         arr[2] = new Goodss("xiaomiMouse",12);
    7.         arr[3] = new Goodss("huaweiMouse",65);
    8.         arr[4] = new Goodss("microsoftMouse",43);
    10.         Arrays.sort(arr,new Comparator(){
    12.             // 按产品名称从低到高，再按价格从高到低
    13.             @Override
    14.             public int compare(Object o1, Object o2) {
    15.                 if(o1 instanceof Goodss && o2 instanceof Goodss){
    16.                     Goodss g1 = (Goodss) o1;
    17.                     Goodss g2 = (Goodss) o2;
    18.                     if(g1.getName().equals(g2.getName())) {
    19.                         return -Double.compare(g1.getPrice(),g2.getPrice());
    20.                     }else{
    21.                         return g1.getName().compareTo(g2.getName());
    22.                     }
    23.                 }
    24.                 throw new RuntimeException("输入的数据类型不一致");
    25.             }
    26.         });
    28.         System.out.println(Arrays.toString(arr));
    29.     }

    两类接口对比：
    Comparable接口的方式一旦指定，保证Comparable接口的实现类在任何位置都可以比较大小；
    Coparator接口时临时性的比较