Collector decouples the score from the collected doc:
the score computation is skipped entirely if it's not
needed. Collectors that do need the score should
implement the setScorer(org.apache.lucene.search.Scorer) method, to hold onto the
passed Scorer instance, and call Scorer.score() within the collect method to compute the
current hit's score. If your collector may request the
score for a single hit multiple times, you should use
ScoreCachingWrappingScorer.

NOTE: The doc that is passed to the collect
method is relative to the current reader. If your
collector needs to resolve this to the docID space of the
Multi*Reader, you must re-base it by recording the
docBase from the most recent setNextReader call. Here's
a simple example showing how to collect docIDs into a
BitSet:

Not all collectors will need to rebase the docID. For
example, a collector that simply counts the total number
of hits would skip it.

NOTE: Prior to 2.9, Lucene silently filtered
out hits with score <= 0. As of 2.9, the core Collectors
no longer do that. It's very unusual to have such hits
(a negative query boost, or function query returning
negative custom scores, could cause it to happen). If
you need that behavior, use PositiveScoresOnlyCollector.

Since:

2.9

WARNING: This API is experimental and might change in incompatible ways in the next release.

Constructor Detail

Collector

Method Detail

setScorer

Called before successive calls to collect(int). Implementations
that need the score of the current document (passed-in to
collect(int)), should save the passed-in Scorer and call
scorer.score() when needed.

Note: This is called in an inner search loop. For good search performance,
implementations of this method should not call IndexSearcher.doc(int) or
IndexReader.document(int) on every hit.
Doing so can slow searches by an order of magnitude or more.

acceptsDocsOutOfOrder

public abstract boolean acceptsDocsOutOfOrder()

Return true if this collector does not
require the matching docIDs to be delivered in int sort
order (smallest to largest) to collect(int).

Most Lucene Query implementations will visit
matching docIDs in order. However, some queries
(currently limited to certain cases of BooleanQuery) can achieve faster searching if the
Collector allows them to deliver the
docIDs out of order.

Many collectors don't mind getting docIDs out of
order, so it's important to return true
here.