<p>I know its possible to get the top terms within a Lucene Index, but is there a way to get the top terms based on a subset of a Lucene index?</p>

<p>I.e. What are the top terms in the Index for documents within a certain date range?</p>

Ideally there'd be a utility somewhere to do this, but I'm not aware of one.  However, it's not too hard to do this "by hand" in a reasonably efficient way.  I'll assume that you already have a
```
Query
```
and/or
```
Filter
```
object that you can use to define the subset of interest.
First, build a list in memory of all of the document IDs in your index subset.  You can use
```
IndexSearcher.search(Query, Filter, HitCollector)
```
to do this very quickly; the
```
HitCollector
```
documentation
includes an example that seems like it ought to work, or you can use some other container to store your doc IDs.
Next, initialize an empty HashMap (or whatever) to map terms to total frequency, and populate the map by invoking one of the
```
IndexReader.getTermFreqVector
```
methods for every document and field of interest.  The three-argument form seems simpler, but either should be just fine.  For the three-argument form, you'd make a
```
TermVectorMapper
```
whose
```
map
```
method checks if
```
term
```
is in the map, associates it with
```
frequency
```
if not, or adds
```
frequency
```
to the existing value if so.  Be sure to use the same
```
TermVectorMapper
```
object across all of the calls to
```
getTermFreqVector
```
in this pass, rather than instantiating a new one for each document in the loop.  You can also speed things up quite a bit by overriding
```
isIgnoringPositions()
```
and
```
isIgnoringOffsets()
```
; your object should return
```
true
```
for both of those.  It looks like your
```
TermVectorMapper
```
might also be forced to define a
```
setExpectations
```
method, but that one doesn't need to do anything.
Once you've built your map, just sort the map items by descending frequency and read off however many top terms you like.  If you know in advance how many terms you want, you might prefer to do some kind of fancy heap-based algorithm to find the top
k
items in linear time instead of using an O(
n
log
n
) sort.  I imagine the plain old sort will be plenty fast in practice.  But it's up to you.
If you prefer, you can combine the first two stages by having your
```
HitCollector
```
invoke
```
getTermFreqVector
```
directly.  This should certainly produce equally correct results, and intuitively seems like it would be simpler and better, but the docs seem to warn that doing so is likely to be quite a bit slower than the two-pass approach (on same page as the HitCollector example above).  Or I could be misinterpreting their warning.  If you're feeling ambitious you could try it both ways, compare, and let us know.