Class Index



AbstractAllTermDocs Base class for enumerating all but deleted docs. 
AlreadyClosedException This exception is thrown when there is an attempt to access something that has already been closed. 
Analyzer An Analyzer builds TokenStreams, which analyze text. 
ArrayUtil Methods for manipulating arrays. 
ASCIIFoldingFilter This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if one exists. 
Attribute Base interface for attributes. 
AttributeImpl Base class for Attributes that can be added to a AttributeSource
AttributeSource An AttributeSource contains a list of different AttributeImpls, and methods to add and get them. 
AttributeSource.AttributeFactory An AttributeFactory creates instances of AttributeImpls. 
AttributeSource.State This class holds the state of an AttributeSource. 
AverageGuessMemoryModel An average, best guess, MemoryModel that should work okay on most systems. 
AveragePayloadFunction Calculate the final score as the average score of all payloads seen. 


BaseCharFilter Base utility class for implementing a CharFilter
BitUtil A variety of high efficiency bit twiddling routines. 
BitVector Optimized implementation of a vector of bits. 
BooleanClause A clause in a BooleanQuery. 
BooleanClause.Occur Specifies how clauses are to occur in matching documents. 
BooleanQuery A Query that matches documents matching boolean combinations of other queries, e.g. 
BooleanQuery.BooleanWeight Expert: the Weight for BooleanQuery, used to normalize, score and explain these queries. 
BooleanQuery.TooManyClauses Thrown when an attempt is made to add more than getMaxClauseCount() clauses. 
BufferedIndexInput Base implementation class for buffered IndexInput
BufferedIndexOutput Base implementation class for buffered IndexOutput
ByteFieldSource Expert: obtains single byte field values from the FieldCache using getBytes() and makes those values available as other numeric types, casting as needed. 


Cache<K, V> Base class for cache implementations. 
CachingSpanFilter Wraps another SpanFilter's result and caches it. 
CachingTokenFilter This class can be used if the token attributes of a TokenStream are intended to be consumed more than once. 
CachingWrapperFilter Wraps another filter's result and caches it. 
CachingWrapperFilter.DeletesMode Expert: Specifies how new deletions against a reopened reader should be handled. 
CharArraySet A simple class that stores Strings as char[]'s in a hash table. 
CharArraySet.CharArraySetIterator The Iterator for this set. 
CharFilter Subclasses of CharFilter can be chained to filter CharStream. 
CharReader CharReader is a Reader wrapper. 
CharStream CharStream adds correctOffset(int) functionality over Reader. 
CharStream This interface describes a character stream that maintains line and column number positions of the characters. 
CharTokenizer An abstract base class for simple, character-oriented tokenizers. 
CheckIndex Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments. 
CheckIndex.Status Returned from checkIndex() detailing the health and status of the index. 
CheckIndex.Status.FieldNormStatus Status from testing field norms. 
CheckIndex.Status.SegmentInfoStatus Holds the status of each segment in the index. 
CheckIndex.Status.StoredFieldStatus Status from testing stored fields. 
CheckIndex.Status.TermIndexStatus Status from testing term index. 
CheckIndex.Status.TermVectorStatus Status from testing stored fields. 
ChecksumIndexInput Writes bytes through to a primary IndexOutput, computing checksum as it goes. 
ChecksumIndexOutput Writes bytes through to a primary IndexOutput, computing checksum. 
CloseableThreadLocal<T> Java's builtin ThreadLocal has a serious flaw: it can take an arbitrarily long amount of time to dereference the things you had stored in it, even once the ThreadLocal instance itself is no longer referenced. 

Expert: Collectors are primarily meant to be used to gather raw results from a search, and implement sorting or custom result filtering, collation, etc. 

