Java中实现Arrays.sort的自然排序和定制排序

Java中 Arrays.sort 可以实现堆数组进行顺序排序，直接调用即可。

有时候需要自己定制排序方式，比如：按绝对值大小排序、逆序排序、按类的某个属性排序等等，可以通过重载 sort 方法来实现定制排序。

1. 直接使用Arrays提供的sort方法，即从小到大排序

        // Arrays.sort方法的使用: ①自然排序 ②定制排序
        Integer arr[] = {-61, 10, -1, 7, 0, 89};

        // 1. 直接使用 Arrays 提供的 sort 方法，从小到大排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [-61, -1, 0, 7, 10, 89]

2. 自己定制 sort 方法

   定制排序时，sort传入两个参数：
      ① 排序的数组arr
      ② 实现了Comparator接口的匿名内部类，要求实现compare方法

2.1  定制排序：按绝对值大小排序

        // 2.1 例如，按绝对值大小进行排序
        Arrays.sort ( arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1; // 向下转型为Integer
                Integer i2 = (Integer)o2;
                return Math.abs(i1)-Math.abs(i2);  // 该接口规定返回值如果>0，则说明o1排在o2的左边
            }
        });
        System.out.println(Arrays.toString(arr)); // [0, -1, 7, 10, -61, 89]

2.2  定制排序：逆序排序

        // 2.2 例如，逆序排序
        Arrays.sort ( arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1; // 向下转型为Integer
                Integer i2 = (Integer)o2;
                return i2 - i1;
            }
        });
        System.out.println(Arrays.toString(arr)); // [89, 10, 7, 0, -1, -61]

以上完整代码：

        // Arrays.sort方法的使用: ①自然排序 ②定制排序
        Integer arr[] = {-61, 10, -1, 7, 0, 89};

        // 1. 直接使用 Arrays 提供的 sort 方法，从小到大排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [-61, -1, 0, 7, 10, 89]

        /* 2. 自己定制 sort 方法
            定制排序时，sort传入两个参数：
            ① 排序的数组arr
            ② 实现了Comparator接口的匿名内部类，要求实现compare方法
         */

        // 2.1 例如，按绝对值大小进行排序
        Arrays.sort ( arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1; // 向下转型为Integer
                Integer i2 = (Integer)o2;
                return Math.abs(i1)-Math.abs(i2);  // 该接口规定返回值如果>0，则说明o1排在o2的左边
            }
        });
        System.out.println(Arrays.toString(arr)); // [0, -1, 7, 10, -61, 89]

        // 2.2 例如，逆序排序
        Arrays.sort ( arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1; // 向下转型为Integer
                Integer i2 = (Integer)o2;
                return i2 - i1;
            }
        });
        System.out.println(Arrays.toString(arr)); // [89, 10, 7, 0, -1, -61]

本质就是自己实现一下系统做的一个系统调用的接口（Comparator），这个接口里有个compare方法，使用者可自行实现这个方法来实现自己的需求。

compare 方法返回的是 int类型。当返回值为负数时，obj1 排在 obj2 左边；为正数时 obj1 排在obj2 右边。

2.3 定制排序：按类的属性排序

自定义商品类(Good），有名称和价格两个属性。

有一个Good类的数组，里面存放了四个商品实例，实现将该数组按照价格排序。

class Good {
    String name;
    double price;

    Good(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String toString() {  
        return name + " " + price;
    }
}

        Good[] goods = new Good[4];  // 四个商品，分别有名字和价格
        goods[0] = new Good("AAA",100.0);
        goods[1] = new Good("BBB",230.0);
        goods[2] = new Good("CCC",120.5);
        goods[3] = new Good("DDD",120.8);

        Arrays.sort(goods,new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                Good g1 = (Good)o1;
                Good g2 = (Good)o2;
                double priceVal = g1.price - g2.price; 
             /* compare方法要求返回类型是int，而商品的价格是double类型。
               所以做转换，让其返回值对应是 1，-1，0 */
                if(priceVal < 0)
                    return -1;
                else if(priceVal > 0)
                    return 1;
                else
                    return 0;
            }
        });
        for(Good g : goods)
            System.out.println(g);
      /*  AAA 100.0
          CCC 120.5
          DDD 120.8
          BBB 230.0
      */
    }