MinMaxPriorityQueue.orderedBy(rpComparator).create(); regionsToReturn = new ArrayList<>();
((float) buckets[right].usedCount) / buckets[right].itemCount); }).maximumSize(bucketCount).create();
/** * Builds a new min-max priority queue using the previously specified * options, and having no initial contents. */ public <T extends B> MinMaxPriorityQueue<T> create() { return create(Collections.<T>emptySet()); }
/** * Creates and returns a new builder, configured to build {@code * MinMaxPriorityQueue} instances that use {@code comparator} to determine the * least and greatest elements. */ public static <B> Builder<B> orderedBy(Comparator<B> comparator) { return new Builder<B>(comparator); }
/** * Creates and returns a new builder, configured to build {@code * MinMaxPriorityQueue} instances sized appropriately to hold {@code * expectedSize} elements. */ public static Builder<Comparable> expectedSize(int expectedSize) { return new Builder<Comparable>(Ordering.natural()).expectedSize(expectedSize); }
/** * Creates a new min-max priority queue using natural order, no maximum size, * and initially containing the given elements. */ public static <E extends Comparable<E>> MinMaxPriorityQueue<E> create( Iterable<? extends E> initialContents) { return new Builder<E>(Ordering.<E>natural()).create(initialContents); }
/** * Creates and returns a new builder, configured to build {@code * MinMaxPriorityQueue} instances that are limited to {@code maximumSize} * elements. Each time a queue grows beyond this bound, it immediately * removes its greatest element (according to its comparator), which might be * the element that was just added. */ public static Builder<Comparable> maximumSize(int maximumSize) { return new Builder<Comparable>(Ordering.natural()).maximumSize(maximumSize); }
/** * @param maxSize the target size of elements in the queue * @param blockSize expected average size of blocks */ public CachedEntryQueue(long maxSize, long blockSize) { int initialSize = (int) (maxSize / blockSize); if (initialSize == 0) { initialSize++; } queue = MinMaxPriorityQueue.orderedBy(new Comparator<Map.Entry<BlockCacheKey, BucketEntry>>() { @Override public int compare(Entry<BlockCacheKey, BucketEntry> entry1, Entry<BlockCacheKey, BucketEntry> entry2) { return BucketEntry.COMPARATOR.compare(entry1.getValue(), entry2.getValue()); } }).expectedSize(initialSize).create(); cacheSize = 0; this.maxSize = maxSize; }
/** * @param maxSize the target size of elements in the queue * @param blockSize expected average size of blocks */ public LruCachedBlockQueue(long maxSize, long blockSize) { int initialSize = (int)(maxSize / blockSize); if(initialSize == 0) initialSize++; queue = MinMaxPriorityQueue.expectedSize(initialSize).create(); heapSize = 0; this.maxSize = maxSize; }