ComplexExplanation Expert: Describes the score computation for document and query, and can distinguish a match independent of a positive value. 
CompressionTools Simple utility class providing static methods to compress and decompress binary data for stored fields. 
ConcurrentMergeScheduler A MergeScheduler that runs each merge using a separate thread, up until a maximum number of threads (setMaxThreadCount(int)) at which when a merge is needed, the thread(s) that are updating the index will pause until one or more merges completes. 
Constants Some useful constants. 
ConstantScoreQuery A query that wraps a filter and simply returns a constant score equal to the query boost for every document in the filter. 
CorruptIndexException This exception is thrown when Lucene detects an inconsistency in the index. 
CustomScoreProvider An instance of this subclass should be returned by getCustomScoreProvider(IndexReader), if you want to modify the custom score calculation of a CustomScoreQuery
CustomScoreQuery Query that sets document score as a programmatic function of several (sub) scores:
  1. the score of its subQuery (any query)
  2. (optional) the score of its ValueSourceQuery (or queries). 


DateField This class is deprecated. If you build a new index, use DateTools or NumericField instead. This class is included for use with existing indices and will be removed in a future release (possibly Lucene 4.0).  
DateTools Provides support for converting dates to strings and vice-versa. 
DateTools.Resolution Specifies the time granularity. 
DefaultSimilarity Expert: Default scoring implementation. 
Directory A Directory is a flat list of files. 
DisjunctionMaxQuery A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. 
DisjunctionMaxQuery.DisjunctionMaxWeight Expert: the Weight for DisjunctionMaxQuery, used to normalize, score and explain these queries. 
DocIdBitSet Simple DocIdSet and DocIdSetIterator backed by a BitSet  
DocIdSet A DocIdSet contains a set of doc ids. 
DocIdSetIterator This abstract class defines methods to iterate over a set of non-decreasing doc ids. 
Document Documents are the unit of indexing and search. 
DocValues Expert: represents field values as different types. 
DummyConcurrentLock A dummy lock as a replacement for ReentrantLock to disable locking  


Explanation Expert: Describes the score computation for document and query. 
Explanation.IDFExplanation Small Util class used to pass both an idf factor as well as an explanation for that factor. 


FastCharStream An efficient implementation of JavaCC's CharStream interface. 
Field A field is a section of a Document. 
Field.Index Specifies whether and how a field should be indexed. 
Field.Store Specifies whether and how a field should be stored. 
Field.TermVector Specifies whether and how a field should have term vectors. 
Fieldable Synonymous with Field
FieldCache Expert: Maintains caches of term values. 
FieldCache.ByteParser Interface to parse bytes from document fields. 
FieldCache.CacheEntry EXPERT: A unique Identifier/Description for each item in the FieldCache. 
FieldCache.DoubleParser Interface to parse doubles from document fields. 
FieldCache.FloatParser Interface to parse floats from document fields. 
FieldCache.IntParser Interface to parse ints from document fields. 
FieldCache.LongParser Interface to parse long from document fields. 
FieldCache.Parser Marker interface as super-interface to all parsers. 
FieldCache.ShortParser Interface to parse shorts from document fields. 
FieldCache.StringIndex Expert: Stores term text values and document ordering data. 
FieldCacheRangeFilter<T> A range filter built on top of a cached single term field (in FieldCache). 
FieldCacheSanityChecker Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent. 
FieldCacheSanityChecker.Insanity Simple container for a collection of related CacheEntry objects that in conjunction with each other represent some "insane" usage of the FieldCache. 
FieldCacheSanityChecker.InsanityType An Enumeration of the different types of "insane" behavior that may be detected in a FieldCache. 
FieldCacheSource Expert: A base class for ValueSource implementations that retrieve values for a single field from the FieldCache
FieldCacheTermsFilter A Filter that only accepts documents whose single term value in the specified field is contained in the provided set of allowed terms. 
FieldComparator Expert: a FieldComparator compares hits so as to determine their sort order when collecting the top results with TopFieldCollector
FieldComparator.ByteComparator Parses field's values as byte (using getBytes(IndexReader, String) and sorts by ascending value  
FieldComparator.DocComparator Sorts by ascending docID  
FieldComparator.DoubleComparator Parses field's values as double (using getDoubles(IndexReader, String) and sorts by ascending value  
FieldComparator.FloatComparator Parses field's values as float (using getFloats(IndexReader, String) and sorts by ascending value  
FieldComparator.IntComparator Parses field's values as int (using getInts(IndexReader, String) and sorts by ascending value  
FieldComparator.LongComparator Parses field's values as long (using getLongs(IndexReader, String) and sorts by ascending value  
FieldComparator.RelevanceComparator Sorts by descending relevance. 
FieldComparator.ShortComparator Parses field's values as short (using getShorts(IndexReader, String) and sorts by ascending value  
FieldComparator.StringComparatorLocale Sorts by a field's value using the Collator for a given Locale. 
FieldComparator.StringOrdValComparator Sorts by field's natural String sort order, using ordinals. 
FieldComparator.StringValComparator Sorts by field's natural String sort order. 
FieldComparatorSource Provides a FieldComparator for custom field sorting. 
FieldDoc Expert: A ScoreDoc which also contains information about how to sort the referenced document. 
FieldInvertState This class tracks the number and position / offset parameters of terms being added to the index. 

Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about their search field. 

