Java Code Examples for java.util.PriorityQueue#toArray()

/**
 * 根据属性排序子节点
 * @param assistantNodes
 * @return
 */
public static AssistantNode[] sortAssistantNodes(List<AssistantNode> assistantNodes) {
    if (assistantNodes == null || assistantNodes.size() == 0) {
        return new AssistantNode[0];
    }

    PriorityQueue<AssistantNode> sorted = new PriorityQueue<>(assistantNodes.size(), new Comparator<AssistantNode>() {
        @Override
        public int compare(AssistantNode lhs, AssistantNode rhs) {
            int lhsP = lhs.calculatePriority();
            int rhsP = rhs.calculatePriority();
            return rhsP- lhsP;
        }
    });
    sorted.addAll(assistantNodes);
    return sorted.toArray(new AssistantNode[assistantNodes.size()]);
}
 

public void outputSecletedFeatures(PriorityQueue<Term> features){
	System.out.println("store features...=======================================");
	try{
		TextFileWriter tw = new TextFileWriter("selectedFeatures","UTF-8");
		Term[] f;
		f = features.toArray(new Term[features.size()]);
		System.out.println(f.length);
		for(int i=f.length-1; i>=0; i--){
			tw.writeLine(lexicon.getWord(f[i].id).getName() + " " + f[i].weight);
		}
		tw.flush();
		tw.close();
		
	}catch(IOException e){
		e.printStackTrace();
	}
	System.out.println("end store features...=======================================");
}
 

static public MinimumSpanningTree build(TreeNode[] nodes, int[][] distances, int root) {
	MinimumSpanningTree mst = new MinimumSpanningTree(nodes[root]);
	PriorityQueue<Vertex> costList = new PriorityQueue<Vertex>();
	
	for(int i = 0; i < distances.length; i++) {
		if(i != root)
			costList.add(new Vertex(i, root, distances[i][root]));
	}
	
	while(!costList.isEmpty()) {
		Vertex next = costList.poll();
		nodes[next.to].addChild(nodes[next.id]);
		Vertex[] remains = costList.toArray(new Vertex[0]);
		for(int i = 0; i<remains.length; i++) {
			if(distances[remains[i].id][next.id] <= remains[i].value) {
				costList.remove(remains[i]);
				remains[i].to = next.id;
				remains[i].value = distances[remains[i].id][next.id];
				costList.add(remains[i]);
			}
		}
	}
	return mst;	
}
 

static public Result chooseAndBuildLine(TreeNode[] nodes, int[][] distances, 
		int root, int nodeNumber) {
	PriorityQueue<Vertex> costList = new PriorityQueue<Vertex>();
	int[] locationsChoosed = new int[nodeNumber];	
	Arrays.fill(locationsChoosed, -1);
	int totalWeight = 0;

	for (int i = 0; i < distances.length; i++) {
		if (i != root)
			costList.add(new Vertex(i, root, distances[i][root]));
	}
	int number = 0;	
	while ((number < nodeNumber) && (!costList.isEmpty())) {
		Vertex next = costList.poll();
		nodes[next.to].addChild(nodes[next.id]);
		totalWeight += next.value;
		//LOG.info("NTar: add " + nodes[next.id] + " as child of " + nodes[next.to]);
		locationsChoosed[number] = next.id;
		number = number + 1;
		Vertex[] remains = costList.toArray(new Vertex[0]);
		for (int i = 0; i<remains.length; i++) {
			costList.remove(remains[i]);
			remains[i].to = next.id;
			remains[i].value = distances[remains[i].id][next.id];
			costList.add(remains[i]);
		}
	}
	return new Result(totalWeight, locationsChoosed);
}
 

