区分几个reverse方法

Java高级特性和类库
留言

下列的几个reverse你能分清楚吗？

1
2
3
4
Comparator.reversed();
Comparator.reverseOrder();
Collections.reverse();
Collections.reverseOrder();

来看看源码：

  1. Comparator.reversed():

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

    返回一个比较器，强制该比较器的相反顺序。

  2. Comparator.reverseOrder:

    1
    2
    3
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
         return Collections.reverseOrder();
    }

    返回一个与 自然排序相反的比较器。

  3. Collections.reverse():

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public static void reverse(List<?> list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
        } else {
            ListIterator fwd = list.listIterator();
            ListIterator rev = list.listIterator(size);
            for (int i=0, mid=list.size()>>1; i<mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
    }

    private static void swap(List<?> list, int i, int j) {
        final List l = list;
        l.set(i, l.set(j, l.get(i)));
    }

    此方法反转指定列表中元素的顺序。

  4. Collections.reverseOrder():

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) {
            if (cmp == null) {
                return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
            } else if (cmp == ReverseComparator.REVERSE_ORDER) {
                return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
            } else if (cmp == Comparators.NaturalOrderComparator.INSTANCE) {
                return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
            } else if (cmp instanceof ReverseComparator2) {
                return ((ReverseComparator2<T>) cmp).cmp;
            } else {
                return new ReverseComparator2<>(cmp);
            }
        }

    此方法返回一个比较器，它强制指定比较器的反向排序。当不指定比较器的时候，返回ReverseComparator.REVERSE_ORDER。那顺便看下ReverseComparator的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private static class ReverseComparator
    implements Comparator<Comparable<Object>>, Serializable {

    @java.io.Serial
    private static final long serialVersionUID = 7207038068494060240L;

    static final ReverseComparator REVERSE_ORDER = new ReverseComparator();

    public int compare(Comparable<Object> c1, Comparable<Object> c2) {
        return c2.compareTo(c1);
    }

    @java.io.Serial
    private Object readResolve() { return Collections.reverseOrder(); }

    @Override
    public Comparator<Comparable<Object>> reversed() {
        return Comparator.naturalOrder();
    }

可见ReverseComparator.REVERSE_ORDER排序的顺序与自然排序刚好相反。

总结：

  • Comparator.reversed(): 无参数。底层调用Collections.reverseOrder(this)。返回一个与调用者比较器相反顺序的新的比较器。
  • Comparator.reverseOrder(): 无参数。底层调用Collections.reverseOrder()。返回一个与自然排序相反的比较器。
  • Collections.reverse(): 接受一个List类型参数，反转该List。无返回值。
  • Collections.reverseOrder(): 无参调用时，返回一个与自然排序相反的比较器；有参调用时，返回与参数相反的比较器。

参考：

Java Comparator使用指南 —- 看这一篇就够了
Java 8 新特性】Java Comparator.reverseOrder | 倒序排序-静态方法
深入学习java源码之Comparator.reverseOrder()与Comparator.compare ()
Java.util.Collections 类

文章目录