FieldScoreQuery A query that scores each document as the value of the numeric input field. 
FieldScoreQuery.Type Type of score field, indicating how field values are interpreted/parsed. 
FieldSelector Similar to a, the FieldSelector allows one to make decisions about what Fields get loaded on a Document by document(int, org.apache.lucene.document.FieldSelector)  
FieldSelectorResult Provides information about what should be done with this Field  
FieldSortedTermVectorMapper For each Field, store a sorted collection of TermVectorEntrys

This is not thread-safe. 

FieldValueHitQueue Expert: A hit queue for sorting by hits by terms in more than one field. 
FileSwitchDirectory Expert: A Directory instance that switches files between two other Directory instances. 
Filter Abstract base class for restricting which documents may be returned during searching. 
FilteredDocIdSet Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation mechanism on a given DocIdSet. 
FilteredDocIdSetIterator Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validation mechanism on an underlying DocIdSetIterator. 
FilteredQuery A query that applies a filter to the results of another query. 
FilteredTermEnum Abstract class for enumerating a subset of all terms. 
FilterIndexReader A FilterIndexReader contains another IndexReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality. 
FilterIndexReader.FilterTermDocs Base class for filtering TermDocs implementations. 
FilterIndexReader.FilterTermEnum Base class for filtering TermEnum implementations. 
FilterIndexReader.FilterTermPositions Base class for filtering TermPositions implementations. 
FilterManager Filter caching singleton. 
FilterManager.FilterCleaner Keeps the cache from getting too big. 
FilterManager.FilterItem Holds the filter and the last time the filter was used, to make LRU-based cache cleaning possible. 
FlagsAttribute This attribute can be used to pass different flags down the Tokenizer chain, eg from one TokenFilter to another one. 
FlagsAttributeImpl This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter to another one. 
FloatFieldSource Expert: obtains float field values from the FieldCache using getFloats() and makes those values available as other numeric types, casting as needed. 
FSDirectory Base class for Directory implementations that store index files in the file system. 
FSLockFactory Base class for file system based locking implementation. 
FuzzyQuery Implements the fuzzy search query. 
FuzzyTermEnum Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term. 


IndexableBinaryStringTools Provides support for converting byte sequences to Strings and back again. 

Expert: represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader


Expert: policy for deletion of stale index commits

IndexFileNameFilter Filename filter that accept filenames and extensions only created by Lucene. 
IndexInput Abstract base class for input from a file in a Directory
IndexOutput Abstract base class for output to a file in a Directory. 
IndexReader IndexReader is an abstract class, providing an interface for accessing an index. 
IndexReader.FieldOption Constants describing field properties, for example used for getFieldNames(FieldOption)
IndexSearcher Implements search over a single IndexReader. 
IndexWriter An IndexWriter creates and maintains an index. 
IndexWriter.IndexReaderWarmer If getReader() has been called (ie, this writer is in near real-time mode), then after a merge completes, this class can be invoked to warm the reader on the newly merged segment, before the merge commits. 
IndexWriter.MaxFieldLength Specifies maximum field length (in number of tokens/terms) in IndexWriter constructors. 
IntFieldSource Expert: obtains int field values from the FieldCache using getInts() and makes those values available as other numeric types, casting as needed. 
ISOLatin1AccentFilter This class is deprecated. If you build a new index, use ASCIIFoldingFilter which covers a superset of Latin 1. This class is included for use with existing indexes and will be removed in a future release (possibly Lucene 4.0).  


