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

/**
 * Determine the k nearest neighbors for a test instance.
 *
 * @param testInstance
 *            The time series to determine the k nearest neighbors for.
 * @return Queue of the k nearest neighbors as pairs (class, distance).
 */
protected PriorityQueue<Pair<Integer, Double>> calculateNearestNeigbors(final double[] testInstance) {
	int numberOfTrainInstances = this.values.length;
	// Priority queue of (class, distance)-pairs for nearest neigbors, sorted by
	// distance ascending.
	PriorityQueue<Pair<Integer, Double>> nearestNeighbors = new PriorityQueue<>(nearestNeighborComparator);

	// Calculate the k nearest neighbors.
	for (int i = 0; i < numberOfTrainInstances; i++) {
		double d = this.distanceMeasure.distance(testInstance, this.values[i]);

		Pair<Integer, Double> neighbor = new Pair<>(this.targets[i], d);
		nearestNeighbors.add(neighbor);
		if (nearestNeighbors.size() > this.k) {
			nearestNeighbors.poll();
		}
	}
	return nearestNeighbors;
}
 

private List<Recognition> getRecognition(final PriorityQueue<Recognition> priorityQueue) {
    List<Recognition> recognitions = new ArrayList();

    if (priorityQueue.size() > 0) {
        // Best recognition
        Recognition bestRecognition = priorityQueue.poll();
        recognitions.add(bestRecognition);

        for (int i = 0; i < Math.min(priorityQueue.size(), MAX_RESULTS); ++i) {
            Recognition recognition = priorityQueue.poll();
            boolean overlaps = false;
            for (Recognition previousRecognition : recognitions) {
                overlaps = overlaps || (getIntersectionProportion(previousRecognition.getLocation(),
                        recognition.getLocation()) > OVERLAP_THRESHOLD);
            }

            if (!overlaps) {
                recognitions.add(recognition);
            }
        }
    }

    return recognitions;
}
 

private List<Recognition> getRecognition(final PriorityQueue<Recognition> priorityQueue) {
    List<Recognition> recognitions = new ArrayList();

    if (priorityQueue.size() > 0) {
        // Best recognition
        Recognition bestRecognition = priorityQueue.poll();
        recognitions.add(bestRecognition);

        for (int i = 0; i < Math.min(priorityQueue.size(), MAX_RESULTS); ++i) {
            Recognition recognition = priorityQueue.poll();
            boolean overlaps = false;
            for (Recognition previousRecognition : recognitions) {
                overlaps = overlaps || (getIntersectionProportion(previousRecognition.getLocation(),
                        recognition.getLocation()) > OVERLAP_THRESHOLD);
            }

            if (!overlaps) {
                recognitions.add(recognition);
            }
        }
    }

    return recognitions;
}
 

/**
 * java.util.PriorityQueue#PriorityQueue(Collection)
 */
public void test_ConstructorLjava_util_Colleciton_from_priorityqueue() {
    String[] array = { "AAAAA", "AA", "AAAA", "AAAAAAAA" };
    PriorityQueue<String> queue = new PriorityQueue<String>(4,
            new MockComparatorStringByLength());
    for (int i = 0; i < array.length; i++) {
        queue.offer(array[i]);
    }
    Collection<String> c = queue;
    PriorityQueue<String> constructedQueue = new PriorityQueue<String>(c);
    assertEquals(queue.comparator(), constructedQueue.comparator());
    while (queue.size() > 0) {
        assertEquals(queue.poll(), constructedQueue.poll());
    }
    assertEquals(0, constructedQueue.size());
}
 

/**
 * Get the top words under each topic given current Markov status.
 */
private ArrayList<PriorityQueue<Integer>> getTopWordsUnderEachTopicGivenCurrentMarkovStatus() {
	ArrayList<PriorityQueue<Integer>> topWordIDList = new ArrayList<PriorityQueue<Integer>>();
	int top_words = param.numberOfTopWordsUnderPriorTopicsForKnowledgeExtraction;

	for (int t = 0; t < param.T; ++t) {
		Comparator<Integer> comparator = new TopicalWordComparator(phi[t]);
		PriorityQueue<Integer> pqueue = new PriorityQueue<Integer>(
				top_words, comparator);

		for (int w = 0; w < param.V; ++w) {
			if (pqueue.size() < top_words) {
				pqueue.add(w);
			} else {
				if (phi[t][w] > phi[t][pqueue.peek()]) {
					pqueue.poll();
					pqueue.add(w);
				}
			}
		}

		topWordIDList.add(pqueue);
	}
	return topWordIDList;
}
 

