Java PriorityQueue类代码示例

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
private void updateTop(CandidateSet[] candidates, Candidate[] path, PriorityQueue<Correction> corrections, double cutoffScore, double score)
        throws IOException {
    score = Math.exp(score);
    assert Math.abs(score - score(path, candidates)) < 0.00001;
    if (score > cutoffScore) {
        if (corrections.size() < maxNumCorrections) {
            Candidate[] c = new Candidate[candidates.length];
            System.arraycopy(path, 0, c, 0, path.length);
            corrections.add(new Correction(score, c));
        } else if (corrections.top().compareTo(score, path) < 0) {
            Correction top = corrections.top();
            System.arraycopy(path, 0, top.candidates, 0, path.length);
            top.score = score;
            corrections.updateTop();
        }
    }
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Add to an existing boolean query the More Like This query from this PriorityQueue
 */
private void addToQuery(PriorityQueue<ScoreTerm> q, BooleanQuery query) {
    ScoreTerm scoreTerm;
    float bestScore = -1;

    while ((scoreTerm = q.pop()) != null) {
        TermQuery tq = new TermQuery(new Term(scoreTerm.topField, scoreTerm.word));

        if (boost) {
            if (bestScore == -1) {
                bestScore = (scoreTerm.score);
            }
            float myScore = (scoreTerm.score);
            tq.setBoost(boostFactor * myScore / bestScore);
        }

        try {
            query.add(tq, BooleanClause.Occur.SHOULD);
        }
        catch (BooleanQuery.TooManyClauses ignore) {
            break;
        }
    }
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Find words for a more-like-this query former.
 *
 * @param docNum
 *          the id of the lucene document from which to find terms
 */
private PriorityQueue<ScoreTerm> retrieveTerms(int docNum) throws IOException
{
  Map<String, Int> termFreqMap = new HashMap<>();
  for (String fieldName : fieldNames) {
    final Terms vector = ir.getTermVector(docNum, fieldName);
    // field does not store term vector info
    if (vector == null) {
      Document d = ir.document(docNum);
      IndexableField[] fields = d.getFields(fieldName);
      for (IndexableField field : fields) {
        final String stringValue = field.stringValue();
        if (stringValue != null) {
          addTermFrequencies(new StringReader(stringValue), termFreqMap, fieldName);
        }
      }
    }
    else {
      addTermFrequencies(termFreqMap, vector);
    }
  }

  return createQueue(termFreqMap);
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Create the More like query from a PriorityQueue
 */
private Query createQuery(PriorityQueue<ScoreTerm> q) {
  BooleanQuery query = new BooleanQuery();
  ScoreTerm scoreTerm;
  float bestScore = -1;

  while ((scoreTerm = q.pop()) != null) {
    TermQuery tq = new TermQuery(new Term(scoreTerm.topField, scoreTerm.word));

    if (boost) {
      if (bestScore == -1) {
        bestScore = (scoreTerm.score);
      }
      float myScore = (scoreTerm.score);
      tq.setBoost(boostFactor * myScore / bestScore);
    }

    try {
      query.add(tq, BooleanClause.Occur.SHOULD);
    }
    catch (BooleanQuery.TooManyClauses ignore) {
      break;
    }
  }
  return query;
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
@Override
protected final int addSiblings(int ordinal, int[] siblings, PriorityQueue<FacetResultNode> pq) {
  FacetResultNode top = pq.top();
  int numResults = 0;
  while (ordinal != TaxonomyReader.INVALID_ORDINAL) {
    int value = values[ordinal];
    if (value > top.value) {
      top.value = value;
      top.ordinal = ordinal;
      top = pq.updateTop();
      ++numResults;
    }
    ordinal = siblings[ordinal];
  }
  return numResults;
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
@Override
protected final int addSiblings(int ordinal, int[] siblings, PriorityQueue<FacetResultNode> pq) {
  FacetResultNode top = pq.top();
  int numResults = 0;
  while (ordinal != TaxonomyReader.INVALID_ORDINAL) {
    float value = values[ordinal];
    if (value > top.value) {
      top.value = value;
      top.ordinal = ordinal;
      top = pq.updateTop();
      ++numResults;
    }
    ordinal = siblings[ordinal];
  }
  return numResults;
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/** Construct the array of doc hits for the hit group. */
private void buildDocHits(int group, ResultGroup resultGroup) 
{
  PriorityQueue queue = hitQueue[group];
  int nFound = queue.size();
  DocHitImpl[] hitArray = new DocHitImpl[nFound];
  for (int i = 0; i < nFound; i++) {
    int index = nFound - i - 1;
    hitArray[index] = (DocHitImpl)queue.pop();
  }

  int start = startDoc[group];
  int max = maxDocs[group];

  int nHits = Math.max(0, Math.min(nFound - start, max));
  resultGroup.docHits = new DocHit[nHits];

  resultGroup.totalDocs = nDocHits(group);
  resultGroup.startDoc = start;
  resultGroup.endDoc = start + nHits;

  for (int i = startDoc[group]; i < nFound; i++)
    resultGroup.docHits[i - start] = hitArray[i];
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Create a PriorityQueue from a word->tf map.
 *
 * @param words a map of words keyed on the word(String) with Int objects as the values.
 */
private PriorityQueue createQueue(IndexReader indexReader, Map words)
  throws IOException 
{
  // Will order words by score
  int queueSize = Math.min(words.size(), maxQueryTerms);
  QueryWordQueue queue = new QueryWordQueue(queueSize);

  // For each term...
  Iterator it = words.keySet().iterator();
  while (it.hasNext()) 
  {
    String word = (String)it.next();
    float score = ((Flt)words.get(word)).x;

    // Okay, add an entry to the queue.
    queue.insert(new QueryWord(word, score));
  }

  return queue;
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
public final boolean insertInto(PriorityQueue queue) 
{
  if (docHit == null)
    docHit = new DocHitImpl(doc, score);

  try 
  {
    docHit.setSpanSource(spanSrc);
    boolean inserted = queue.insert(docHit);
    
    // If we're keeping this hit, make sure spans have been grabbed. 
    if (inserted)
      docHit.totalSnippets();
    
    return inserted;
  }
  finally {
    docHit.setSpanSource(null); // prevent memory leaks
  }

}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
public void findCandidates(CandidateSet[] candidates, Candidate[] path, int ord, int numMissspellingsLeft,
        PriorityQueue<Correction> corrections, double cutoffScore, final double pathScore) throws IOException {
    CandidateSet current = candidates[ord];
    if (ord == candidates.length - 1) {
        path[ord] = current.originalTerm;
        updateTop(candidates, path, corrections, cutoffScore, pathScore + scorer.score(path, candidates, ord, gramSize));
        if (numMissspellingsLeft > 0) {
            for (int i = 0; i < current.candidates.length; i++) {
                path[ord] = current.candidates[i];
                updateTop(candidates, path, corrections, cutoffScore, pathScore + scorer.score(path, candidates, ord, gramSize));
            }
        }
    } else {
        if (numMissspellingsLeft > 0) {
            path[ord] = current.originalTerm;
            findCandidates(candidates, path, ord + 1, numMissspellingsLeft, corrections, cutoffScore, pathScore + scorer.score(path, candidates, ord, gramSize));
            for (int i = 0; i < current.candidates.length; i++) {
                path[ord] = current.candidates[i];
                findCandidates(candidates, path, ord + 1, numMissspellingsLeft - 1, corrections, cutoffScore, pathScore + scorer.score(path, candidates, ord, gramSize));
            }
        } else {
            path[ord] = current.originalTerm;
            findCandidates(candidates, path, ord + 1, 0, corrections, cutoffScore, pathScore + scorer.score(path, candidates, ord, gramSize));
        }
    }

}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Find words for a more-like-this query former.
 *
 * @param docNum the id of the lucene document from which to find terms
 */
private PriorityQueue<ScoreTerm> retrieveTerms(int docNum) throws IOException {
    Map<String, Int> termFreqMap = new HashMap<>();
    for (String fieldName : fieldNames) {
        final Fields vectors = ir.getTermVectors(docNum);
        final Terms vector;
        if (vectors != null) {
            vector = vectors.terms(fieldName);
        } else {
            vector = null;
        }

        // field does not store term vector info
        if (vector == null) {
            Document d = ir.document(docNum);
            IndexableField fields[] = d.getFields(fieldName);
            for (IndexableField field : fields) {
                final String stringValue = field.stringValue();
                if (stringValue != null) {
                    addTermFrequencies(new FastStringReader(stringValue), termFreqMap, fieldName);
                }
            }
        } else {
            addTermFrequencies(termFreqMap, vector, fieldName);
        }
    }

    return createQueue(termFreqMap);
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * @see #retrieveInterestingTerms(java.io.Reader, String)
 */
public String[] retrieveInterestingTerms(int docNum) throws IOException {
    ArrayList<Object> al = new ArrayList<>(maxQueryTerms);
    PriorityQueue<ScoreTerm> pq = retrieveTerms(docNum);
    ScoreTerm scoreTerm;
    int lim = maxQueryTerms; // have to be careful, retrieveTerms returns all words but that's probably not useful to our caller...
    // we just want to return the top words
    while (((scoreTerm = pq.pop()) != null) && lim-- > 0) {
        al.add(scoreTerm.word); // the 1st entry is the interesting word
    }
    String[] res = new String[al.size()];
    return al.toArray(res);
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
private RFQuery buildQueryFromFieldTermFrequencies(Map<String, Map<String, Flt>> fieldTermFreq, boolean contentStreamQuery) throws IOException {

        List<RFTerm> interestingTerms = new ArrayList<RFTerm>();
        for(String fieldName: fieldTermFreq.keySet()){
            Map<String,Flt> words = fieldTermFreq.get(fieldName);
            PriorityQueue<RFTerm> queue = createQueue(fieldName, words, contentStreamQuery);
            interestingTerms.addAll(getMostInterestingTerms(queue));
        }

        RFQuery rfResult = new RFQuery(interestingTerms, getMm());
        return rfResult;
    }
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * Compute the top most interesting terms from the priority queue of all RF Terms
 */
private List<RFTerm> getMostInterestingTerms(PriorityQueue<RFTerm> q) {

    int maxTerms = (maxQueryTermsPerField <= 0) ? Integer.MAX_VALUE : maxQueryTermsPerField;
    double sumQuaredBoost = 0.0f;

    List<RFTerm> interestingTerms = new ArrayList<RFTerm>();
    RFTerm currentTerm = null;
    while ((currentTerm = q.pop()) != null
            && interestingTerms.size() < maxTerms) {
        // if not boost, then set score to 1.0 not tf.idf
        // now implemented inside RFTerm

        // if not boost, boostValue == 1.0, so this just adds 1 as desired
        sumQuaredBoost += Math.pow(currentTerm.getTermWeight(),2);
        interestingTerms.add(currentTerm);
    }

    float vectorLength = (float) Math.sqrt(sumQuaredBoost);
    if(vectorLength <= 0.0){
        return new ArrayList<RFTerm>();
    }

    if(this.isNormalizeFieldBoosts()){
        for(RFTerm term: interestingTerms){
            term.setVectorLength(vectorLength);
        }
    }
    return interestingTerms;
}
 

import org.apache.lucene.util.PriorityQueue; //导入依赖的package包/类
/**
 * @see #retrieveInterestingTerms(java.io.Reader, String)
 */
public String[] retrieveInterestingTerms(int docNum) throws IOException
{
  ArrayList<Object> al = new ArrayList<>(maxQueryTerms);
  PriorityQueue<ScoreTerm> pq = retrieveTerms(docNum);
  ScoreTerm scoreTerm;
  int lim = maxQueryTerms; // have to be careful, retrieveTerms returns all words but that's probably not
                           // useful to our caller...
  // we just want to return the top words
  while (((scoreTerm = pq.pop()) != null) && lim-- > 0) {
    al.add(scoreTerm.word); // the 1st entry is the interesting word
  }
  String[] res = new String[al.size()];
  return al.toArray(res);
}