JavaList集合排序之Comparable与Comparator的使用

Collections类说明

Collections是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。其中就有用于集合排序的sort方法，此方法主要是通过Comparable或Comparator来实现排序。以下介绍两者之间的使用以及区别。

Comparable用法

注意：在使用Collections的sort(List<T> list) 方法排序时，要求集合元素（对象）T必须是Comparable接口的实现类，同时重写Comparable的抽象方法 - int compareTo(T t)。方法说明如下：

 *  在使用Collection的sort排序的集合元素都必须是Comparable接口的实现类，该接口表示子类是可以比较的。
 *  同时实现接口必须重写抽象方法。
 *  - int compareTo(T t);
 *  该方法用于使当前对象与给定对象进行比较。
 *  返回值为一个int值，该值表示大小关系，它不关注具体的取值是多少，而关注的是取值范围。
 *  当返回值>0时：当前对象比参数对象大(T是传入的参数,this表示当前对象)
 *  当返回值<0时：当前对象比参数对象小(T是传入的参数,this表示当前对象)
 *  当返回值=0时：当前对象等于参数对象(T是传入的参数,this表示当前对象)

代码案例一（Java基本包装类型排序）

Integer、String等一些基本包装类，JDK默认都实现了Comparable接口，所以可以使用方法一直接进行比较排序（自然排序）

package example.demo03;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author yuanchaoyong
 */
public class ComparatorTest {

    public static void main(String[] args) {
        // 测试案例1
        testInteger();
        // 测试案例2
        testString();
    }

    /**
     * List<Integer> 排序测试
     *              Integer 默认实现了Comparable接口
     *              Collections.sort默认是升序排序（自然排序）
     */
    public static  void   testInteger(){
        List<Integer> integers = Arrays.asList(12,7,15,4);
        Collections.sort(integers);
        System.out.println(integers);
    }

    /**
     * List<String> 排序测试
     *              String 默认实现了Comparable接口
     *              Collections.sort默认是升序排序（自然排序）
     */
    public static  void   testString(){
        List<String> strings = Arrays.asList("aaa","ccc","bbb","rrr");
        Collections.sort(strings);
        System.out.println(strings);
    }

}

输出结果

 

代码案例二 （自定义对象排序）

平常工作开发的时候，基本包装类型一般无法满足需求。所以我们定义了自定义对象，有时候需要根据对象的某一个属性进行排序。这个时候需要对象实现Comparable接口，同时重写Comparable的抽象方法 - int compareTo(T t)。这里以用户(User)年龄进行升序排序案例说明。

package example.demo03;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author yuanchaoyong
 */
public class ComparatorTest02 {

    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("王五",50),new User("张三",30),new User("李四",40));
        Collections.sort(users);
        System.out.println(users);
    }

}

/**
 * 用户对象
 *          name
 *          age
 */
class User   implements Comparable<User>{

    String name;
    Integer age;

    User(String n, Integer a) {
        name = n;
        age = a;
    }

    @Override
    public int compareTo(User u) {
        return this.age - u.age ;
    }

    @Override
    public String toString() {
        return String.format("{name=%s, age=%d}", name, age);
    }

}

 

Comparable优缺点

通过以上案例知道，Comparable的确实现了我们想要的排序结果。但是使用Collections的sort(List<T> list) 方法排序集合时，集合元素必须实现Comparable接口并且定义比较规则。这个时候就开始出现一些问题。比如我们同一个工程使用了User对象，单个场景使用age进行排序，但是另一种情况下使用name排序，这个时候就出现了冲突。并且集合元素需要去实现Comparable接口，这对于我们的代码会有一些"侵入性"，也不利于我们后续的代码扩展。

所以一般不建议使用，推荐使用Collections的sort(List<T> list, Comparator<? super T> c)的重载方法。

Comparator用法

Collections的sort(List<T> list, Comparator<? super T> c)

 * 重载的sort方法要求传入一个外部的比较器。
 * 该方法不再要求集合元素必须实现Comparable接口。
 * 并且也不再使用集合元素自身的比较规则排序了，而是根据给定的这个额外的比较器的比较规则,对集合元素进行排序。
 * 实际开发中也推荐使用这种方式排序集合元素，若集合元素是自定义的，创建比较器时也推荐使用匿名内部类的形式。

代码案例一 （自定义对象排序）

package example.demo03;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @author yuanchaoyong
 */
public class ComparatorTest03 {

    public static void main(String[] args) {
        List<Student> students = Arrays.asList(new Student("张三",30),new Student("李四",40),new Student("王五",50));
        // 使用匿名内部类进行排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自定义排序规则
                return o1.age- o2.age;
            }
        });
        System.out.println(students);
    }


}

class  Student {

    String name;
    Integer age;

    Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return String.format("{name=%s, age=%d}", name, age);
    }
}

结果

 

代码案例二 （使用List自带的排序方法）

package example.demo03;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
 * @author yuanchaoyong
 */
public class ComparatorTest03 {

    public static void main(String[] args) {
        //test01();
        test02();
    }

    /**
     * 使用List自带的排序方法
     */
    private static void test02() {
        List<Student> students = Arrays.asList(new Student("张三",30),new Student("李四",40),new Student("王五",50));
        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age- o2.age;
            }
        });
        System.out.println(students);
    }

    /**
     * Collections.sort方法测试
     */
    private static void test01() {
        List<Student> students = Arrays.asList(new Student("张三",30),new Student("李四",40),new Student("王五",50));
        // 使用匿名内部类进行排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自定义排序规则
                return o1.age- o2.age;
            }
        });
        System.out.println(students);
    }
}

class  Student {
    String name;
    Integer age;
    Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return String.format("{name=%s, age=%d}", name, age);
    }
}

 

JDK8之lambda简化写法

Comparator接口是一个函数式接口，所以我们可以使用更优秀的写法，简化代码。

函数式接口就是只定义一个抽象方法的接口。
JDK1.8开始支持默认方法，即便这个接口拥有很多默认方法，只要接口只有一个抽象方法，那么这个接口就是函数式接口。

package example.demo03;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author yuanchaoyong
 */
public class ComparatorTest04 {

    public static void main(String[] args) {
        test02();
    }

    /**
     * lambda写法测试
     */
    private static void test02() {
        List<Teacher> teachers = Arrays.asList(new Teacher("张三", 30), new Teacher("李四", 40), new Teacher("王五", 50));
        // 多种写法，以下只是作为参考

        // 写法1
        // teachers.stream().sorted((o1,o2)-> o1.age- o2.age).collect(Collectors.toList());

        // 写法2
        //Collections.sort(teachers,(o1,o2)-> o1.getAge()- o2.getAge());

        // 写法3
        List<Teacher> teacherList = teachers.stream().
                sorted((Comparator.comparingInt(Teacher::getAge)))
                .collect(Collectors.toList());

        System.out.println(teachers);
    }
}

class  Teacher {
    String name;
    Integer age;
    Teacher(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return String.format("{name=%s, age=%d}", name, age);
    }
}

额外参考资源

List<类> list; 代表某集合
 
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
 
//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
 
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
 
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

//空/Null数据排序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(item -> item.属性二, Comparator.nullsLast(Date::compareTo))).collect(Collectors.toList());

//空/Null数据分组
Map<String, List<类>> map = list.stream().collect(Collectors.groupingBy(item -> {
  if (item.属性一 == null || item.属性一.equals("")) {
  　　return "";
  }
  return DateFormat.getDateInstance().format(item.属性一);
}))