private PriorityQueue<IntermediateRecord> convertToIntermediateRecordsPQ(Map<Key, Record> recordsMap, int size,
    Comparator<IntermediateRecord> comparator) {
  PriorityQueue<IntermediateRecord> priorityQueue = new PriorityQueue<>(size, comparator);

  for (Map.Entry<Key, Record> entry : recordsMap.entrySet()) {

    IntermediateRecord intermediateRecord = getIntermediateRecord(entry.getKey(), entry.getValue());
    if (priorityQueue.size() < size) {
      priorityQueue.offer(intermediateRecord);
    } else {
      IntermediateRecord peek = priorityQueue.peek();
      if (comparator.compare(peek, intermediateRecord) < 0) {
        priorityQueue.poll();
        priorityQueue.offer(intermediateRecord);
      }
    }
  }
  return priorityQueue;
}
 

public static void addResultToPriorityQueue(
  PriorityQueue<NodeInfo> topResults,
  NodeInfo nodeInfo,
  int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(nodeInfo);
  } else if (nodeInfo.getWeight() > topResults.peek().getWeight()) {
    topResults.poll();
    topResults.add(nodeInfo);
  }
}
 

public int lastStoneWeight(int[] stones) {
    PriorityQueue<Integer> heap = new PriorityQueue<>(stones.length, Collections.reverseOrder());
    for (int stone : stones) {
        heap.add(stone);
    }

    while (heap.size() > 1) {
        int a = heap.poll(), b = heap.poll();
        if (a != b) {
            heap.add(a - b);
        }
    }
    return heap.size() == 0 ? 0 : heap.poll();
}
 

/**
 *
 * @param vector
 * @param n
 * @return
 * @throws IOException
 */
public List<SpaceResult> findFileSimilar(float[] vector, int n) throws IOException {
    PriorityQueue<SpaceResult> queue = new PriorityQueue<>();
    indexInput.seek(0);
    String header = indexInput.readString(); //skip header
    if ((header.equalsIgnoreCase("-dimensions"))) {
        ObjectVector.vecLength = indexInput.readInt();
    } else if (header.contains("-dimension")) {
        int index = header.indexOf("-dimension");
        ObjectVector.vecLength = Integer.parseInt(header.substring(index + 10).trim());
    }
    while (indexInput.getFilePointer() < indexInput.length()) {
        String key = indexInput.readString();
        float[] v = new float[ObjectVector.vecLength];
        for (int k = 0; k < v.length; k++) {
            v[k] = Float.intBitsToFloat(indexInput.readInt());
        }
        float score = VectorUtils.scalarProduct(vector, v);
        if (queue.size() < n) {
            queue.offer(new SpaceResult(key, score));
        } else {
            queue.poll();
            queue.offer(new SpaceResult(key, score));
        }

    }
    queue.poll();
    List<SpaceResult> list = new ArrayList<>(queue);
    Collections.sort(list);
    return list;
}
 

/**
 * Helper method to add a value to a {@link PriorityQueue}.
 *
 * @param value value to be added.
 * @param queue priority queue.
 * @param maxNumValues maximum number of values in the priority queue.
 * @param <T> type for the value.
 */
public static <T> void addToPriorityQueue(T value, PriorityQueue<T> queue, int maxNumValues) {
  if (queue.size() < maxNumValues) {
    queue.add(value);
  } else if (queue.comparator().compare(queue.peek(), value) < 0) {
    queue.poll();
    queue.offer(value);
  }
}
 

/**
 * Add a neighborInfo to the priority queue when the queue is not full
 * or the score of this neighborInfo is larger then the smallest score in the queue.
 *
 * @param topResults                the priority queue
 * @param neighborInfo              the neighborInfo to be added
 * @param maxNumResults             the maximum capacity of the queue
 */
private void addResultToPriorityQueue(
    PriorityQueue<NeighborInfo> topResults,
    NeighborInfo neighborInfo,
    int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(neighborInfo);
  } else if (neighborInfo.getScore() > topResults.peek().getScore()) {
    topResults.poll();
    topResults.add(neighborInfo);
  }
}
 