KeepOnlyLastCommitDeletionPolicy This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done. 
KeywordAnalyzer "Tokenizes" the entire stream as a single token. 
KeywordTokenizer Emits the entire input as a single token. 


LengthFilter Removes words that are too long or too short from the stream. 
LetterTokenizer A LetterTokenizer is a tokenizer that divides text at non-letters. 
LoadFirstFieldSelector Load the First field and break. 
Lock An interprocess mutex lock. 
Lock.With Utility class for executing code with exclusive access. 

Base class for Locking implementation. 

LockObtainFailedException This exception is thrown when the write.lock could not be acquired. 
LockReleaseFailedException This exception is thrown when the write.lock could not be released. 
LockStressTest Simple standalone tool that forever acquires & releases a lock using a specific LockFactory. 
LockVerifyServer Simple standalone server that must be running when you use VerifyingLockFactory
LogByteSizeMergePolicy This is a LogMergePolicy that measures size of a segment as the total byte size of the segment's files. 
LogDocMergePolicy This is a LogMergePolicy that measures size of a segment as the number of documents (not taking deletions into account). 

This class implements a MergePolicy that tries to merge segments into levels of exponentially increasing size, where each level has fewer segments than the value of the merge factor. 

LowerCaseFilter Normalizes token text to lower case. 
LowerCaseTokenizer LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. 
LucenePackage Lucene's package information, including version. 


MapFieldSelector A FieldSelector based on a Map of field names to FieldSelectorResults  
MapOfSets<K, V> Helper class for keeping Lists of Objects associated with keys. 
MappingCharFilter Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stream, and correcting the resulting changes to the offsets. 
MatchAllDocsQuery A query that matches all documents. 
MaxPayloadFunction Returns the maximum payload score seen, else 1 if there are no payloads on the doc. 
MemoryModel Returns primitive memory sizes for estimating RAM usage. 

Expert: a MergePolicy determines the sequence of primitive merge operations to be used for overall merge and optimize operations. 

MergePolicy.MergeException Exception thrown if there are any problems while executing a merge. 
MergePolicy.MergeSpecification A MergeSpecification instance provides the information necessary to perform multiple merges. 
MergePolicy.OneMerge OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment. 

Expert: IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePolicy

Message Message Interface for a lazy loading. 
MessageImpl Default implementation of Message interface. 
MinPayloadFunction Calculates the minimum payload seen  
MMapDirectory File-based Directory implementation that uses mmap for reading, and SimpleFSDirectory.SimpleFSIndexOutput for writing. 
MultiFieldQueryParser A QueryParser which constructs queries to search multiple fields. 
MultiPhraseQuery MultiPhraseQuery is a generalized version of PhraseQuery, with an added method add(Term[])
MultipleTermPositions Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions
MultiReader An IndexReader which reads multiple indexes, appending their content. 
MultiSearcher Implements search over a set of Searchables
MultiTermQuery An abstract Query that matches documents containing a subset of terms provided by a FilteredTermEnum enumeration. 
MultiTermQuery.ConstantScoreAutoRewrite A rewrite method that tries to pick the best constant-score rewrite method based on term and document counts from the query. 
MultiTermQuery.RewriteMethod Abstract class that defines how the query is rewritten. 
MultiTermQueryWrapperFilter<Q extends MultiTermQuery> A wrapper for MultiTermQuery, that exposes its functionality as a Filter


NamedThreadFactory A default ThreadFactory implementation that accepts the name prefix of the created threads as a constructor argument. 

Implements LockFactory using native OS file locks. 

