Java的Sort方法和泛型中类型变量的限定

Java的Sort方法和泛型中类型变量的限定

1. 包含自定义类的集合使用Collections中的sort方法

Collections中的sort方法可以对集合进行排序，数字或字符串默认为升序排列。

• sort方法原型
  public static <T extends Comparable<? super T>> void sort(List<T> list)

关于此方法原型中泛型的解释见此博客下一节：Java泛型_类型变量的限定
那么当List中的T为自定义类时，该怎么排序呢，实际上被排序的集合里面存储的元素，必须实现Comparable接口，并重写接口中的compareTo方法，通过此方法定义排序规则，从而实现List集合中自定义类的排序。

• 自定义类Person中对方法Compare重写如下

    @Override
    public int compareTo(Person o) {
        // return 0;代表两个元素相同
        // 自定义比较规则
        return this.getAge() - o.getAge();  // 升序排序
        // return o.getAge() - this.getAge();  // 降序排序
    }

• 调用代码如下

    private static void test01() {
        ArrayList<Person> list = new ArrayList<>();
        Person p1 = new Person("Tim", 12);
        Person p2 = new Person("Lisa", 15);
        Person p3 = new Person("Ritchie", 14);
        Person p4 = new Person("Jane", 16);
        Collections.addAll(list, p1, p2, p3, p4);
        Collections.sort(list);
        System.out.println(list);	// 注意Person中重写了toString方法
    }

• 输出结果
  [Person{name='Tim', age=12}, Person{name='Ritchie', age=14}, Person{name='Lisa', age=15}, Person{name='Jane', age=16}]

• 补充：compareTo方法说明

int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

2. Java泛型_类型变量的限定

有时候在泛型使用时需要对泛型类型范围进行限制，比如该泛型必须实现某个接口或者必须继承自某个类。这种操作是可以在Java中实现的，下面我们以Java中Collections类下的sort方法为例进行说明。

• sort方法原型
  public static <T extends Comparable<? super T>> void sort(List<T> list)

其中最为关键的是<T extends Comparable<? super T>>部分，在这里首先表明了泛型的名称为T，接下来使用extends对T的范围进行了限制，表示该泛型必须实现了Comparable<? super T>接口，而这里的<? super T>又代表着Compareable的泛型必须是T或者T的父类。

3. 另一个sort方法

• 方法原型
  public static <T> void sort(List<T> list, Comparator<? super T> c)

• 使用时要使用接口Comparator中的compare方法

• 使用示例1——比较非自定义类型

    private static void test02() {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 4, 3, 5);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;     //升序排序
                // return o2 - o1;  //降序排序
            }
        });
        System.out.println(list);
    }

• 执行结果
  [1, 2, 3, 4, 5]

• 使用示例2——比较自定义类型

    private static void test03() {
        ArrayList<Person> list = new ArrayList<>();
        Person p1 = new Person("Tim", 12);
        Person p2 = new Person("Lisa", 15);
        Person p3 = new Person("Ritchie", 14);
        Collections.addAll(list, p1, p2, p3);
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(list);
    }

• 执行结果
  [Person{name='Tim', age=12}, Person{name='Ritchie', age=14}, Person{name='Lisa', age=15}]