public QueryTree (ParseTree T){
	results = new ArrayList<ParseTree>();
	PriorityQueue<ParseTree> Q = new PriorityQueue<ParseTree>();
	Q.add(T);
	HashMap<Integer, ParseTree> H = new HashMap<Integer, ParseTree>();
	H.put(hashing(T), T);
	T.setEdit(0);
	
	while (Q.size() > 0){
		ParseTree oriTree = Q.poll();
		List<ParseTree> treeList = adjuster(oriTree);
		double treeScore = evaluate(oriTree);
		
		for (int i = 0; i < treeList.size(); i++){
			ParseTree currentTree = treeList.get(i);
			int hashValue = hashing(currentTree);
			if (oriTree.getEdit()<10 && !H.containsKey(hashValue)){
				H.put(hashValue, currentTree);
				currentTree.setEdit(oriTree.getEdit()+1);
				if (evaluate(currentTree) >= treeScore){
					Q.add(currentTree);
					results.add(currentTree);
				}
			}
		}
	}
}
 

private static void run(final AsyncServer server, final SelectorWrapper selector, final PriorityQueue<Scheduled> queue) {
//        Log.i(LOGTAG, "****AsyncServer is starting.****");
        // at this point, this local queue and selector are owned
        // by this thread.
        // if a stop is called, the instance queue and selector
        // will be replaced and nulled respectively.
        // this will allow the old queue and selector to shut down
        // gracefully, while also allowing a new selector thread
        // to start up while the old one is still shutting down.
        while(true) {
            try {
                runLoop(server, selector, queue);
            }
            catch (AsyncSelectorException e) {
                if (!(e.getCause() instanceof ClosedSelectorException))
                    Log.i(LOGTAG, "Selector exception, shutting down", e);
                StreamUtility.closeQuietly(selector);
            }
            // see if we keep looping, this must be in a synchronized block since the queue is accessed.
            synchronized (server) {
                if (selector.isOpen() && (selector.keys().size() > 0 || queue.size() > 0))
                    continue;

                shutdownEverything(selector);
                if (server.mSelector == selector) {
                    server.mQueue = new PriorityQueue<Scheduled>(1, Scheduler.INSTANCE);
                    server.mSelector = null;
                    server.mAffinity = null;
                }
                break;
            }
        }
//        Log.i(LOGTAG, "****AsyncServer has shut down.****");
    }
 

private static void run(final SocketServer server, final SelectorWrapper selector, final PriorityQueue<Scheduled> queue) {
    log("****SocketServer is starting.****");
    // at this point, this local queue and selector are owned by this thread.
    // if a stop is called, the instance queue and selector
    // will be replaced and nulled respectively.
    // this will allow the old queue and selector to shut down
    // gracefully, while also allowing a new selector thread
    // to start up while the old one is still shutting down.
    while (true) {
        try {
            runLoop(server, selector, queue);
        } catch (AsyncSelectorException e) {
            log("Selector exception, shutting down", e);
            try {
                // Util.closeQuiety is throwing ArrayStoreException?
                selector.getSelector().close();
            } catch (Exception ignore) {
            }
        }
        // see if we keep looping, this must be in a synchronized block since the queue is accessed.
        synchronized (server) {
            if (selector.isOpen() && (selector.keys().size() > 0 || queue.size() > 0))
                continue;

            shutdownEverything(selector);
            if (server.mSelector == selector) {
                server.mQueue = new PriorityQueue<Scheduled>(1, Scheduler.INSTANCE);
                server.mSelector = null;
                server.serverThread = null;
            }
            break;
        }
    }
    synchronized (servers) {
        servers.remove(Thread.currentThread());
    }
    log("****SocketServer has shut down.****");
}
 

private void testCustomAggregation(Double[] values, int n)
{
    PriorityQueue<Double> heap = new PriorityQueue<>(n, (x, y) -> -Double.compare(x, y));
    Arrays.stream(values).filter(x -> x != null).forEach(heap::add);
    Double[] expected = new Double[heap.size()];
    for (int i = heap.size() - 1; i >= 0; i--) {
        expected[i] = heap.remove();
    }
    testAggregation(Arrays.asList(expected), createDoublesBlock(values), createLongRepeatBlock(n, values.length));
}
 

public int findKthLargest(int[] nums, int k) {
    int len = nums.length;
    // 最小堆
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(k + 1, (a, b) -> (a - b));
    for (int num : nums) {
        priorityQueue.add(num);
        if (priorityQueue.size() == k + 1) {
            priorityQueue.poll();
        }
    }
    return priorityQueue.peek();
}
 

private void addResultToPriorityQueue(
    PriorityQueue<NodeInfo> topResults,
    NodeInfo nodeInfo,
    int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(nodeInfo);
  } else if (nodeInfo.getWeight() > topResults.peek().getWeight()) {
    topResults.poll();
    topResults.add(nodeInfo);
  }
}
 