NearSpansOrdered A Spans that is formed from the ordered subspans of a SpanNearQuery where the subspans do not overlap and have a maximum slop between them. 
NearSpansUnordered Similar to NearSpansOrdered, but for the unordered case. 
NIOFSDirectory An FSDirectory implementation that uses java.nio's FileChannel's positional read, which allows multiple threads to read from the same file without synchronizing. 
NLS MessageBundles classes extend this class, to implement a bundle. 
NLSException Interface that exceptions should implement to support lazy loading of messages. 
NoLockFactory Use this LockFactory to disable locking entirely. 
NormalizeCharMap Holds a map of String input to String output, to be used with MappingCharFilter
NoSuchDirectoryException This exception is thrown when you try to list a non-existent directory. 
NumberTools This class is deprecated. For new indexes use NumericUtils instead, which provides a sortable binary representation (prefix encoded) of numeric values. To index and efficiently query numeric values use NumericField and NumericRangeQuery. This class is included for use with existing indices and will be removed in a future release (possibly Lucene 4.0).  

This class provides a Field that enables indexing of numeric values for efficient range filtering and sorting. 

NumericRangeFilter<T extends Number> A Filter that only accepts numeric values within a specified range. 
NumericRangeQuery<T extends Number>

A Query that matches numeric values within a specified range. 

NumericTokenStream Expert: This class provides a TokenStream for indexing numeric values that can be used by NumericRangeQuery or NumericRangeFilter
NumericUtils This is a helper class to generate prefix-encoded representations for numerical values and supplies converters to represent float/double values as sortable integers/longs. 
NumericUtils.IntRangeBuilder Expert: Callback for splitIntRange(NumericUtils.IntRangeBuilder, int, int, int)
NumericUtils.LongRangeBuilder Expert: Callback for splitLongRange(NumericUtils.LongRangeBuilder, int, long, long)


OffsetAttribute The start and end character offset of a Token. 
OffsetAttributeImpl The start and end character offset of a Token. 
OpenBitSet An "open" BitSet implementation that allows direct access to the array of words storing the bits. 
OpenBitSetIterator An iterator to iterate over set bits in an OpenBitSet. 
OrdFieldSource Expert: obtains the ordinal of the field value from the default Lucene Fieldcache using getStringIndex(). 


ParallelMultiSearcher Implements parallel search over a set of Searchables
ParallelReader An IndexReader which reads multiple, parallel indexes. 
Parameter This class is deprecated. Use Java 5 enum, will be removed in a later Lucene 3.x release.  
ParseException This exception is thrown when parse errors are encountered. 
Payload A Payload is metadata that can be stored together with each occurrence of a term. 
PayloadAttribute The payload of a Token. 
PayloadAttributeImpl The payload of a Token. 
PayloadFunction An abstract class that defines a way for Payload*Query instances to transform the cumulative effects of payload scores for a document. 
PayloadNearQuery This class is very similar to SpanNearQuery except that it factors in the value of the payloads located at each of the positions where the TermSpans occurs. 
PayloadSpanUtil Experimental class to get set of payloads for most standard Lucene queries. 
PayloadTermQuery This class is very similar to SpanTermQuery except that it factors in the value of the payload located at each of the positions where the Term occurs. 
PerFieldAnalyzerWrapper This analyzer is used to facilitate scenarios where different fields require different analysis techniques. 
PhraseQuery A Query that matches documents containing a particular sequence of terms. 
PorterStemFilter Transforms the token stream as per the Porter stemming algorithm. 
PositionBasedTermVectorMapper For each Field, store position by position information. 
PositionBasedTermVectorMapper.TVPositionInfo Container for a term at a position  
PositionIncrementAttribute The positionIncrement determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching. 
PositionIncrementAttributeImpl The positionIncrement determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching. 
PositiveScoresOnlyCollector A Collector implementation which wraps another Collector and makes sure only documents with scores > 0 are collected. 
PrefixFilter A Filter that restricts search results to values that have a matching prefix in a given field. 
PrefixQuery A Query that matches documents containing terms with a specified prefix. 
PrefixTermEnum Subclass of FilteredTermEnum for enumerating all terms that match the specified prefix filter term. 
PriorityQueue<T> A PriorityQueue maintains a partial ordering of its elements such that the least element can always be found in constant time. 


Query The abstract base class for queries. 
QueryParser This class is generated by JavaCC. 
QueryParser.Operator The default operator for parsing queries. 
QueryParserConstants Token literal values and constants. 
QueryParserTokenManager Token Manager. 
QueryWrapperFilter Constrains search results to only match those which also match a provided query. 


