public <E extends T> List<E> leastOf(Iterable<E> iterable, int k) {
if (iterable instanceof Collection) {
Collection<E> collection = (Collection<E>) iterable;
//当collection长度小于2L * k时,使用数组的方式进行计算。
if (collection.size() <= 2L * k) {
// In this case, just dumping the collection to an array and sorting is
// faster than using the implementation for Iterator, which is
// specialized for k much smaller than n.
@SuppressWarnings ( "unchecked" ) // c only contains E's and doesn't escape
//强转为数据,然后调用数组的sort方法。
E[] array = (E[]) collection.toArray();
Arrays.sort(array, this );
if (array.length > k) {
//调用Arrays.copyOf方法。拷贝排序后的数组的前k位,之前使用了ReverseOrdering,所以可以得到最大的k个元素
/*
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> original.getClass()) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)original.getClass()== (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
*/
array = Arrays.copyOf(array, k);
}
return Collections.unmodifiableList(Arrays.asList(array));
}
}
/*
public <E extends T> List<E> leastOf(Iterator<E> iterator, int k) {
checkNotNull(iterator);
checkNonnegative(k, "k");
if (k == 0 || !iterator.hasNext()) {
return ImmutableList.of();
} else if (k >= Integer.MAX_VALUE / 2) {
//长度大于Integer.MAX_VALUE / 2,使用ArrayList集合,进行排序并使用subList截取
// k is really large; just do a straightforward sorted-copy-and-sublist
ArrayList<E> list = Lists.newArrayList(iterator);
Collections.sort(list, this);
if (list.size() > k) {
list.subList(k, list.size()).clear();
}
list.trimToSize();
return Collections.unmodifiableList(list);
} else {
//长度不是很大时,调用TopKSelector的least方法
TopKSelector<E> selector = TopKSelector.least(k, this);
selector.offerAll(iterator);
return selector.topK();
}
}
*/
return leastOf(iterable.iterator(), k);
}
|