public static void main(String[] args) throws Exception
{
      System.out.println("BRouter 1.6.1 / 01032020");
      if ( args.length != 5 && args.length != 6)
      {
        System.out.println("serve BRouter protocol");
        System.out.println("usage: java RouteServer <segmentdir> <profiledir> <customprofiledir> <port> <maxthreads> [bindaddress]");
        return;
      }

      ServiceContext serviceContext = new ServiceContext();
      serviceContext.segmentDir = args[0];
      serviceContext.profileDir = args[1];
      System.setProperty( "profileBaseDir", serviceContext.profileDir );
      String dirs = args[2];
      StringTokenizer tk = new StringTokenizer( dirs, "," );
      serviceContext.customProfileDir = tk.nextToken();
      serviceContext.sharedProfileDir = tk.hasMoreTokens() ? tk.nextToken() : serviceContext.customProfileDir;

      int maxthreads = Integer.parseInt( args[4] );
      
      ProfileCache.setSize( 2*maxthreads );

      PriorityQueue<RouteServer> threadQueue = new PriorityQueue<RouteServer>();

      ServerSocket serverSocket = args.length > 5 ? new ServerSocket(Integer.parseInt(args[3]),100,InetAddress.getByName(args[5])) : new ServerSocket(Integer.parseInt(args[3]));

      // stacksample for performance profiling
      // ( caution: start stacksampler only after successfully creating the server socket
      //   because that thread prevents the process from terminating, so the start-attempt
      //   by the watchdog cron would create zombies )
      File stackLog = new File( "stacks.txt" );
      if ( stackLog.exists() )
      {
        StackSampler stackSampler = new StackSampler( stackLog, 1000 );
        stackSampler.start();
        System.out.println( "*** sampling stacks into stacks.txt *** ");
      }

      for (;;)
      {
        Socket clientSocket = serverSocket.accept();
        RouteServer server = new RouteServer();
        server.serviceContext = serviceContext;
        server.clientSocket = clientSocket;
        server.starttime = System.currentTimeMillis();

        // kill an old thread if thread limit reached

        cleanupThreadQueue( threadQueue );

        if ( debug ) System.out.println( "threadQueue.size()=" + threadQueue.size() );
        if ( threadQueue.size() >= maxthreads )
        {
           synchronized( threadPoolSync )
           {
             // wait up to 2000ms (maybe notified earlier)
             // to prevent killing short-running threads
             long maxage = server.starttime - threadQueue.peek().starttime;
             long maxWaitTime = 2000L-maxage;
             if ( debug ) System.out.println( "maxage=" + maxage + " maxWaitTime=" + maxWaitTime );
             if ( debug )
             {
               for ( RouteServer t : threadQueue )
               {
                 System.out.println( "age=" + (server.starttime - t.starttime) );
               }
             }
             if ( maxWaitTime > 0 )
             {
               threadPoolSync.wait( maxWaitTime );
             }
           }
           cleanupThreadQueue( threadQueue );
           if ( threadQueue.size() >= maxthreads )
           {
             if ( debug ) System.out.println( "stopping oldest thread..." );
             // no way... stop the oldest thread
             threadQueue.poll().stopRouter();
           }
        }

        threadQueue.add( server );

        server.start();
        if ( debug ) System.out.println( "thread started..." );
      }
}
 

/**
 * <p>
 * We assume here that the passed-in inner LinkedHashMaps are already sorted
 * in order of "Best Possible Correction".
 * </p>
 */