RAMDirectory A memory-resident Directory implementation. 
RAMFile For Lucene internal use  
RAMOutputStream A memory-resident IndexOutput implementation. 
RamUsageEstimator Estimates the size of a given Object using a given MemoryModel for primitive size information. 
ReaderUtil Common util methods for dealing with IndexReaders. 
ReverseOrdFieldSource Expert: obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and reverses the order. 


ScoreCachingWrappingScorer A Scorer which wraps another scorer and caches the score of the current document. 
ScoreDoc Expert: Returned by low-level search implementations. 
Scorer Expert: Common scoring functionality for different types of queries. 
ScorerDocQueue A ScorerDocQueue maintains a partial ordering of its Scorers such that the least Scorer can always be found in constant time. 
Searchable The interface for search implementations. 
Searcher An abstract base class for search implementations. 
SegmentInfo Information about a segment such as it's name, directory, and files related to the segment. 
SegmentInfos A collection of segmentInfo objects with methods for operating on those segments in relation to the file system. 
SegmentInfos.FindSegmentsFile Utility class for executing code that needs to do something with the current segments file. 

NOTE: This API is new and still experimental (subject to change suddenly in the next release)

SerialMergeScheduler A MergeScheduler that simply does each merge sequentially, using the current thread. 
SetBasedFieldSelector Declare what fields to load normally and what fields to load lazily  
ShortFieldSource Expert: obtains short field values from the FieldCache using getShorts() and makes those values available as other numeric types, casting as needed. 
Similarity Expert: Scoring API. 
SimilarityDelegator Expert: Delegating scoring implementation. 
SimpleAnalyzer An Analyzer that filters LetterTokenizer with LowerCaseFilter  
SimpleFSDirectory A straightforward implementation of FSDirectory using 

Implements LockFactory using createNewFile()

SimpleLRUCache<K, V> Simple LRU cache implementation that uses a LinkedHashMap. 
SimpleMapCache<K, V> Simple cache implementation that uses a HashMap to store (key, value) pairs. 
SimpleStringInterner Simple lockless and memory barrier free String intern cache that is guaranteed to return the same String instance as String.intern() does. 
SingleInstanceLockFactory Implements LockFactory for a single in-process instance, meaning all locking will take place through this one instance. 
SingleTermEnum Subclass of FilteredTermEnum for enumerating a single term. 
SmallFloat Floating point numbers smaller than 32 bits. 
SnapshotDeletionPolicy A IndexDeletionPolicy that wraps around any other IndexDeletionPolicy and adds the ability to hold and later release a single "snapshot" of an index. 
Sort Encapsulates sort criteria for returned hits. 
SortedTermVectorMapper Store a sorted collection of TermVectorEntrys. 
SortedVIntList Stores and iterate on sorted integers in compressed form in RAM. 
SorterTemplate Borrowed from Cglib. 
SortField Stores information about how to sort documents by terms in an individual field. 
SpanFilter Abstract base class providing a mechanism to restrict searches to a subset of an index and also maintains and returns position information. 
SpanFilterResult The results of a SpanQueryFilter. 
SpanFirstQuery Matches spans near the beginning of a field. 
SpanNearQuery Matches spans which are near one another. 
SpanNotQuery Removes matches which overlap with another SpanQuery. 
SpanOrQuery Matches the union of its clauses. 
SpanQuery Base class for span-based queries. 
SpanQueryFilter Constrains search results to only match those which also match a provided query. 
Spans Expert: an enumeration of span matches. 
SpanScorer Public for extension only. 
SpanTermQuery Matches spans containing a term. 
SpanWeight Expert-only. 
StaleReaderException This exception is thrown when an IndexReader tries to make changes to the index (via deleteDocument(int), undeleteAll() or setNorm(int, String, byte)) but changes have already been committed to the index since this reader was instantiated. 
StandardAnalyzer Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of English stop words. 
StandardFilter Normalizes tokens extracted with StandardTokenizer
StandardTokenizer A grammar-based tokenizer constructed with JFlex

This should be a good tokenizer for most European-language documents:

  • Splits words at punctuation characters, removing punctuation. 
