下面列出了java.util.PriorityQueue#clear ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public ArrayList<Integer> maxInWindows(int[] num, int size) {
ArrayList<Integer> result = new ArrayList<Integer>(); //用一个列表存放每次窗口移动一位后窗口内的最大值
if (num == null || num.length == 0 || size <= 0 || num.length < size) return result;
PriorityQueue<Integer> queue = new PriorityQueue<Integer>(size, new Comparator<Integer>() { //利用最大值排在前的优先队列自动比较放入队列的值
public int compare(Integer i1, Integer i2) {
return i2 - i1; //这样重写比较器的比较函数，可以使前一个值小于后一个值时返回正数，与默认情况为负数相反
}
});
int count = 0; //每次加入窗口的元素数量的计数
for (int i = 0; i < num.length - size + 1; i++) { //num.length-size为最后一个窗口的开头位置，正如常见的i<array.length一样，这里的num.length-size+1是一个到不了的索引位置
while (count < size) { //当计数没达到窗口大小时，朝优先队列中添加元素，形成一个窗口
queue.add(num[i + count]);
count++;
}
result.add(queue.peek()); //经过优先队列排序后，最大元素排在前，因此队列第一个元素就是最大元素
count = 0; //一个窗口中的最大元素已经找到，清空计数和优先队列中的元素，进行下一个窗口多个元素的添加
queue.clear();
}
return result;
}
private void computeAndForwardSignatures(List<FeatureValue> features, Object[] forwardObjs)
throws HiveException {
final PriorityQueue<Integer> minhashes = new PriorityQueue<Integer>();
// Compute N sets K minhash values
for (int i = 0; i < num_hashes; i++) {
float weightedMinHashValues = Float.MAX_VALUE;
for (FeatureValue fv : features) {
Object f = fv.getFeature();
int hashIndex = Math.abs(hashFuncs[i].hash(f));
float w = fv.getValueAsFloat();
float hashValue = calcWeightedHashValue(hashIndex, w);
if (hashValue < weightedMinHashValues) {
weightedMinHashValues = hashValue;
minhashes.offer(hashIndex);
}
}
forwardObjs[0] = getSignature(minhashes, num_keygroups);
forward(forwardObjs);
minhashes.clear();
}
}
private static List<IntWritable> computeSignatures(final List<FeatureValue> features,
final int numHashes, final int keyGroups, final int[] seeds) throws HiveException {
final IntWritable[] hashes = new IntWritable[numHashes];
final PriorityQueue<Integer> minhashes = new PriorityQueue<Integer>();
// Compute N sets K minhash values
for (int i = 0; i < numHashes; i++) {
float weightedMinHashValues = Float.MAX_VALUE;
for (FeatureValue fv : features) {
Object f = fv.getFeature();
assert (f != null);
String fs = f.toString();
int hashIndex = Math.abs(MurmurHash3.murmurhash3_x86_32(fs, seeds[i]));
float w = fv.getValueAsFloat();
float hashValue = calcWeightedHashValue(hashIndex, w);
if (hashValue < weightedMinHashValues) {
weightedMinHashValues = hashValue;
minhashes.offer(hashIndex);
}
}
hashes[i] = val(getSignature(minhashes, keyGroups));
minhashes.clear();
}
return Arrays.asList(hashes);
}
/**
* clear removes all elements
*/
public void testClear() {
PriorityQueue q = populatedQueue(SIZE);
q.clear();
assertTrue(q.isEmpty());
assertEquals(0, q.size());
q.add(new Integer(1));
assertFalse(q.isEmpty());
q.clear();
assertTrue(q.isEmpty());
}
@Test
public void testPriorityRandomOperations() {
for (int loop = 0; loop < LOOPS; loop++) {
double p1 = Math.random();
double p2 = Math.random();
if (p2 < p1) {
double tmp = p1;
p1 = p2;
p2 = tmp;
}
Integer[] ar = genRandArray(LOOPS);
int d = 2 + (int) (Math.random() * 6);
MinDHeap<Integer> pq = new MinDHeap<>(d, LOOPS);
PriorityQueue<Integer> pq2 = new PriorityQueue<>(LOOPS);
for (int i = 0; i < LOOPS; i++) {
int e = ar[i];
double r = Math.random();
if (0 <= r && r <= p1) {
pq.add(e);
pq2.add(e);
} else if (p1 < r && r <= p2) {
if (!pq2.isEmpty()) assertEquals(pq.poll(), pq2.poll());
} else {
pq.clear();
pq2.clear();
}
}
assertEquals(pq.peek(), pq2.peek());
}
}
@Test
public void testPriorityRandomOperations() {
for (int loop = 0; loop < LOOPS; loop++) {
double p1 = Math.random();
double p2 = Math.random();
if (p2 < p1) {
double tmp = p1;
p1 = p2;
p2 = p1;
}
Integer[] ar = genRandArray(LOOPS);
int d = 2 + (int) (Math.random() * 6);
MinDHeap<Integer> pq = new MinDHeap<>(d, LOOPS);
PriorityQueue<Integer> pq2 = new PriorityQueue<>(LOOPS);
for (int i = 0; i < LOOPS; i++) {
int e = ar[i];
double r = Math.random();
if (0 <= r && r <= p1) {
pq.add(e);
pq2.add(e);
} else if (p1 < r && r <= p2) {
if (!pq2.isEmpty()) assertEquals(pq.poll(), pq2.poll());
} else {
pq.clear();
pq2.clear();
}
}
assertEquals(pq.peek(), pq2.peek());
}
}
/**
* java.util.PriorityQueue#Clear()
*/
public void test_clear() {
PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
int[] array = { 2, 45, 7, -12, 9 };
for (int i = 0; i < array.length; i++) {
integerQueue.offer(array[i]);
}
integerQueue.clear();
assertTrue(integerQueue.isEmpty());
}
/**
* clear removes all elements
*/
public void testClear() {
PriorityQueue q = populatedQueue(SIZE);
q.clear();
assertTrue(q.isEmpty());
assertEquals(0, q.size());
q.add(new Integer(1));
assertFalse(q.isEmpty());
q.clear();
assertTrue(q.isEmpty());
}
protected ArrayList<Recognition> nms(ArrayList<Recognition> list) {
ArrayList<Recognition> nmsList = new ArrayList<Recognition>();
for (int k = 0; k < mLabelList.size(); k++) {
//1.find max confidence per class
PriorityQueue<Recognition> pq =
new PriorityQueue<Recognition>(
10,
new Comparator<Recognition>() {
@Override
public int compare(final Recognition lhs, final Recognition rhs) {
// Intentionally reversed to put high confidence at the head of the queue.
return Float.compare(rhs.getConfidence(), lhs.getConfidence());
}
});
for (int i = 0; i < list.size(); ++i) {
if (list.get(i).detectedClass == k) {
pq.add(list.get(i));
}
}
Log.d("wangmin", "class[" + k + "] pq size: " + pq.size());
//2.do non maximum suppression
while(pq.size() > 0) {
//insert detection with max confidence
Recognition[] a = new Recognition[pq.size()];
Recognition[] detections = pq.toArray(a);
Recognition max = detections[0];
nmsList.add(max);
Log.d("wangmin", "before nms pq size: " + pq.size());
//clear pq to do next nms
pq.clear();
for (int j = 1; j < detections.length; j++) {
Recognition detection = detections[j];
RectF b = detection.getLocation();
if (box_iou(max.getLocation(), b) < mNmsThresh){
pq.add(detection);
}
}
Log.d("wangmin", "after nms pq size: " + pq.size());
}
}
return nmsList;
}
private static void realMain(String[] args) throws Throwable {
final PriorityQueue<Integer> q = new PriorityQueue<>();
Iterator<Integer> it;
//----------------------------------------------------------------
// Empty
//----------------------------------------------------------------
checkQ(q);
check(q.isEmpty());
check(! q.contains(1));
it = q.iterator();
removeIsCurrentlyIllegal(it);
noMoreElements(it);
q.clear();
check(q.isEmpty());
//----------------------------------------------------------------
// Singleton
//----------------------------------------------------------------
q.add(1);
checkQ(q, 1);
check(! q.isEmpty());
check(q.contains(1));
it = q.iterator();
removeIsCurrentlyIllegal(it);
check(it.hasNext());
equal(it.next(), 1);
noMoreElements(it);
remove(it, q);
check(q.isEmpty());
noMoreElements(it);
checkQ(q);
q.clear();
//----------------------------------------------------------------
// @see PriorityQueue.forgetMeNot
//----------------------------------------------------------------
final Integer[] a = {0, 4, 1, 6, 7, 2, 3}; // Carefully chosen!
q.addAll(Arrays.asList(a));
checkQ(q, a);
it = q.iterator();
checkQ(q, a);
removeIsCurrentlyIllegal(it);
checkQ(q, a);
check(it.hasNext());
removeIsCurrentlyIllegal(it);
checkQ(q, a);
check(it.hasNext());
equal(it.next(), 0);
equal(it.next(), 4);
equal(it.next(), 1);
equal(it.next(), 6);
check(it.hasNext());
checkQ(q, a);
remove(it, q);
checkQ(q, 0, 3, 1, 4, 7, 2);
check(it.hasNext());
removeIsCurrentlyIllegal(it);
equal(it.next(), 7);
remove(it, q);
checkQ(q, 0, 2, 1, 4, 3);
check(it.hasNext());
removeIsCurrentlyIllegal(it);
check(it.hasNext());
equal(it.next(), 3);
equal(it.next(), 2);
check(! it.hasNext());
remove(it, q);
checkQ(q, 0, 3, 1, 4);
check(! it.hasNext());
noMoreElements(it);
removeIsCurrentlyIllegal(it);
}
public NodeEdgeModel calculateClosenessCentrality(NodeEdgeModel nodeEdgeModel){
PriorityQueue<GraphNode> queue = new PriorityQueue<>();
ArrayList<GraphNode> visited = new ArrayList<>();
int level;
int counterUntilNextLevel;
int counterOfNextLevel;
double result;
GraphNode currentNode;
ArrayList<GraphNode> GraphNodes = nodeEdgeModel.getNodes();
for(GraphNode node: GraphNodes){
visited.clear();
queue.clear();
queue.add(node);
result = 0;
level = 0;
counterUntilNextLevel = 1;
counterOfNextLevel = 0;
while(!queue.isEmpty()){
currentNode = queue.poll();
counterOfNextLevel += currentNode.getConnectedNodes().size();
visited.add(currentNode);
ArrayList<GraphNode> currentNodeList = new ArrayList<>(currentNode.getConnectedNodes());
for(GraphNode gNode: currentNodeList){
if(!visited.contains(gNode) && !queue.contains(gNode)){
queue.add(gNode);
}
}
if(level>0) {
result += 1.0 / (double) level;
}
counterUntilNextLevel--;
if(counterUntilNextLevel == 0){
level++;
counterUntilNextLevel = counterOfNextLevel;
counterOfNextLevel = 0;
}
}
node.setNumericAttribute(closenessKey, new Double(result));
}
return nodeEdgeModel;
}
@Test
public void testPQReusability() {
List<Integer> SZs = genUniqueRandList(LOOPS);
PriorityQueue<Integer> PQ = new PriorityQueue<>();
BinaryHeap<Integer> pq = new BinaryHeap<>();
for (int sz : SZs) {
pq.clear();
PQ.clear();
List<Integer> nums = genRandList(sz);
for (int n : nums) {
pq.add(n);
PQ.add(n);
}
Collections.shuffle(nums);
for (int i = 0; i < sz / 2; i++) {
// Sometimes add a new number into the BinaryHeap
if (0.25 < Math.random()) {
int randNum = (int) (Math.random() * 10000);
PQ.add(randNum);
pq.add(randNum);
}
int removeNum = nums.get(i);
assertTrue(pq.isMinHeap(0));
assertEquals(PQ.size(), pq.size());
assertEquals(PQ.peek(), pq.peek());
PQ.remove(removeNum);
pq.remove(removeNum);
assertEquals(PQ.peek(), pq.peek());
assertEquals(PQ.size(), pq.size());
assertTrue(pq.isMinHeap(0));
}
}
}
@Test
public void testPQReusability() {
List<Integer> SZs = genUniqueRandList(LOOPS);
PriorityQueue<Integer> PQ = new PriorityQueue<>();
BinaryHeapQuickRemovals<Integer> pq = new BinaryHeapQuickRemovals<>();
for (int sz : SZs) {
pq.clear();
PQ.clear();
List<Integer> nums = genRandList(sz);
for (int n : nums) {
pq.add(n);
PQ.add(n);
}
Collections.shuffle(nums);
for (int i = 0; i < sz / 2; i++) {
// Sometimes add a new number into the BinaryHeapQuickRemovals
if (0.25 < Math.random()) {
int randNum = (int) (Math.random() * 10000);
PQ.add(randNum);
pq.add(randNum);
}
int removeNum = nums.get(i);
assertTrue(pq.isMinHeap(0));
assertEquals(PQ.size(), pq.size());
assertEquals(PQ.peek(), pq.peek());
PQ.remove(removeNum);
pq.remove(removeNum);
assertEquals(PQ.peek(), pq.peek());
assertEquals(PQ.size(), pq.size());
assertTrue(pq.isMinHeap(0));
}
}
}
@Test
public void testPQReusability() {
List<Integer> SZs = genUniqueRandList(LOOPS);
PriorityQueue<Integer> PQ = new PriorityQueue<>();
BinaryHeap<Integer> pq = new BinaryHeap<>();
for (int sz : SZs) {
pq.clear();
PQ.clear();
List<Integer> nums = genRandList(sz);
for (int n : nums) {
pq.add(n);
PQ.add(n);
}
Collections.shuffle(nums);
for (int i = 0; i < sz / 2; i++) {
// Sometimes add a new number into the BinaryHeap
if (0.25 < Math.random()) {
int randNum = (int) (Math.random() * 10000);
PQ.add(randNum);
pq.add(randNum);
}
int removeNum = nums.get(i);
assertTrue(pq.isMinHeap(0));
assertEquals(PQ.size(), pq.size());
assertEquals(PQ.peek(), pq.peek());
PQ.remove(removeNum);
pq.remove(removeNum);
assertEquals(PQ.peek(), pq.peek());
assertEquals(PQ.size(), pq.size());
assertTrue(pq.isMinHeap(0));
}
}
}
@Test
public void testPQReusability() {
List<Integer> SZs = genUniqueRandList(LOOPS);
PriorityQueue<Integer> PQ = new PriorityQueue<>();
BinaryHeapQuickRemovals<Integer> pq = new BinaryHeapQuickRemovals<>();
for (int sz : SZs) {
pq.clear();
PQ.clear();
List<Integer> nums = genRandList(sz);
for (int n : nums) {
pq.add(n);
PQ.add(n);
}
Collections.shuffle(nums);
for (int i = 0; i < sz / 2; i++) {
// Sometimes add a new number into the BinaryHeapQuickRemovals
if (0.25 < Math.random()) {
int randNum = (int) (Math.random() * 10000);
PQ.add(randNum);
pq.add(randNum);
}
int removeNum = nums.get(i);
assertTrue(pq.isMinHeap(0));
assertEquals(PQ.size(), pq.size());
assertEquals(PQ.peek(), pq.peek());
PQ.remove(removeNum);
pq.remove(removeNum);
assertEquals(PQ.peek(), pq.peek());
assertEquals(PQ.size(), pq.size());
assertTrue(pq.isMinHeap(0));
}
}
}