Java 排序之 Comparable 和 Comparator

1. Comparable 排序接口

• java.lang.Comparable
• 实现了Comparable接口的类支持排序，可以通过 Collections.sort 或 Arrays.sort 进行自动排序

public interface Comparable<T> {
    public int compareTo(T o);
}

1.1 String 字符串

@Test
public void demo() {
    List<String> strs = Arrays.asList("222", "111", "333");
    // String implements Comparable<String>
    Collections.sort(strs);
    System.out.println(strs);
}

Collections.sort()方法：

public class Collections {
    public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
    }
}

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

   /**
     * Compares two strings lexicographically.
     */
  public int compareTo(String anotherString) {}
}

1.2 实例比较

@Test
public void demo() {
    List<OrderDTO> orders = Arrays.asList(new OrderDTO("2023-01-01 10:00:00", "1001"),
            new OrderDTO("2023-02-01 10:00:00", "1001"), new OrderDTO("2023-01-01 10:10:00", "1001"));
    Collections.sort(orders);
    System.out.println(orders);
}

@Data
@AllArgsConstructor
public class OrderDTO implements Comparable<OrderDTO> {

    private String gmtModify;
    private String orderCode;

    @Override
    public int compareTo(OrderDTO order) {
        return this.getGmtModify().compareTo(order.getGmtModify());
    }
}

2. Comparator 比较器

• java.util.Comparator

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    // some default methods
    // some static methods

    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
}

2.1 实例比较器

@Data
@AllArgsConstructor
public class OrderDTO {
    private String gmtModify;
    private String orderCode;
}

public class OrderComparator implements Comparator<OrderDTO> {
    @Override
    public int compare(OrderDTO o1, OrderDTO o2) {
        return o1.getGmtModify().compareTo(o2.getGmtModify());
    }
}

测试：

@Test
public void demo() {
    List<OrderDTO> orders = Arrays.asList(new OrderDTO("2023-01-01 10:00:00", "1001"),
            new OrderDTO("2023-02-01 10:00:00", "1001"), new OrderDTO("2023-01-01 10:10:00", "1001"));
    Collections.sort(orders, new OrderComparator());
    System.out.println(orders);
}

2.2 Collections.sort(list, Comparator c)

@Test
public void demo() {
    List<OrderDTO> orders = Arrays.asList(new OrderDTO("2023-01-01 10:00:00", "1001"),
            new OrderDTO("2023-02-01 10:00:00", "1001"), new OrderDTO("2023-01-01 10:10:00", "1001"));

    // Collections.sort(orders, new Comparator<OrderDTO>() {
    //     @Override
    //     public int compare(OrderDTO o1, OrderDTO o2) {
    //         return o1.getGmtModify().compareTo(o2.getGmtModify());
    //     }
    // });
    Collections.sort(orders, Comparator.comparing(OrderDTO::getGmtModify));

    System.out.println(orders);
}

Collections.sort() 方法

public class Collections {
    public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
    }
}

public interface List<E> extends Collection<E> {
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
}

2.3 list.sort(Comparator c)

@Data
@AllArgsConstructor
public class OrderDTO {
    private String gmtModify;
    private String orderCode;
}

@Test
public void demo() {
    List<OrderDTO> orders = Arrays.asList(new OrderDTO("2023-01-01 10:00:00", "1001"),
            new OrderDTO("2023-02-01 10:00:00", "1001"), new OrderDTO("2023-01-01 10:10:00", "1001"));

    // orders.sort(new Comparator<OrderDTO>() {
    //     @Override
    //     public int compare(OrderDTO o1, OrderDTO o2) {
    //         return o1.getGmtModify().compareTo(o2.getGmtModify());
    //     }
    // });
    orders.sort(Comparator.comparing(OrderDTO::getGmtModify));

    // 逆序
    // orders.sort((o1, o2) -> o2.getGmtModify().compareTo(o1.getGmtModify()));
    orders.sort(Comparator.comparing(OrderDTO::getGmtModify).reversed());
    System.out.println(orders);
}

3. 比较