StopAnalyzer Filters LetterTokenizer with LowerCaseFilter and StopFilter
StopFilter Removes stop words from a token stream. 
StringHelper Methods for manipulating strings. 
StringInterner Subclasses of StringInterner are required to return the same single String object for all equal strings. 


TeeSinkTokenFilter This TokenFilter provides the ability to set aside attribute states that have already been analyzed. 
TeeSinkTokenFilter.SinkFilter A filter that decides which AttributeSource states to store in the sink. 
Term A Term represents a word from text. 
TermAttribute The term text of a Token. 
TermAttributeImpl The term text of a Token. 
TermDocs TermDocs provides an interface for enumerating <document, frequency> pairs for a term. 
TermEnum Abstract class for enumerating terms. 
TermFreqVector Provides access to stored term vector of a document field. 
TermPositions TermPositions provides an interface for enumerating the <document, frequency, <position>* > tuples for a term. 
TermPositionVector Extends TermFreqVector to provide additional information about positions in which each of the terms is found. 
TermQuery A Query that matches documents containing a term. 
TermRangeFilter A Filter that restricts search results to a range of term values in a given field. 
TermRangeQuery A Query that matches documents within an range of terms. 
TermRangeTermEnum Subclass of FilteredTermEnum for enumerating all terms that match the specified range parameters. 
TermSpans Expert: Public for extension only  
TermVectorEntry Convenience class for holding TermVector information. 
TermVectorEntryFreqSortedComparator Compares TermVectorEntrys first by frequency and then by the term (case-sensitive)  
TermVectorMapper The TermVectorMapper can be used to map Term Vectors into your own structure instead of the parallel array structure used by getTermFreqVector(int, String)
TermVectorOffsetInfo The TermVectorOffsetInfo class holds information pertaining to a Term in a TermPositionVector's offset information. 
ThreadInterruptedException Thrown by lucene on detecting that Thread.interrupt() had been called. 
TimeLimitingCollector The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowed search time limit. 
TimeLimitingCollector.TimeExceededException Thrown when elapsed search time exceeds allowed search time. 
Token A Token is an occurrence of a term from the text of a field. 
Token Describes the input token stream. 
Token.TokenAttributeFactory Expert: Creates a TokenAttributeFactory returning Token as instance for the basic attributes and for all other attributes calls the given delegate factory. 
TokenFilter A TokenFilter is a TokenStream whose input is another TokenStream. 
Tokenizer A Tokenizer is a TokenStream whose input is a Reader. 
TokenMgrError Token Manager Error. 
TokenStream A TokenStream enumerates the sequence of tokens, either from Fields of a Document or from query text. 
TopDocs Represents hits returned by search(Query, Filter, int) and search(Query, int)
TopDocsCollector<T extends ScoreDoc> A base class for all collectors that return a TopDocs output. 
TopFieldCollector A Collector that sorts by SortField using FieldComparators. 
TopFieldDocs Represents hits returned by search(Query, Filter, int, Sort)
TopScoreDocCollector A Collector implementation that collects the top-scoring hits, returning them as a TopDocs
ToStringUtils Helper methods to ease implementing toString()
TypeAttribute A Token's lexical type. 
TypeAttributeImpl A Token's lexical type. 


UnicodeUtil Class to encode java's UTF16 char[] into UTF8 byte[] without always allocating a new byte[] as String.getBytes("UTF-8") does. 


ValueSource Expert: source of values for basic function queries. 
ValueSourceQuery Expert: A Query that sets the scores of document to the values obtained from a ValueSource
VerifyingLockFactory A LockFactory that wraps another LockFactory and verifies that each lock obtain/release is "correct" (never results in two processes holding the lock at the same time). 
Version Use by certain classes to match version compatibility across releases of Lucene. 


Weight Expert: Calculate query weights and build query scorers. 
WhitespaceAnalyzer An Analyzer that uses WhitespaceTokenizer
WhitespaceTokenizer A WhitespaceTokenizer is a tokenizer that divides text at whitespace. 
WildcardQuery Implements the wildcard search query. 
WildcardTermEnum Subclass of FilteredTermEnum for enumerating all terms that match the specified wildcard filter term. 
WordlistLoader Loader for text files that represent a list of stopwords.