背景

在工作中我们往往要对列表中的对象根据某一些字段进行排序，本文就对Java中如何实现排序进行一个简单的介绍。

实现排序的方法

想要通过对象进行排序，核心是先要实现内置的Comparable接口，或者是自定义的排序方法。

@Data
@ToString
public class Person implements Comparable<Person> {
    /**
     *  姓名
     */
    private String name;
    /**
     * 生日
     */
    private Long birthday;


    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        Person p1 = new Person();
        p1.setBirthday(177722388923L);
        p1.setName("张三");
        Person p2 = new Person();
        p2.setBirthday(132722388923L);
        p2.setName("李四");

        list.add(p1);
        list.add(p2);

       // 1. 使用stream流进行排序
        List<Person> collect = list.stream().sorted().collect(Collectors.toList());
        for (Person person : collect) {
            System.out.println(person);
        }
        // 2. 使用java.util.Collections工具类进行排序
        Collections.sort(list);
        list.stream().forEach(System.out::println);
        ```
        /**
         * 3. 自定义排序方法，通过Collection.sort进行排序
         */
        Collections.sort(list,Person::compareByDateAsc);
        list.forEach(System.out::println);
        ```
    }

    /**
     *  默认比较是升序，倒着比较是降序
     * @param o
     * @return
     */
    @Override
    public int compareTo(@NotNull Person o) {
        Long target = o.getBirthday();
        Long we = this.getBirthday();
        return target.compareTo(we);
    }
    /**
    * 自定义排序方法
    */
    public int compareByDateAsc(Person target){
        return this.getBirthday().compareTo(target.getBirthday());
    }
}

我们通过要比较的对象实现Comparable接口，然后重写compareTo方法即可实现排序。

数据并不规范时

我们对列表中数据排序往往会遇到一个问题：那就是要排序的字段并不规范！我们在获取出来的时候直接比较可能会发生异常。 比如以下的列表数据：

@Data
@ToString
public class PersonDemo2 implements Comparable<PersonDemo2> {
    /**
     *  姓名
     */
    private String name;
    /**
     * 生日
     */
    private String birthday;


    public static void main(String[] args) {
        /**
         *  我们期望的birthday字段中存放的就是long类型，当时实际上可能会存在其他如null,"null"等类型的数据，直接进行比较的话程序会报出错误
         */
        List<PersonDemo2> list = new ArrayList<>();
        PersonDemo2 p1 = new PersonDemo2();
        p1.setBirthday(null);
        p1.setName("张三");
        PersonDemo2 p2 = new PersonDemo2();
        p2.setBirthday("132722388923");
        p2.setName("李四");

        PersonDemo2 p3 = new PersonDemo2();
        p3.setBirthday("null");
        p3.setName("王五");

        PersonDemo2 p4 = new PersonDemo2();
        p4.setBirthday("未知");
        p4.setName("赵六");


        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);

        Collections.sort(list);
        list.forEach(System.out::println);
    }

    /**
     *  默认比较是升序，倒着比较是降序
     * @param target
     * @return
     */
    @Override
    public int compareTo(@NotNull PersonDemo2 target) {
        Long l1;
        Long l2;
        try {
            l1 = Long.parseLong(target.getBirthday());
        }catch (Exception e){
            System.out.println("转换发生异常："+target.getBirthday());
            l1 = 0L;
        }
        try {
            l2 = Long.parseLong(this.getBirthday());
        }catch (Exception e){
            l2 = 0L;
            System.out.println("转换发生异常："+this.getBirthday());

        }
        return l2.compareTo(l1);
    }

}

可以通过异常处理的方式来捕获，然后将数据转换为需要的格式以后，再进行转换。