Class Index

A B C D E F I K L M N O P Q R S T U V W

A

AbstractAllTermDocs	Base class for enumerating all but deleted docs.
AbstractField
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 `AttributeImpl`s, and methods to add and get them.
AttributeSource.AttributeFactory	An AttributeFactory creates instances of `AttributeImpl`s.
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.

B

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.

C

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.
Collector	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.
ConcurrentMergeScheduler.MergeThread
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.
ConstantScoreQuery.ConstantScorer
ConstantScoreQuery.ConstantWeight
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: the score of its subQuery (any query) (optional) the score of its ValueSourceQuery (or queries).

D

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

E

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.

F

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.CreationPlaceholder
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.
FieldCacheTermsFilter.FieldCacheTermsFilterDocIdSet
FieldCacheTermsFilter.FieldCacheTermsFilterDocIdSet.FieldCacheTermsFilterDocIdSetIterator
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.
FieldMaskingSpanQuery	Wrapper to allow `SpanQuery` objects participate in composite single-field SpanQueries by 'lying' about their search field.
FieldReaderException
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 java.io.FileFilter, 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 `TermVectorEntry`s 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.

I

IndexableBinaryStringTools	Provides support for converting byte sequences to Strings and back again.
IndexCommit	Expert: represents a single commit into an index as seen by the `IndexDeletionPolicy` or `IndexReader`.
IndexDeletionPolicy	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).

K

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.

L

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.
LockFactory	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).
LogMergePolicy	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.

M

MapFieldSelector	A `FieldSelector` based on a Map of field names to `FieldSelectorResult`s
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.
MergePolicy	Expert: a MergePolicy determines the sequence of primitive merge operations to be used for overall merge and optimize operations.
MergePolicy.MergeAbortedException
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.
MergeScheduler	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 `Term`s 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`.

N

NamedThreadFactory	A default ThreadFactory implementation that accepts the name prefix of the created threads as a constructor argument.
NativeFSLockFactory	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.
NIOFSDirectory.NIOFSIndexInput
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).
NumericField	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)`.

O

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.
OpenBitSetDISI
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().

P

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.
PayloadNearQuery.PayloadNearSpanScorer
PayloadNearQuery.PayloadNearSpanWeight
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.
PayloadTermQuery.PayloadTermWeight
PayloadTermQuery.PayloadTermWeight.PayloadTermSpanScorer
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.

Q

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.
QueryTermVector
QueryWrapperFilter	Constrains search results to only match those which also match a provided query.

R

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 `IndexReader`s.
ReverseOrdFieldSource	Expert: obtains the ordinal of the field value from the default Lucene `FieldCache` using getStringIndex() and reverses the order.

S

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.
SegmentReader	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 java.io.RandomAccessFile.
SimpleFSDirectory.SimpleFSIndexInput
SimpleFSDirectory.SimpleFSIndexInput.Descriptor
SimpleFSDirectory.SimpleFSIndexOutput
SimpleFSLockFactory	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 `TermVectorEntry`s.
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.
SpanFilterResult.PositionInfo
SpanFilterResult.StartEnd
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.

T

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.
TeeSinkTokenFilter.SinkTokenStream
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 `TermVectorEntry`s 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 `Field`s 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 `FieldComparator`s.
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.

U

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

V

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.

W

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.