public static FloatElement[] topNSort(final float[] vec, final int topN,
		final Set<Integer> exclusions) {

	final Comparator<FloatElement> valAscending = new FloatElement.ValueComparator(
			false);
	final Comparator<FloatElement> valDescending = new FloatElement.ValueComparator(
			true);

	PriorityQueue<FloatElement> heap = new PriorityQueue<FloatElement>(topN,
			valAscending);

	for (int i = 0; i < vec.length; i++) {
		if (exclusions != null && exclusions.contains(i) == true) {
			continue;
		}
		float val = vec[i];
		if (heap.size() < topN) {
			heap.add(new FloatElement(i, val));

		} else {
			if (heap.peek().value < val) {
				heap.poll();
				heap.add(new FloatElement(i, val));
			}
		}
	}

	FloatElement[] heapArray = new FloatElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

public static FloatElement[] topNSort(final FloatElement[] vec,
		final int topN, final Set<Integer> exclusions) {

	final Comparator<FloatElement> valAscending = new FloatElement.ValueComparator(
			false);
	final Comparator<FloatElement> valDescending = new FloatElement.ValueComparator(
			true);

	PriorityQueue<FloatElement> heap = new PriorityQueue<FloatElement>(topN,
			valAscending);

	for (int i = 0; i < vec.length; i++) {
		if (exclusions != null && exclusions.contains(i) == true) {
			continue;
		}
		FloatElement element = vec[i];
		if (heap.size() < topN) {
			heap.add(element);

		} else {
			if (heap.peek().value < element.getValue()) {
				heap.poll();
				heap.add(element);
			}
		}
	}

	FloatElement[] heapArray = new FloatElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

public static FloatElement[] topNSortOffset(final float[] vec, int topN,
		final int offset, final int length, Set<Integer> exclusions) {

	final Comparator<FloatElement> valAscending = new FloatElement.ValueComparator(
			false);
	final Comparator<FloatElement> valDescending = new FloatElement.ValueComparator(
			true);
	PriorityQueue<FloatElement> heap = new PriorityQueue<>(topN,
			valAscending);

	for (int i = 0; i < length; i++) {
		if (exclusions != null && exclusions.contains(i) == true) {
			continue;
		}
		float val = vec[i + offset];
		if (heap.size() < topN) {
			heap.add(new FloatElement(i, val));

		} else {
			if (heap.peek().getValue() < val) {
				heap.poll();
				heap.add(new FloatElement(i, val));
			}
		}
	}

	FloatElement[] heapArray = new FloatElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

static public Result chooseAndBuildTree(TreeNode[] nodes, int[][] distances, 
		int root, int nodeNumber) {
	PriorityQueue<Vertex> costList = new PriorityQueue<Vertex>();
	int[] locationsChoosed = new int[nodeNumber];	
	int totalWeight = 0;
	for(int i = 0; i < distances.length; i++) {
		if(i != root)
			costList.add(new Vertex(i, root, distances[i][root]));
	}
	int number = 0;	
	while((number < nodeNumber) && (!costList.isEmpty())) {
		Vertex next = costList.poll();
		nodes[next.to].addChild(nodes[next.id]);
		totalWeight += next.value;
		//LOG.info("NTar: add " + nodes[next.id] + " as child of " + nodes[next.to]);
		locationsChoosed[number] = next.id;
		number = number + 1;
		Vertex[] remains = costList.toArray(new Vertex[0]);
		for(int i = 0; i<remains.length; i++) {
			if(distances[remains[i].id][next.id] < remains[i].value) {
				costList.remove(remains[i]);
				remains[i].to = next.id;
				remains[i].value = distances[remains[i].id][next.id];
				costList.add(remains[i]);
			}
		}
	}
	
	return new Result(totalWeight, locationsChoosed);
}
 

public static MLMatrixElement[] topNSort(final int rowIndex,
		final float[] vec, final int topN, final Set<Integer> exclusions) {

	final Comparator<MLMatrixElement> valAscending = new MLMatrixElement.ValueComparator(
			false);
	final Comparator<MLMatrixElement> valDescending = new MLMatrixElement.ValueComparator(
			true);

	PriorityQueue<MLMatrixElement> heap = new PriorityQueue<MLMatrixElement>(
			topN, valAscending);

	for (int i = 0; i < vec.length; i++) {
		if (exclusions != null && exclusions.contains(i) == true) {
			continue;
		}
		float val = vec[i];
		if (heap.size() < topN) {
			heap.add(new MLMatrixElement(rowIndex, i, val, 0));

		} else {
			if (heap.peek().value < val) {
				heap.poll();
				heap.add(new MLMatrixElement(rowIndex, i, val, 0));
			}
		}
	}

	MLMatrixElement[] heapArray = new MLMatrixElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

public static MLMatrixElement[] topNSort(final MLMatrixElement[] elements,
		final int topN, final Set<Integer> exclusions) {

	final Comparator<MLMatrixElement> valAscending = new MLMatrixElement.ValueComparator(
			false);
	final Comparator<MLMatrixElement> valDescending = new MLMatrixElement.ValueComparator(
			true);

	PriorityQueue<MLMatrixElement> heap = new PriorityQueue<MLMatrixElement>(
			topN, valAscending);

	for (int i = 0; i < elements.length; i++) {
		if (exclusions != null && exclusions.contains(i) == true) {
			continue;
		}
		MLMatrixElement element = elements[i];
		if (heap.size() < topN) {
			heap.add(element);

		} else {
			if (heap.peek().value < element.value) {
				heap.poll();
				heap.add(element);
			}
		}
	}

	MLMatrixElement[] heapArray = new MLMatrixElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

/**
 * toArray contains all elements
 */
public void testToArray() {
    PriorityQueue q = populatedQueue(SIZE);
    Object[] o = q.toArray();
    Arrays.sort(o);
    for (int i = 0; i < o.length; i++)
        assertSame(o[i], q.poll());
}
 

/**
 * toArray(a) contains all elements
 */
public void testToArray2() {
    PriorityQueue<Integer> q = populatedQueue(SIZE);
    Integer[] ints = new Integer[SIZE];
    Integer[] array = q.toArray(ints);
    assertSame(ints, array);
    Arrays.sort(ints);
    for (int i = 0; i < ints.length; i++)
        assertSame(ints[i], q.poll());
}
 

/**
 * {@link PriorityQueue#toArray()}
 */
public void test_toArray() throws Exception {
    PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>();
    Integer[] array = { 2, 45, 7, -12, 9 };
    for (int i = 0; i < array.length; i++) {
        integerQueue.add(array[i]);
    }
    Object[] returnArray = integerQueue.toArray();
    assertEquals(returnArray.length, integerQueue.size());
    for (int i = 0; i < returnArray.length; i++) {
        assertTrue(integerQueue.contains(returnArray[i]));
    }
}
 

/**
 * toArray contains all elements
 */
public void testToArray() {
    PriorityQueue q = populatedQueue(SIZE);
    Object[] o = q.toArray();
    Arrays.sort(o);
    for (int i = 0; i < o.length; i++)
        assertSame(o[i], q.poll());
}
 

/**
 * toArray(a) contains all elements
 */
public void testToArray2() {
    PriorityQueue<Integer> q = populatedQueue(SIZE);
    Integer[] ints = new Integer[SIZE];
    Integer[] array = q.toArray(ints);
    assertSame(ints, array);
    Arrays.sort(ints);
    for (int i = 0; i < ints.length; i++)
        assertSame(ints[i], q.poll());
}
 

private static Object[] createIndexes( DatabaseLookupData stepData, RowMetaInterface keysMeta, Object[][] keys ) {
  final int rowsAmount = keys.length;
  final int[] conditions = stepData.conditions;

  // it makes sense to apply restrictions in the specific order, namely, to use those, that can filter more elements
  // Index.restrictionComparator() uses heuristic "restriction power" of each index
  PriorityQueue<Index> indexes = new PriorityQueue<>( conditions.length, Index.restrictionComparator() );
  List<int[]> otherConditions = new ArrayList<>();
  for ( int i = 0, len = conditions.length; i < len; i++ ) {
    int condition = conditions[ i ];
    Index index = null;
    switch ( condition ) {
      case DatabaseLookupMeta.CONDITION_EQ:
        index = new EqIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_NE:
        index = EqIndex.nonEqualityIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_LT:
        index = new LtIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_LE:
        index = GtIndex.lessOrEqualCache( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_GT:
        index = new GtIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_GE:
        index = LtIndex.greaterOrEqualCache( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_IS_NULL:
        index = new IsNullIndex( i, keysMeta.getValueMeta( i ), rowsAmount, true );
        break;
      case DatabaseLookupMeta.CONDITION_IS_NOT_NULL:
        index = new IsNullIndex( i, keysMeta.getValueMeta( i ), rowsAmount, false );
        break;
    }
    if ( index == null ) {
      otherConditions.add( new int[] { i, condition } );
    } else {
      index.performIndexingOf( keys );
      indexes.add( index );
    }
  }

  return new Object[] {
    indexes.toArray( new Index[ indexes.size() ] ),
    otherConditions.toArray( new int[ otherConditions.size() ][] )
  };
}
 

public static FloatElement[] topNSortOffset(final float[] vec, int topN,
		int[] exclusionSorted, final int offset, final int length) {

	final Comparator<FloatElement> valAscending = new FloatElement.ValueComparator(
			false);
	final Comparator<FloatElement> valDescending = new FloatElement.ValueComparator(
			true);
	PriorityQueue<FloatElement> heap = new PriorityQueue<>(topN,
			valAscending);

	int skipping = exclusionSorted == null ? -1 : exclusionSorted[0];
	int skippingCur = 0;
	final int exclusionEnd = exclusionSorted == null ? 0
			: exclusionSorted.length;
	for (int i = 0; i < length; i++) {
		if (i == skipping) {
			skippingCur++;
			if (skippingCur < exclusionEnd) {
				skipping = exclusionSorted[skippingCur];
			} else {
				skipping = -1;
			}
			continue;
		}
		float val = vec[i + offset];
		if (heap.size() < topN) {
			heap.add(new FloatElement(i, val));

		} else {
			if (heap.peek().getValue() < val) {
				heap.poll();
				heap.add(new FloatElement(i, val));
			}
		}
	}

	FloatElement[] heapArray = new FloatElement[heap.size()];
	heap.toArray(heapArray);
	Arrays.sort(heapArray, valDescending);

	return heapArray;
}
 

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 Object[] createIndexes( DatabaseLookupData transformData, IRowMeta keysMeta, Object[][] keys ) {
  final int rowsAmount = keys.length;
  final int[] conditions = transformData.conditions;

  // it makes sense to apply restrictions in the specific order, namely, to use those, that can filter more elements
  // Index.restrictionComparator() uses heuristic "restriction power" of each index
  PriorityQueue<Index> indexes = new PriorityQueue<>( conditions.length, Index.restrictionComparator() );
  List<int[]> otherConditions = new ArrayList<>();
  for ( int i = 0, len = conditions.length; i < len; i++ ) {
    int condition = conditions[ i ];
    Index index = null;
    switch ( condition ) {
      case DatabaseLookupMeta.CONDITION_EQ:
        index = new EqIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_NE:
        index = EqIndex.nonEqualityIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_LT:
        index = new LtIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_LE:
        index = GtIndex.lessOrEqualCache( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_GT:
        index = new GtIndex( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_GE:
        index = LtIndex.greaterOrEqualCache( i, keysMeta.getValueMeta( i ), rowsAmount );
        break;
      case DatabaseLookupMeta.CONDITION_IS_NULL:
        index = new IsNullIndex( i, keysMeta.getValueMeta( i ), rowsAmount, true );
        break;
      case DatabaseLookupMeta.CONDITION_IS_NOT_NULL:
        index = new IsNullIndex( i, keysMeta.getValueMeta( i ), rowsAmount, false );
        break;
    }
    if ( index == null ) {
      otherConditions.add( new int[] { i, condition } );
    } else {
      index.performIndexingOf( keys );
      indexes.add( index );
    }
  }

  return new Object[] {
    indexes.toArray( new Index[ indexes.size() ] ),
    otherConditions.toArray( new int[ otherConditions.size() ][] )
  };
}