Ordering类-greatestOf

最新推荐文章于 2023-12-06 10:34:58 发布

原创最新推荐文章于 2023-12-06 10:34:58 发布 · 512 阅读

0 ·

CC 4.0 BY-SA版权

JAVA 专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了Guava库中的Ordering工具类，重点讲解了greatestOf方法的使用及其实现原理，包括如何通过反转比较器来获取集合中最大的k个元素。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Ordeing是Guava类库提供的一个强大的比较器工具，可以构造复杂的comparator，然后用在容器的比较、排序等操作中。

其本质上来说是一个特殊的Comparator实例。

1、greatestOf

　greatestOf(Iterable iterable, int k)：返回指定的第k个可迭代的最大的元素，按照这个从最大到最小的顺序。是不稳定的。

还是先看一下函数的使用：

List<String> names= Lists.newArrayList("cici","bobo","dodo","eva","haha","lala");
Ordering<String> naturalOrdering = Ordering.natural();
System.out.println("greatestOf:"+naturalOrdering.greatestOf(names, 3));

输出结果为：greatestOf:[lala, haha, eva]，按照从大到小排序，要求迭代到第三个。

2、看一下源码的实现：

public <E extends T> List<E> greatestOf(Iterable<E> iterable, int k) {
    return this.reverse().leastOf(iterable, k);
}

它调用reverse()方法，和leastof(iterable, k)方法

先看一下leastof方法：

public <E extends T> List<E> leastOf(Iterable<E> iterable, int k) {
    if (iterable instanceof Collection) {
        Collection<E> collection = (Collection)iterable;
        if ((long)collection.size() <= 2L * (long)k) {      //6<=2*3
            E[] array = (Object[])collection.toArray();//强转为数组，然后排序
            Arrays.sort(array, this);//进行排序
            if (array.length > k) {//6>3
                array = Arrays.copyOf(array, k);//copyOf(array,3)
            }  //复制前k位 

            return Collections.unmodifiableList(Arrays.asList(array));
        }
    }

    return this.leastOf(iterable.iterator(), k);
}

public <E extends T> List<E> leastOf(Iterator<E> iterator, int k) {
    Preconditions.checkNotNull(iterator);//先检查判空情况
    CollectPreconditions.checkNonnegative(k, "k");
    if (k != 0 && iterator.hasNext()) {
        if (k >= 1073741823) {//Integer.MAX_VALUE 
            ArrayList<E> list = Lists.newArrayList(iterator);
            Collections.sort(list, this);//直接对list进行排序
            if (list.size() > k) {
                list.subList(k, list.size()).clear();
            }

            list.trimToSize();
            return Collections.unmodifiableList(list);
        } else {
            //长度没有超过最大值，就调用TopKSelector排序
            TopKSelector<E> selector = TopKSelector.least(k, this);
            selector.offerAll(iterator);
            return selector.topK();
        }
    } else {//if（k==0）
        return Collections.emptyList();
    }
}