public PossibilityIterator(
    Map<Token,LinkedHashMap<String,Integer>> suggestions,
    int maximumRequiredSuggestions, int maxEvaluations, boolean overlap) {
  this.suggestionsMayOverlap = overlap;
  for (Map.Entry<Token,LinkedHashMap<String,Integer>> entry : suggestions
      .entrySet()) {
    Token token = entry.getKey();
    if (entry.getValue().size() == 0) {
      continue;
    }
    List<SpellCheckCorrection> possibleCorrections = new ArrayList<>();
    for (Map.Entry<String,Integer> entry1 : entry.getValue().entrySet()) {
      SpellCheckCorrection correction = new SpellCheckCorrection();
      correction.setOriginal(token);
      correction.setCorrection(entry1.getKey());
      correction.setNumberOfOccurences(entry1.getValue());
      possibleCorrections.add(correction);
    }
    possibilityList.add(possibleCorrections);
  }
  
  int wrapSize = possibilityList.size();
  if (wrapSize == 0) {
    done = true;
  } else {
    correctionIndex = new int[wrapSize];
    for (int i = 0; i < wrapSize; i++) {
      int suggestSize = possibilityList.get(i).size();
      if (suggestSize == 0) {
        done = true;
        break;
      }
      correctionIndex[i] = 0;
    }
  }
  PriorityQueue<RankedSpellPossibility> rankedPossibilities = new PriorityQueue<>(
      11, new RankComparator());
  Set<RankedSpellPossibility> removeDuplicates = null;
  if (suggestionsMayOverlap) {
    removeDuplicates = new HashSet<>();
  }
  long numEvaluations = 0;
  while (numEvaluations < maxEvaluations && internalHasNext()) {
    RankedSpellPossibility rsp = internalNext();
    numEvaluations++;
    if (rankedPossibilities.size() >= maximumRequiredSuggestions
        && rsp.rank >= rankedPossibilities.peek().rank) {
      continue;
    }
    if (!isSuggestionForReal(rsp)) {
      continue;
    }
    if (removeDuplicates == null) {
      rankedPossibilities.offer(rsp);
    } else {
      // Needs to be in token-offset order so that the match-and-replace
      // option for collations can work.
      Collections.sort(rsp.corrections, new StartOffsetComparator());
      if (removeDuplicates.add(rsp)) {
        rankedPossibilities.offer(rsp);
      }
    }
    if (rankedPossibilities.size() > maximumRequiredSuggestions) {
      RankedSpellPossibility removed = rankedPossibilities.poll();
      if (removeDuplicates != null) {
        removeDuplicates.remove(removed);
      }
    }
  }
  
  RankedSpellPossibility[] rpArr = new RankedSpellPossibility[rankedPossibilities
      .size()];
  for (int i = rankedPossibilities.size() - 1; i >= 0; i--) {
    rpArr[i] = rankedPossibilities.remove();
  }
  rankedPossibilityIterator = Arrays.asList(rpArr).iterator();
}
 

/**
 * Provide spelling corrections based on several parameters.
 *
 * @param term The term to suggest spelling corrections for
 * @param numSug The maximum number of spelling corrections
 * @param ir The index reader to fetch the candidate spelling corrections from
 * @param docfreq The minimum document frequency a potential suggestion need to have in order to be included
 * @param editDistance The maximum edit distance candidates are allowed to have
 * @param accuracy The minimum accuracy a suggested spelling correction needs to have in order to be included
 * @param spare a chars scratch
 * @return a collection of spelling corrections sorted by <code>ScoreTerm</code>'s natural order.
 * @throws IOException If I/O related errors occur
 */
protected Collection<ScoreTerm> suggestSimilar(Term term, int numSug, IndexReader ir, int docfreq, int editDistance,
                                               float accuracy, final CharsRefBuilder spare) throws IOException {

  Terms terms = MultiTerms.getTerms(ir, term.field());
  if (terms == null) {
    return Collections.emptyList();
  }
  FuzzyTermsEnum e = new FuzzyTermsEnum(terms, term, editDistance, Math.max(minPrefix, editDistance - 1), true);
  final PriorityQueue<ScoreTerm> stQueue = new PriorityQueue<>();
  
  BytesRef queryTerm = new BytesRef(term.text());
  BytesRef candidateTerm;
  ScoreTerm st = new ScoreTerm();
  while ((candidateTerm = e.next()) != null) {
    // For FuzzyQuery, boost is the score:
    float score = e.getBoost();
    // ignore uncompetitive hits
    if (stQueue.size() >= numSug && score <= stQueue.peek().boost) {
      continue;
    }
    
    // ignore exact match of the same term
    if (queryTerm.bytesEquals(candidateTerm)) {
      continue;
    }
    
    int df = e.docFreq();
    
    // check docFreq if required
    if (df <= docfreq) {
      continue;
    }
    
    final String termAsString;
    if (distance == INTERNAL_LEVENSHTEIN) {
      // delay creating strings until the end
      termAsString = null;
    } else {
      spare.copyUTF8Bytes(candidateTerm);
      termAsString = spare.toString();
      score = distance.getDistance(term.text(), termAsString);
    }
    
    if (score < accuracy) {
      continue;
    }
    
    // add new entry in PQ
    st.term = BytesRef.deepCopyOf(candidateTerm);
    st.boost = score;
    st.docfreq = df;
    st.termAsString = termAsString;
    st.score = score;
    stQueue.offer(st);
    // possibly drop entries from queue
    st = (stQueue.size() > numSug) ? stQueue.poll() : new ScoreTerm();
    e.setMaxNonCompetitiveBoost((stQueue.size() >= numSug) ? stQueue.peek().boost : Float.NEGATIVE_INFINITY);
  }
    
  return stQueue;
}