All Classes (Lucene 9.11.1 core API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class	Description
AbstractAnalysisFactory	Abstract parent class for analysis factories `TokenizerFactory`, `TokenFilterFactory` and `CharFilterFactory`.
AbstractIterator<E>	Simplifies the implementation of iterators a bit.
AbstractKnnCollector	AbstractKnnCollector is the default implementation for a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
AbstractPagedMutable<T extends AbstractPagedMutable<T>>	Base implementation for `PagedMutable` and `PagedGrowableWriter`.
Accountable	An object whose RAM usage can be computed.
Accountables	Helper methods for constructing nested resource descriptions and debugging RAM usage.
AfterEffect	This class acts as the base class for the implementations of the first normalization of the informative content in the DFR framework.
AfterEffectB	Model of the information gain based on the ratio of two Bernoulli processes.
AfterEffectL	Model of the information gain based on Laplace's law of succession.
AlreadyClosedException	This exception is thrown when there is an attempt to access something that has already been closed.
AnalysisSPILoader<S extends AbstractAnalysisFactory>	Helper class for loading named SPIs from classpath (e.g.
Analyzer	An Analyzer builds TokenStreams, which analyze text.
Analyzer.ReuseStrategy	Strategy defining how TokenStreamComponents are reused per call to `Analyzer.tokenStream(String, java.io.Reader)`.
Analyzer.TokenStreamComponents	This class encapsulates the outer components of a token stream.
AnalyzerWrapper	Extension to `Analyzer` suitable for Analyzers which wrap other Analyzers.
ArrayUtil	Methods for manipulating arrays.
ArrayUtil.ByteArrayComparator	Comparator for a fixed number of bytes.
Attribute	Base interface for attributes.
AttributeFactory	An AttributeFactory creates instances of `AttributeImpl`s.
AttributeFactory.StaticImplementationAttributeFactory<A extends AttributeImpl>	Expert: AttributeFactory returning an instance of the given `clazz` for the attributes it implements.
AttributeImpl	Base class for Attributes that can be added to a `AttributeSource`.
AttributeReflector	This interface is used to reflect contents of `AttributeSource` or `AttributeImpl`.
AttributeSource	An AttributeSource contains a list of different `AttributeImpl`s, and methods to add and get them.
AttributeSource.State	This class holds the state of an AttributeSource.
Automata	Construction of basic automata.
Automaton	Represents an automaton and all its states and transitions.
Automaton.Builder	Records new states and transitions and then `Automaton.Builder.finish()` creates the `Automaton`.
AutomatonProvider	Automaton provider for `RegExp.` `RegExp.toAutomaton(AutomatonProvider,int)`
AutomatonQuery	A `Query` that will match terms against a finite-state machine.
AutomatonTermsEnum	A FilteredTermsEnum that enumerates terms based upon what is accepted by a DFA.
AutomatonToTokenStream	Converts an Automaton into a TokenStream.
Axiomatic	Axiomatic approaches for IR.
AxiomaticF1EXP	F1EXP is defined as Sum(tf(term_doc_freq)ln(docLen)IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF1LOG	F1LOG is defined as Sum(tf(term_doc_freq)ln(docLen)IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF2EXP	F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF2LOG	F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF3EXP	F3EXP is defined as Sum(tf(term_doc_freq)IDF(term)-gamma(docLen, queryLen)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
AxiomaticF3LOG	F3EXP is defined as Sum(tf(term_doc_freq)IDF(term)-gamma(docLen, queryLen)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
BaseCompositeReader<R extends IndexReader>	Base class for implementing `CompositeReader`s based on an array of sub-readers.
BaseDirectory	Base implementation for a concrete `Directory` that uses a `LockFactory` for locking.
BaseTermsEnum	A base TermsEnum that adds default implementations for `BaseTermsEnum.attributes()` `BaseTermsEnum.termState()` `BaseTermsEnum.seekExact(BytesRef)` `BaseTermsEnum.seekExact(BytesRef, TermState)` In some cases, the default implementation may be slow and consume huge memory, so subclass SHOULD have its own implementation if possible.
BasicModel	This class acts as the base class for the specific basic model implementations in the DFR framework.
BasicModelG	Geometric as limiting form of the Bose-Einstein model.
BasicModelIF	An approximation of the I(n_e) model.
BasicModelIn	The basic tf-idf model of randomness.
BasicModelIne	Tf-idf model of randomness, based on a mixture of Poisson and inverse document frequency.
BasicStats	Stores all statistics commonly used ranking methods.
BinaryDocValues	A per-document numeric value.
BinaryDocValuesField	Field that stores a per-document `BytesRef` value.
BinaryPoint	An indexed binary field for fast range filters.
BinaryRangeDocValues	A binary representation of a range that wraps a BinaryDocValues field
BitDocIdSet	Implementation of the `DocIdSet` interface on top of a `BitSet`.
BitMixer	Bit mixing utilities.
Bits	Interface for Bitset-like structures.
Bits.MatchAllBits	Bits impl of the specified length with all bits set.
Bits.MatchNoBits	Bits impl of the specified length with no bits set.
BitSet	Base implementation for a bit set.
BitSetIterator	A `DocIdSetIterator` which iterates over set bits in a bit set.
BitUtil	A variety of high efficiency bit twiddling routines and encoders for primitives.
BKDConfig	Basic parameters for indexing points on the BKD tree.
BKDRadixSelector	Offline Radix selector for BKD tree.
BKDRadixSelector.PathSlice	Sliced reference to points in an PointWriter.
BKDReader	Handles reading a block KD-tree in byte[] space previously written with `BKDWriter`.
BKDWriter	Recursively builds a block KD-tree to assign all incoming points in N-dim space to smaller and smaller N-dim rectangles (cells) until the number of points in a given rectangle is <= `config.maxPointsInLeafNode`.
BlendedTermQuery	A `Query` that blends index statistics across multiple terms.
BlendedTermQuery.Builder	A Builder for `BlendedTermQuery`.
BlendedTermQuery.DisjunctionMaxRewrite	A `BlendedTermQuery.RewriteMethod` that creates a `DisjunctionMaxQuery` out of the sub queries.
BlendedTermQuery.RewriteMethod	A `BlendedTermQuery.RewriteMethod` defines how queries for individual terms should be merged.
BlockingFloatHeap	A blocking bounded min heap that stores floats.
BlockPackedReaderIterator	Reader for sequences of longs written with `BlockPackedWriter`.
BlockPackedWriter	A writer for large sequences of longs.
BlockTermState	Holds all state required for `PostingsReaderBase` to produce a `PostingsEnum` without re-seeking the terms dict.
BM25Similarity	BM25 Similarity.
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.Builder	A builder for boolean queries.
BooleanQuery.TooManyClauses	Deprecated. use `IndexSearcher.TooManyClauses`
BooleanSimilarity	Simple similarity that gives terms a score that is equal to their query boost.
BoostAttribute	Add this `Attribute` to a `TermsEnum` returned by `MultiTermQuery.getTermsEnum(Terms,AttributeSource)` and update the boost on each returned term.
BoostAttributeImpl	Implementation class for `BoostAttribute`.
BoostQuery	A `Query` wrapper that allows to give a boost to the wrapped query.
BufferAllocationException	BufferAllocationException forked from HPPC.
BufferedChecksum	Wraps another `Checksum` with an internal buffer to speed up checksum calculations.
BufferedChecksumIndexInput	Simple implementation of `ChecksumIndexInput` that wraps another input and delegates calls.
BufferedIndexInput	Base implementation class for buffered `IndexInput`.
BufferingKnnVectorsWriter	Buffers up pending vector value(s) per doc, then flushes when segment flushes.
BulkScorer	This class is used to score a range of documents at once, and is returned by `Weight.bulkScorer(org.apache.lucene.index.LeafReaderContext)`.
ByteArrayDataInput	DataInput backed by a byte array.
ByteArrayDataOutput	DataOutput backed by a byte array.
ByteBlockPool	This class enables the allocation of fixed-size buffers and their management as part of a buffer array.
ByteBlockPool.Allocator	Abstract class for allocating and freeing byte blocks.
ByteBlockPool.DirectAllocator	A simple `ByteBlockPool.Allocator` that never recycles.
ByteBlockPool.DirectTrackingAllocator	A simple `ByteBlockPool.Allocator` that never recycles, but tracks how much total RAM is in use.
ByteBufferIndexInput	Deprecated. This class was made public for internal reasons (`instanceof` checks).
ByteBuffersDataInput	A `DataInput` implementing `RandomAccessInput` and reading data from a list of `ByteBuffer`s.
ByteBuffersDataOutput	A `DataOutput` storing data in a list of `ByteBuffer`s.
ByteBuffersDataOutput.ByteBufferRecycler	An implementation of a `ByteBuffer` allocation and recycling policy.
ByteBuffersDirectory	A `ByteBuffer`-based `Directory` implementation that can be used to store index files on the heap.
ByteBuffersIndexInput	An `IndexInput` implementing `RandomAccessInput` and backed by a `ByteBuffersDataInput`.
ByteBuffersIndexOutput	An `IndexOutput` writing to a `ByteBuffersDataOutput`.
ByteRunAutomaton	Automaton representation for matching UTF-8 byte[].
ByteSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of bytes.
BytesRef	Represents byte[], as a slice (offset + length) into an existing byte[].
BytesRefArray	A simple append only random-access `BytesRef` array that stores full copies of the appended bytes in a `ByteBlockPool`.
BytesRefArray.IndexedBytesRefIterator	An extension of `BytesRefIterator` that allows retrieving the index of the current element
BytesRefArray.SortState	Used to iterate the elements of an array in a given order.
BytesRefBlockPool	Represents a logical list of ByteRef backed by a `ByteBlockPool`.
BytesRefBuilder	A builder for `BytesRef` instances.
BytesRefComparator	Specialized `BytesRef` comparator that `StringSorter` has optimizations for.
BytesRefFSTEnum<T>	Enumerates all input (BytesRef) + output pairs in an FST.
BytesRefFSTEnum.InputOutput<T>	Holds a single input (BytesRef) + output pair.
BytesRefHash	`BytesRefHash` is a special purpose hash-map like data-structure optimized for `BytesRef` instances.
BytesRefHash.BytesStartArray	Manages allocation of the per-term addresses.
BytesRefHash.DirectBytesStartArray	A simple `BytesRefHash.BytesStartArray` that tracks memory allocation using a private `Counter` instance.
BytesRefHash.MaxBytesLengthExceededException	Thrown if a `BytesRef` exceeds the `BytesRefHash` limit of `ByteBlockPool.BYTE_BLOCK_SIZE`-2.
BytesRefIterator	A simple iterator interface for `BytesRef` iteration.
BytesTermAttribute	This attribute can be used if you have the raw term bytes to be indexed.
BytesTermAttributeImpl	Implementation class for `BytesTermAttribute`.
ByteVectorSimilarityQuery	Search for all (approximate) byte vectors above a similarity threshold.
ByteVectorValues	This class provides access to per-document floating point vector values indexed as `KnnByteVectorField`.
CachingCollector	Caches all docs, and optionally also scores, coming from a search, and is then able to replay them to another collector.
CachingTokenFilter	This class can be used if the token attributes of a TokenStream are intended to be consumed more than once.
CharacterRunAutomaton	Automaton representation for matching char[].
CharacterUtils	Utility class to write tokenizers or token filters.
CharacterUtils.CharacterBuffer	A simple IO buffer to use with `CharacterUtils.fill(CharacterBuffer, Reader)`.
CharArrayMap<V>	A simple class that stores key Strings as char[]'s in a hash table.
CharArraySet	A simple class that stores Strings as char[]'s in a hash table.
CharCursor	Forked from HPPC, holding int index and char value.
CharFilter	Subclasses of CharFilter can be chained to filter a Reader They can be used as `Reader` with additional offset correction.
CharFilterFactory	Abstract parent class for analysis factories that create `CharFilter` instances.
CharHashSet	A hash set of `char`s, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap<VType>	A hash map of `char` to `Object`, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap.CharObjectCursor<VType>	Forked from HPPC, holding int index,key and value
CharSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of characters.
CharsRef	Represents char[], as a slice (offset + length) into an existing char[].
CharsRefBuilder	A builder for `CharsRef` instances.
CharTermAttribute	The term text of a Token.
CharTermAttributeImpl	Default implementation of `CharTermAttribute`.
CheckedIntConsumer<T extends Exception>	Like `IntConsumer`, but may throw checked exceptions.
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.CheckIndexException	The marker RuntimeException used by CheckIndex APIs when index integrity failure is detected.
CheckIndex.Options	Run-time configuration options for CheckIndex commands.
CheckIndex.Status	Returned from `CheckIndex.checkIndex()` detailing the health and status of the index.
CheckIndex.Status.DocValuesStatus	Status from testing DocValues
CheckIndex.Status.FieldInfoStatus	Status from testing field infos.
CheckIndex.Status.FieldNormStatus	Status from testing field norms.
CheckIndex.Status.IndexSortStatus	Status from testing index sort
CheckIndex.Status.LiveDocStatus	Status from testing livedocs
CheckIndex.Status.PointsStatus	Status from testing PointValues
CheckIndex.Status.SegmentInfoStatus	Holds the status of each segment in the index.
CheckIndex.Status.SoftDeletsStatus	Status from testing soft deletes
CheckIndex.Status.StoredFieldStatus	Status from testing stored fields.
CheckIndex.Status.TermIndexStatus	Status from testing term index.
CheckIndex.Status.TermVectorStatus	Status from testing stored fields.
CheckIndex.Status.VectorValuesStatus	Status from testing vector values
CheckIndex.VerifyPointsVisitor	Walks the entire N-dimensional points space, verifying that all points fall within the last cell's boundaries.
ChecksumIndexInput	Extension of IndexInput, computing checksum as it goes.
Circle	Represents a circle on the earth's surface.
ClassicSimilarity	Expert: Historical scoring implementation.
ClassLoaderUtils	Helper class used by ServiceLoader to investigate parent/child relationships of `ClassLoader`s.
ClasspathResourceLoader	Simple `ResourceLoader` that uses `ClassLoader.getResourceAsStream(String)` and `Class.forName(String,boolean,ClassLoader)` to open resources and classes, respectively.
CloseableRandomVectorScorerSupplier	A supplier that creates `RandomVectorScorer` from an ordinal.
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.
Codec	Encodes/decodes an inverted index segment.
CodecReader	LeafReader implemented by codec APIs.
CodecUtil	Utility class for reading and writing versioned headers.
CollectionStatistics	Contains statistics for a collection (field).
CollectionTerminatedException	Throw this exception in `LeafCollector.collect(int)` to prematurely terminate collection of the current leaf.
CollectionUtil	Methods for manipulating (sorting) and creating collections.
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.
CollectorManager<C extends Collector,T>	A manager of collectors.
CommandLineUtil	Class containing some useful methods used by command line tools
CompetitiveImpactAccumulator	This class accumulates the (freq, norm) pairs that may produce competitive scores.
CompiledAutomaton	Immutable class holding compiled details for a given Automaton.
CompiledAutomaton.AUTOMATON_TYPE	Automata are compiled into different internal forms for the most efficient execution depending upon the language they accept.
Component2D	2D Geometry object that supports spatial relationships with bounding boxes, triangles and points.
Component2D.WithinRelation	Used by withinTriangle to check the within relationship between a triangle and the query shape (e.g.
CompositeReader	Instances of this reader type can only be used to get stored fields from the underlying LeafReaders, but it is not possible to directly retrieve postings.
CompositeReaderContext	`IndexReaderContext` for `CompositeReader` instance.
CompoundDirectory	A read-only `Directory` that consists of a view over a compound file.
CompoundFormat	Encodes/decodes compound files
CompressionMode	A compression mode.
Compressor	A data compressor.
ConcurrentHnswMerger	This merger merges graph in a concurrent manner, by using `HnswConcurrentMergeBuilder`
ConcurrentMergeScheduler	A `MergeScheduler` that runs each merge using a separate thread.
ConcurrentMergeSchedulerAccess	Access to `ConcurrentMergeScheduler` internals exposed to the test framework.
ConjunctionUtils	Helper methods for building conjunction iterators
Constants	Some useful constants.
ConstantScoreQuery	A query that wraps another query and simply returns a constant score equal to 1 for every document that matches the query.
ConstantScoreQuery.ConstantBulkScorer	We return this as our `BulkScorer` so that if the CSQ wraps a query with its own optimized top-level scorer (e.g.
ConstantScoreScorer	A constant-scoring `Scorer`.
ConstantScoreWeight	A Weight that has a constant score equal to the boost of the wrapped query.
ControlledRealTimeReopenThread<T>	Utility class that runs a thread to manage periodicc reopens of a `ReferenceManager`, with methods to wait for a specific index changes to become visible.
CorruptIndexException	This exception is thrown when Lucene detects an inconsistency in the index.
Counter	Simple counter class
DaciukMihovAutomatonBuilder	Deprecated. Visibility of this class will be reduced in a future release.
DataInput	Abstract base class for performing read operations of Lucene's low-level data types.
DataOutput	Abstract base class for performing write operations of Lucene's low-level data types.
DateTools	Provides support for converting dates to strings and vice-versa.
DateTools.Resolution	Specifies the time granularity.
Decompressor	A decompressor.
DefaultFlatVectorScorer	Default implementation of `FlatVectorsScorer`.
DeflateWithPresetDictCompressionMode	A compression mode that trades speed for compression ratio.
DelegatingAnalyzerWrapper	An analyzer wrapper, that doesn't allow to wrap components or readers.
DFISimilarity	Implements the Divergence from Independence (DFI) model based on Chi-square statistics (i.e., standardized Chi-squared distance from independence in term frequency tf).
DFRSimilarity	Implements the divergence from randomness (DFR) framework introduced in Gianni Amati and Cornelis Joost Van Rijsbergen.
DirectMonotonicReader	Retrieves an instance previously written by `DirectMonotonicWriter`.
DirectMonotonicReader.Meta	In-memory metadata that needs to be kept around for `DirectMonotonicReader` to read data from disk.
DirectMonotonicWriter	Write monotonically-increasing sequences of integers.
Directory	A `Directory` provides an abstraction layer for storing a list of files.
DirectoryReader	DirectoryReader is an implementation of `CompositeReader` that can read indexes in a `Directory`.
DirectReader	Retrieves an instance previously written by `DirectWriter`
DirectWriter	Class for writing packed integers to be directly read from Directory.
DisiPriorityQueue	A priority queue of DocIdSetIterators that orders by current doc ID.
DisiWrapper	Wrapper used in `DisiPriorityQueue`.
DisjunctionDISIApproximation	A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
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.
Distribution	The probabilistic distribution used to model term occurrence in information-based models.
DistributionLL	Log-logistic distribution.
DistributionSPL	The smoothed power-law (SPL) distribution for the information-based framework that is described in the original paper.
DocBaseBitSetIterator	A `DocIdSetIterator` like `BitSetIterator` but has a doc base in onder to avoid storing previous 0s.
DocComparator	Comparator that sorts by asc _doc
DocIDMerger<T extends DocIDMerger.Sub>	Utility class to help merging documents from sub-readers according to either simple concatenated (unsorted) order, or by a specified index-time sort, skipping deleted documents and remapping non-deleted documents.
DocIDMerger.Sub	Represents one sub-reader being merged
DocIdSet	A DocIdSet contains a set of doc ids.
DocIdSetBuilder	A builder of `DocIdSet`s.
DocIdSetBuilder.BulkAdder	Utility class to efficiently add many docs in one go.
DocIdSetIterator	This abstract class defines methods to iterate over a set of non-decreasing doc ids.
DocIdStream	A stream of doc IDs.
DocsWithFieldSet	Accumulator for documents that have a value for a field.
Document	Documents are the unit of indexing and search.
DocumentStoredFieldVisitor	A `StoredFieldVisitor` that creates a `Document` from stored fields.
DocValues	This class contains utility methods and constants for DocValues
DocValuesConsumer	Abstract API that consumes numeric, binary and sorted docvalues.
DocValuesFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
DocValuesFormat	Encodes/decodes per-document values.
DocValuesProducer	Abstract API that produces numeric, binary, sorted, sortedset, and sortednumeric docvalues.
DocValuesRewriteMethod	Rewrites MultiTermQueries into a filter, using DocValues for term enumeration.
DocValuesType	DocValues types.
DoubleComparator	Comparator based on `Double.compare(double, double)` for `numHits`.
DoubleCursor	Forked from HPPC, holding int index and double value.
DoubleDocValuesField	Syntactic sugar for encoding doubles as NumericDocValues via `Double.doubleToRawLongBits(double)`.
DoubleField	Field that stores a per-document `double` value for scoring, sorting or value retrieval and index the field for fast range filters.
DoublePoint	An indexed `double` field for fast range filters.
DoubleRange	An indexed Double Range field.
DoubleRangeDocValuesField	DocValues field for DoubleRange.
DoubleValues	Per-segment, per-document double values, which can be calculated at search-time
DoubleValuesSource	Base class for producing `DoubleValues`
EmptyDocValuesProducer	Abstract base class implementing a `DocValuesProducer` that has no doc values.
ExactPhraseMatcher	Expert: Find exact phrases
ExitableDirectoryReader	The `ExitableDirectoryReader` wraps a real index `DirectoryReader` and allows for a `QueryTimeout` implementation object to be checked periodically to see if the thread should exit or not.
ExitableDirectoryReader.ExitableFilterAtomicReader	Wrapper class for another FilterAtomicReader.
ExitableDirectoryReader.ExitableSubReaderWrapper	Wrapper class for a SubReaderWrapper that is used by the ExitableDirectoryReader.
ExitableDirectoryReader.ExitableTerms	Wrapper class for another Terms implementation that is used by ExitableFields.
ExitableDirectoryReader.ExitableTermsEnum	Wrapper class for TermsEnum that is used by ExitableTerms for implementing an exitable enumeration of terms.
ExitableDirectoryReader.ExitingReaderException	Exception that is thrown to prematurely terminate a term enumeration.
Explanation	Expert: Describes the score computation for document and query.
FeatureField	`Field` that can be used to store static scoring factors into documents.
Field	Expert: directly create a field for a document.
Field.Store	Specifies whether and how a field should be stored.
FieldComparator<T>	Expert: a FieldComparator compares hits so as to determine their sort order when collecting the top results with `TopFieldCollector`.
FieldComparator.RelevanceComparator	Sorts by descending relevance.
FieldComparator.TermValComparator	Sorts by field's natural Term 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.
FieldExistsQuery	A `Query` that matches documents that contain either a `KnnFloatVectorField`, `KnnByteVectorField` or a field that indexes norms or doc values.
FieldInfo	Access to the Field Info file that describes document fields and whether or not they are indexed.
FieldInfos	Collection of `FieldInfo`s (accessible by number or by name).
FieldInfosFormat	Encodes/decodes `FieldInfos`
FieldInvertState	This class tracks the number and position / offset parameters of terms being added to the index.
FieldReader	BlockTree's implementation of `Terms`.
Fields	Provides a `Terms` index for fields that have it, and lists which fields do.
FieldsConsumer	Abstract API that consumes terms, doc, freq, prox, offset and payloads postings.
FieldsIndexWriter	Efficient index format for block-based `Codec`s.
FieldsProducer	Abstract API that produces terms, doc, freq, prox, offset and payloads postings.
FieldType	Describes the properties of a field.
FieldValueHitQueue<T extends FieldValueHitQueue.Entry>	Expert: A hit queue for sorting by hits by terms in more than one field.
FieldValueHitQueue.Entry	Extension of ScoreDoc to also store the `FieldComparator` slot.
FileDeleter	This class provides ability to track the reference counts of a set of index files and delete them when their counts decreased to 0.
FileDeleter.MsgType	Types of messages this file deleter will broadcast REF: messages about reference FILE: messages about file
FileDeleter.RefCount	Tracks the reference count for a single index file:
FileSwitchDirectory	Expert: A Directory instance that switches files between two other Directory instances.
FilterBinaryDocValues	Delegates all methods to a wrapped `BinaryDocValues`.
FilterCodec	A codec that forwards all its method calls to another codec.
FilterCodecReader	A `FilterCodecReader` contains another CodecReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterCollector	`Collector` delegator.
FilterDirectory	Directory implementation that delegates calls to another directory.
FilterDirectoryReader	A FilterDirectoryReader wraps another DirectoryReader, allowing implementations to transform or extend it.
FilterDirectoryReader.DelegatingCacheHelper	A DelegatingCacheHelper is a CacheHelper specialization for implementing long-lived caching behaviour for FilterDirectoryReader subclasses.
FilterDirectoryReader.SubReaderWrapper	Factory class passed to FilterDirectoryReader constructor that allows subclasses to wrap the filtered DirectoryReader's subreaders.
FilteredDocIdSetIterator	Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validation mechanism on an underlying DocIdSetIterator.
FilteredTermsEnum	Abstract class for enumerating a subset of all terms.
FilteredTermsEnum.AcceptStatus	Return value, if term should be accepted or the iteration should `END`.
FilterIndexInput	IndexInput implementation that delegates calls to another directory.
FilterIndexInputAccess	Access to `FilterIndexInput` internals exposed to the test framework.
FilterIndexOutput	IndexOutput implementation that delegates calls to another directory.
FilteringTokenFilter	Abstract base class for TokenFilters that may remove tokens.
FilterIterator<T,InnerT extends T>	An `Iterator` implementation that filters elements with a boolean predicate.
FilterLeafCollector	`LeafCollector` delegator.
FilterLeafReader	A `FilterLeafReader` contains another LeafReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterLeafReader.FilterFields	Base class for filtering `Fields` implementations.
FilterLeafReader.FilterPostingsEnum	Base class for filtering `PostingsEnum` implementations.
FilterLeafReader.FilterTerms	Base class for filtering `Terms` implementations.
FilterLeafReader.FilterTermsEnum	Base class for filtering `TermsEnum` implementations.
FilterMatchesIterator	A MatchesIterator that delegates all calls to another MatchesIterator
FilterMergePolicy	A wrapper for `MergePolicy` instances.
FilterNumericDocValues	Delegates all methods to a wrapped `NumericDocValues`.
FilterScorable	Filter a `Scorable`, intercepting methods and optionally changing their return values
FilterScorer	A `FilterScorer` contains another `Scorer`, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterSortedDocValues	Delegates all methods to a wrapped `SortedDocValues`.
FilterSortedNumericDocValues	Delegates all methods to a wrapped `SortedNumericDocValues`.
FilterSortedSetDocValues	Delegates all methods to a wrapped `SortedSetDocValues`.
FilterVectorValues	Delegates all methods to a wrapped `FloatVectorValues`.
FilterWeight	A `FilterWeight` contains another `Weight` and implements all abstract methods by calling the contained weight's method.
FiniteStringsIterator	Iterates all accepted strings.
FixedBitSet	BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
FlagsAttribute	This attribute can be used to pass different flags down the `Tokenizer` chain, e.g.
FlagsAttributeImpl	Default implementation of `FlagsAttribute`.
FlatFieldVectorsWriter<T>	Vectors' writer for a field
FlatVectorScorerUtil	Utilities for `FlatVectorsScorer`.
FlatVectorsFormat	Encodes/decodes per-document vectors and provides a scoring interface for the flat stored vectors
FlatVectorsReader	Reads vectors from an index.
FlatVectorsScorer	Provides mechanisms to score vectors that are stored in a flat file The purpose of this class is for providing flexibility to the codec utilizing the vectors
FlatVectorsWriter	Vectors' writer for a field that allows additional indexing logic to be implemented by the caller
FloatArrayList	An array-backed list of `float`.
FloatComparator	Comparator based on `Float.compare(float, float)` for `numHits`.
FloatCursor	Forked from HPPC, holding int index and float value.
FloatDocValuesField	Syntactic sugar for encoding floats as NumericDocValues via `Float.floatToRawIntBits(float)`.
FloatField	Field that stores a per-document `float` value for scoring, sorting or value retrieval and index the field for fast range filters.
FloatHeap	A bounded min heap that stores floats.
FloatPoint	An indexed `float` field for fast range filters.
FloatRange	An indexed Float Range field.
FloatRangeDocValuesField	DocValues field for FloatRange.
FloatVectorSimilarityQuery	Search for all (approximate) float vectors above a similarity threshold.
FloatVectorValues	This class provides access to per-document floating point vector values indexed as `KnnFloatVectorField`.
FlushInfo	A FlushInfo provides information required for a FLUSH context.
ForDeltaUtil	Utility class to encode/decode increasing sequences of 128 integers.
FrequencyTrackingRingBuffer	A ring buffer that tracks the frequency of the integers that it contains.
FSDirectory	Base class for Directory implementations that store index files in the file system.
FSLockFactory	Base class for file system based locking implementation.
FST<T>	Represents an finite state machine (FST), using a compact byte[] format.
FST.Arc<T>	Represents a single arc.
FST.BytesReader	Reads bytes stored in an FST.
FST.FSTMetadata<T>	Represents the FST metadata.
FST.INPUT_TYPE	Specifies allowed range of each int input label for this FST.
FSTCompiler<T>	Builds a minimal FST (maps an IntsRef term to an arbitrary output) from pre-sorted terms with outputs.
FSTCompiler.Builder<T>	Fluent-style constructor for FST `FSTCompiler`.
FSTReader	Abstraction for reading bytes necessary for FST.
FSTStore	A type of `FSTReader` which needs data to be initialized before use
FuzzyQuery	Implements the fuzzy search query.
FuzzyTermsEnum	Subclass of TermsEnum for enumerating all terms that are similar to the specified filter term.
FuzzyTermsEnum.FuzzyTermsException	Thrown to indicate that there was an issue creating a fuzzy query for a given term.
GeoEncodingUtils	reusable geopoint encoding methods
GeoEncodingUtils.Component2DPredicate	A predicate that checks whether a given point is within a component2D geometry.
GeoEncodingUtils.DistancePredicate	A predicate that checks whether a given point is within a distance of another point.
Geometry	Base class for `LatLonGeometry` and `XYGeometry`
GeoUtils	Basic reusable geo-spatial utility methods
GeoUtils.WindingOrder	used to define the orientation of 3 points -1 = Clockwise 0 = Colinear 1 = Counter-clockwise
GraphTokenFilter	An abstract TokenFilter that exposes its input stream as a graph
GraphTokenStreamFiniteStrings	Consumes a TokenStream and creates an `Automaton` where the transition labels are terms from the `TermToBytesRefAttribute`.
GroupVIntUtil	This class contains utility methods and constants for group varint
GroupVIntUtil.IntReader	Provides an abstraction for read int values, so that decoding logic can be reused in different DataInput.
GrowableWriter	Implements `PackedInts.Mutable`, but grows the bit count of the underlying packed ints on-demand.
HeapPointReader	Utility class to read buffered points from in-heap arrays.
HeapPointWriter	Utility class to write new points into in-heap arrays.
HitQueue	Expert: Priority queue containing hit docs
HnswBuilder	Interface for builder building the `OnHeapHnswGraph`
HnswConcurrentMergeBuilder	A graph builder that manages multiple workers, it only supports adding the whole graph all at once.
HnswGraph	Hierarchical Navigable Small World graph.
HnswGraph.ArrayNodesIterator	NodesIterator that accepts nodes as an integer array.
HnswGraph.CollectionNodesIterator	Nodes iterator based on set representation of nodes.
HnswGraph.NodesIterator	Iterator over the graph nodes on a certain level, Iterator also provides the size – the total number of nodes to be iterated over.
HnswGraphBuilder	Builder for HNSW graph.
HnswGraphBuilder.GraphBuilderKnnCollector	A restricted, specialized knnCollector that can be used when building a graph.
HnswGraphMerger	Abstraction of merging multiple graphs into one on-heap graph
HnswGraphProvider	An interface that provides an HNSW graph.
HnswGraphSearcher	Searches an HNSW graph to find nearest neighbors to a query vector.
IBSimilarity	Provides a framework for the family of information-based models, as described in Stéphane Clinchant and Eric Gaussier.
IgnoreRandomChains	Annotation to not test a class or constructor with `TestRandomChains` integration test.
Impact	Per-document scoring factors.
Impacts	Information about upcoming impacts, ie.
ImpactsDISI	`DocIdSetIterator` that skips non-competitive docs thanks to the indexed impacts.
ImpactsEnum	Extension of `PostingsEnum` which also provides information about upcoming impacts.
ImpactsSource	Source of `Impacts`.
IncrementalHnswGraphMerger	This selects the biggest Hnsw graph from the provided merge state and initializes a new HnswGraphBuilder with that graph as a starting point.
Independence	Computes the measure of divergence from independence for DFI scoring functions.
IndependenceChiSquared	Normalized chi-squared measure of distance from independence
IndependenceSaturated	Saturated measure of distance from independence
IndependenceStandardized	Standardized measure of distance from independence
IndexableField	Represents a single field for indexing.
IndexableFieldType	Describes the properties of a field.
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`.
IndexedDISI	Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
IndexFileNames	This class contains useful constants representing filenames and extensions used by lucene, as well as convenience methods for querying whether a file name matches an extension (`matchesExtension`), as well as generating file names from a segment name, generation and extension ( `fileNameFromGeneration`, `segmentFileName`).
IndexFormatTooNewException	This exception is thrown when Lucene detects an index that is newer than this Lucene version.
IndexFormatTooOldException	This exception is thrown when Lucene detects an index that is too old for this Lucene version
IndexInput	Abstract base class for input from a file in a `Directory`.
IndexNotFoundException	Signals that no index was found in the Directory.
IndexOptions	Controls how much information is stored in the postings lists.
IndexOrDocValuesQuery	A query that uses either an index structure (points or terms) or doc values in order to run a query, depending which one is more efficient.
IndexOutput	A `DataOutput` for appending data to a file in a `Directory`.
IndexPackageAccess	Access to `org.apache.lucene.index` package internals exposed to the test framework.
IndexPackageAccess.FieldInfosBuilder	Public type exposing `FieldInfo` internal builders.
IndexReader	IndexReader is an abstract class, providing an interface for accessing a point-in-time view of an index.
IndexReader.CacheHelper	A utility class that gives hooks in order to help build a cache based on the data that is contained in this index.
IndexReader.CacheKey	A cache key identifying a resource that is being cached on.
IndexReader.ClosedListener	A listener that is called when a resource gets closed.
IndexReaderContext	A struct like class that represents a hierarchical relationship between `IndexReader` instances.
IndexSearcher	Implements search over a single IndexReader.
IndexSearcher.LeafSlice	A class holding a subset of the `IndexSearcher`s leaf contexts to be executed within a single thread.
IndexSearcher.TooManyClauses	Thrown when an attempt is made to add more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` clauses.
IndexSearcher.TooManyNestedClauses	Thrown when a client attempts to execute a Query that has more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` total clauses cumulatively in all of its children.
IndexSorter	Handles how documents should be sorted in an index, both within a segment and between segments.
IndexSorter.ComparableProvider	Used for sorting documents across segments
IndexSorter.DocComparator	A comparator of doc IDs, used for sorting documents within a segment
IndexSorter.DoubleSorter	Sorts documents based on double values from a NumericDocValues instance
IndexSorter.FloatSorter	Sorts documents based on float values from a NumericDocValues instance
IndexSorter.IntSorter	Sorts documents based on integer values from a NumericDocValues instance
IndexSorter.LongSorter	Sorts documents based on long values from a NumericDocValues instance
IndexSorter.NumericDocValuesProvider	Provide a NumericDocValues instance for a LeafReader
IndexSorter.SortedDocValuesProvider	Provide a SortedDocValues instance for a LeafReader
IndexSorter.StringSorter	Sorts documents based on terms from a SortedDocValues instance
IndexSortSortedNumericDocValuesRangeQuery	A range query that can take advantage of the fact that the index is sorted to speed up execution.
IndexUpgrader	This is an easy-to-use tool that upgrades all segments of an index from previous Lucene versions to the current segment file format.
IndexWriter	An `IndexWriter` creates and maintains an index.
IndexWriter.DocStats	DocStats for this index
IndexWriter.IndexReaderWarmer	If `DirectoryReader.open(IndexWriter)` 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.
IndexWriterAccess	Access to `IndexWriter` internals exposed to the test framework.
IndexWriterConfig	Holds all the configuration that is used to create an `IndexWriter`.
IndexWriterConfig.OpenMode	Specifies the open mode for `IndexWriter`.
IndexWriterEventListener	A callback event listener for recording key events happened inside IndexWriter
IndriAndQuery	A Query that matches documents matching combinations of subqueries.
IndriAndScorer	Combines scores of subscorers.
IndriAndWeight	The Weight for IndriAndQuery, used to normalize, score and explain these queries.
IndriDirichletSimilarity	Bayesian smoothing using Dirichlet priors as implemented in the Indri Search engine (http://www.lemurproject.org/indri.php).
IndriDirichletSimilarity.IndriCollectionModel	Models `p(w\|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
IndriDisjunctionScorer	The Indri implemenation of a disjunction scorer which stores the subscorers for the child queries.
IndriQuery	A Basic abstract query that all IndriQueries can extend to implement toString, equals, getClauses, and iterator.
IndriScorer	The Indri parent scorer that stores the boost so that IndriScorers can use the boost outside of the term.
InetAddressPoint	An indexed 128-bit `InetAddress` field.
InetAddressRange	An indexed InetAddress Range Field
InfoStream	Debugging API for Lucene classes such as `IndexWriter` and `SegmentInfos`.
InitializedHnswGraphBuilder	This creates a graph builder that is initialized with the provided HnswGraph.
InPlaceMergeSorter	`Sorter` implementation based on the merge-sort algorithm that merges in place (no extra memory will be allocated).
InputStreamDataInput	A `DataInput` wrapping a plain `InputStream`.
IntArrayList	An array-backed list of `int`.
IntBlockPool	A pool for int blocks similar to `ByteBlockPool`
IntBlockPool.Allocator	Abstract class for allocating and freeing int blocks.
IntBlockPool.DirectAllocator	A simple `IntBlockPool.Allocator` that never recycles.
IntComparator	Comparator based on `Integer.compare(int, int)` for `numHits`.
IntCursor	Forked from HPPC, holding int index and int value.
IntDoubleHashMap	A hash map of `int` to `double`, implemented using open addressing with linear probing for collision resolution.
IntDoubleHashMap.IntDoubleCursor	Forked from HPPC, holding int index,key and value
IntField	Field that stores a per-document `int` value for scoring, sorting or value retrieval and index the field for fast range filters.
IntFloatHashMap	A hash map of `int` to `float`, implemented using open addressing with linear probing for collision resolution.
IntFloatHashMap.IntFloatCursor	Forked from HPPC, holding int index,key and value
IntHashSet	A hash set of `int`s, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap	A hash map of `int` to `int`, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap.IntIntCursor	Forked from HPPC, holding int index,key and value
IntObjectHashMap<VType>	A hash map of `int` to `Object`, implemented using open addressing with linear probing for collision resolution.
IntObjectHashMap.IntObjectCursor<VType>	Forked from HPPC, holding int index,key and value
IntPoint	An indexed `int` field for fast range filters.
IntRange	An indexed Integer Range field.
IntRangeDocValuesField	DocValues field for IntRange.
IntroSelector	Adaptive selection algorithm based on the introspective quick select algorithm.
IntroSorter	`Sorter` implementation based on a variant of the quicksort algorithm called introsort: when the recursion level exceeds the log of the length of the array to sort, it falls back to heapsort.
IntSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of ints.
IntsRef	Represents int[], as a slice (offset + length) into an existing int[].
IntsRefBuilder	A builder for `IntsRef` instances.
IntsRefFSTEnum<T>	Enumerates all input (IntsRef) + output pairs in an FST.
IntsRefFSTEnum.InputOutput<T>	Holds a single input (IntsRef) + output pair.
IntToIntFunction	Native int to int function
InvertableType	Describes how an `IndexableField` should be inverted for indexing terms and postings.
IOConsumer<T>	An IO operation with a single input that may throw an IOException.
IOContext	IOContext holds additional details on the merge/search context.
IOContext.Context	Context is a enumerator which specifies the context in which the Directory is being used for.
IOFunction<T,R>	A Function that may throw an IOException
IORunnable	A Runnable that may throw an IOException
IOSupplier<T>	This is a result supplier that is allowed to throw an IOException.
IOUtils	Utilities for dealing with `Closeable`s.
IOUtils.IOConsumer<T>	Deprecated, for removal: This API element is subject to removal in a future version. was replaced by `IOConsumer`.
IOUtils.IOFunction<T,R>	Deprecated, for removal: This API element is subject to removal in a future version. was replaced by `IOFunction`.
JavaLoggingInfoStream	InfoStream implementation that logs every message using Java Utils Logging (JUL) with the supplied log level.
KeepOnlyLastCommitDeletionPolicy	This `IndexDeletionPolicy` implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done.
KeywordAttribute	This attribute can be used to mark a token as a keyword.
KeywordAttributeImpl	Default implementation of `KeywordAttribute`.
KeywordField	Field that indexes a per-document String or `BytesRef` into an inverted index for fast filtering, stores values in a columnar fashion using `DocValuesType.SORTED_SET` doc values for sorting and faceting, and optionally stores values as stored fields for top-hits retrieval.
KnnByteVectorField	A field that contains a single byte numeric vector (or none) for each document.
KnnByteVectorQuery	Uses `KnnVectorsReader.search(String, byte[], KnnCollector, Bits)` to perform nearest neighbour search.
KnnCollector	KnnCollector is a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
KnnCollectorManager	KnnCollectorManager responsible for creating `KnnCollector` instances.
KnnFieldVectorsWriter<T>	Vectors' writer for a field
KnnFloatVectorField	A field that contains a single floating-point numeric vector (or none) for each document.
KnnFloatVectorQuery	Uses `KnnVectorsReader.search(String, float[], KnnCollector, Bits)` to perform nearest neighbour search.
KnnVectorField	Deprecated. use `KnnFloatVectorField` instead
KnnVectorFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
KnnVectorQuery	Deprecated. use `KnnFloatVectorQuery` instead
KnnVectorsFormat	Encodes/decodes per-document vector and any associated indexing structures required to support nearest-neighbor search
KnnVectorsReader	Reads vectors from an index.
KnnVectorsWriter	Writes vectors to an index.
KnnVectorsWriter.MergedVectorValues	View over multiple vector values supporting iterator-style access via DocIdMerger.
Lambda	The lambda (λ_w) parameter in information-based models.
LambdaDF	Computes lambda as `docFreq+1 / numberOfDocuments+1`.
LambdaTTF	Computes lambda as `totalTermFreq+1 / numberOfDocuments+1`.
LatLonDocValuesField	An per-document location field.
LatLonGeometry	Lat/Lon Geometry object.
LatLonPoint	An indexed location field.
LatLonShape	An geo shape utility class for indexing and searching gis geometries whose vertices are latitude, longitude values (in decimal degrees).
LatLonShapeDocValues	A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `LatLonShape` geometries in a `LatLonShapeDocValuesField`
LatLonShapeDocValuesField	Concrete implementation of a `ShapeDocValuesField` for geographic geometries.
LeafCollector	Collector decouples the score from the collected doc: the score computation is skipped entirely if it's not needed.
LeafFieldComparator	Expert: comparator that gets instantiated on each leaf from a top-level `FieldComparator` instance.
LeafMetaData	Provides read-only metadata about a leaf.
LeafReader	`LeafReader` is an abstract class, providing an interface for accessing an index.
LeafReaderContext	`IndexReaderContext` for `LeafReader` instances.
LeafSimScorer	`Similarity.SimScorer` on a specific `LeafReader`.
LevenshteinAutomata	Class to construct DFAs that match a word within some edit distance.
LimitedFiniteStringsIterator	`FiniteStringsIterator` which limits the number of iterated accepted strings.
Line	Represents a line on the earth's surface.
LiveDocsFormat	Format for live/deleted documents
LiveFieldValues<S,T>	Tracks live field values across NRT reader reopens.
LiveIndexWriterConfig	Holds all the configuration used by `IndexWriter` with few setters for settings that can be changed on an `IndexWriter` instance "live".
LMDirichletSimilarity	Bayesian smoothing using Dirichlet priors.
LMJelinekMercerSimilarity	Language model based on the Jelinek-Mercer smoothing method.
LMSimilarity	Abstract superclass for language modeling Similarities.
LMSimilarity.CollectionModel	A strategy for computing the collection language model.
LMSimilarity.DefaultCollectionModel	Models `p(w\|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
LMSimilarity.LMStats	Stores the collection distribution of the current term.
Lock	An interprocess mutex lock.
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 and releases a lock using a specific `LockFactory`.
LockValidatingDirectoryWrapper	This class makes a best-effort check that a provided `Lock` is valid before any destructive filesystem operation.
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.
LongArrayList	An array-backed list of `long`.
LongBitSet	BitSet of fixed length (numBits), backed by accessible (`LongBitSet.getBits()`) long[], accessed with a long index.
LongComparator	Comparator based on `Long.compare(long, long)` for `numHits`.
LongCursor	Forked from HPPC, holding int index and long value.
LongField	Field that stores a per-document `long` value for scoring, sorting or value retrieval and index the field for fast range filters.
LongFloatHashMap	A hash map of `long` to `float`, implemented using open addressing with linear probing for collision resolution.
LongFloatHashMap.LongFloatCursor	Forked from HPPC, holding int index,key and value
LongHashSet	A hash set of `long`s, implemented using open addressing with linear probing for collision resolution.
LongHeap	A min heap that stores longs; a primitive priority queue that like all priority queues maintains a partial ordering of its elements such that the least element can always be found in constant time.
LongIntHashMap	A hash map of `long` to `int`, implemented using open addressing with linear probing for collision resolution.
LongIntHashMap.LongIntCursor	Forked from HPPC, holding int index,key and value
LongObjectHashMap<VType>	A hash map of `long` to `Object`, implemented using open addressing with linear probing for collision resolution.
LongObjectHashMap.LongObjectCursor<VType>	Forked from HPPC, holding int index,key and value
LongPoint	An indexed `long` field for fast range filters.
LongRange	An indexed Long Range field.
LongRangeDocValuesField	DocValues field for LongRange.
LongsRef	Represents long[], as a slice (offset + length) into an existing long[].
LongValues	Per-segment, per-document long values, which can be calculated at search-time
LongValues	Abstraction over an array of longs.
LongValuesSource	Base class for producing `LongValues`
LongValuesSource.ConstantLongValuesSource	A ConstantLongValuesSource that always returns a constant value
LowercaseAsciiCompression	Utility class that can efficiently compress arrays that mostly contain characters in the [0x1F,0x3F) or [0x5F,0x7F) ranges, which notably include all digits, lowercase characters, '.', '-' and '_'.
LowerCaseFilter	Normalizes token text to lower case.
LRUQueryCache	A `QueryCache` that evicts queries using a LRU (least-recently-used) eviction policy in order to remain under a given maximum size and number of bytes used.
LRUQueryCache.CacheAndCount	Cache of doc ids with a count.
LSBRadixSorter	A LSB Radix sorter for unsigned int values.
Lucene90BlockTreeTermsReader	A block-based terms index and dictionary that assigns terms to variable length blocks according to how they share prefixes.
Lucene90BlockTreeTermsWriter	Block-based terms index and dictionary writer.
Lucene90CompoundFormat	Lucene 9.0 compound file format
Lucene90CompressingStoredFieldsFormat	A `StoredFieldsFormat` that compresses documents in chunks in order to improve the compression ratio.
Lucene90CompressingStoredFieldsReader	`StoredFieldsReader` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingStoredFieldsWriter	`StoredFieldsWriter` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingTermVectorsFormat	A `TermVectorsFormat` that compresses chunks of documents together in order to improve the compression ratio.
Lucene90CompressingTermVectorsReader	`TermVectorsReader` for `Lucene90CompressingTermVectorsFormat`.
Lucene90CompressingTermVectorsWriter	`TermVectorsWriter` for `Lucene90CompressingTermVectorsFormat`.
Lucene90DocValuesFormat	Lucene 9.0 DocValues format.
Lucene90LiveDocsFormat	Lucene 9.0 live docs format
Lucene90NormsFormat	Lucene 9.0 Score normalization format.
Lucene90PointsFormat	Lucene 9.0 point format, which encodes dimensional values in a block KD-tree structure for fast 1D range and N dimensional shape intersection filtering.
Lucene90PointsReader	Reads point values previously written with `Lucene90PointsWriter`
Lucene90PointsWriter	Writes dimensional values
Lucene90StoredFieldsFormat	Lucene 9.0 stored fields format.
Lucene90StoredFieldsFormat.Mode	Configuration option for stored fields.
Lucene90TermVectorsFormat	Lucene 9.0 `term vectors format`.
Lucene94FieldInfosFormat	Lucene 9.0 Field Infos format.
Lucene99Codec	Implements the Lucene 9.9 index format
Lucene99Codec.Mode	Configuration option for the codec.
Lucene99FlatVectorsFormat	Lucene 9.9 flat vector format, which encodes numeric vector values
Lucene99FlatVectorsReader	Reads vectors from the index segments.
Lucene99FlatVectorsWriter	Writes vector values to index segments.
Lucene99HnswScalarQuantizedVectorsFormat	Lucene 9.9 vector format, which encodes numeric vector values into an associated graph connecting the documents having values.
Lucene99HnswVectorsFormat	Lucene 9.9 vector format, which encodes numeric vector values into an associated graph connecting the documents having values.
Lucene99HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene99HnswVectorsWriter	Writes vector values and knn graphs to index segments.
Lucene99PostingsFormat	Lucene 9.9 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene99PostingsFormat.IntBlockTermState	Holds all state required for `Lucene99PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene99PostingsReader	Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene99PostingsWriter	Concrete class that writes docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene99ScalarQuantizedVectorScorer	Optimized scalar quantized implementation of `FlatVectorsScorer` for quantized vectors stored in the Lucene99 format.
Lucene99ScalarQuantizedVectorsFormat	Format supporting vector quantization, storage, and retrieval
Lucene99ScalarQuantizedVectorsReader	Reads Scalar Quantized vectors from the index segments along with index data structures.
Lucene99ScalarQuantizedVectorsWriter	Writes quantized vector values and metadata to index segments.
Lucene99SegmentInfoFormat	Lucene 9.9 Segment info format.
Lucene99SkipReader	Implements the skip list reader for block postings format that stores positions and payloads.
Lucene99SkipWriter	Write skip lists with multiple levels, and support skip within block ints.
LZ4	LZ4 compression and decompression routines.
LZ4.FastCompressionHashTable	Simple lossy `LZ4.HashTable` that only stores the last ocurrence for each hash on `2^14` bytes of memory.
LZ4.HighCompressionHashTable	A higher-precision `LZ4.HashTable`.
LZ4WithPresetDictCompressionMode	A compression mode that compromises on the compression ratio to provide fast compression and decompression.
MapOfSets<K,V>	Helper class for keeping Lists of Objects associated with keys.
MappedMultiFields	A `Fields` implementation that merges multiple Fields into one, and maps around deleted documents.
MatchAllDocsQuery	A query that matches all documents.
Matches	Reports the positions and optionally offsets of all matching terms in a query for a single document
MatchesIterator	An iterator over match positions (and optionally offsets) for a single document and field
MatchesUtils	Contains static functions that aid the implementation of `Matches` and `MatchesIterator` interfaces.
MatchingReaders	Computes which segments have identical field name to number mappings, which allows stored fields and term vectors in this codec to be bulk-merged.
MatchNoDocsQuery	A query that matches no documents.
MathUtil	Math static utility methods.
MaxNonCompetitiveBoostAttribute	Add this `Attribute` to a fresh `AttributeSource` before calling `MultiTermQuery.getTermsEnum(Terms,AttributeSource)`.
MaxNonCompetitiveBoostAttributeImpl	Implementation class for `MaxNonCompetitiveBoostAttribute`.
MaxScoreCache	Compute maximum scores based on `Impacts` and keep them in a cache in order not to run expensive similarity score computations multiple times on the same data.
MergedIterator<T extends Comparable<T>>	Provides a merged sorted view from several sorted iterators.
MergeInfo	A MergeInfo provides information required for a MERGE context.
MergePolicy	Expert: a MergePolicy determines the sequence of primitive merge operations.
MergePolicy.MergeAbortedException	Thrown when a merge was explicitly aborted because `IndexWriter.abortMerges()` was called.
MergePolicy.MergeContext	This interface represents the current context of the merge selection process.
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.
MergePolicy.OneMergeProgress	Progress and state for an executing merge.
MergePolicy.OneMergeProgress.PauseReason	Reason for pausing the merge thread.
MergeRateLimiter	This is the `RateLimiter` that `IndexWriter` assigns to each running merge, to give `MergeScheduler`s ionice like control.
MergeScheduler	Expert: `IndexWriter` uses an instance implementing this interface to execute the merges selected by a `MergePolicy`.
MergeScheduler.MergeSource	Provides access to new merges and executes the actual merge
MergeState	Holds common state used during segment merging.
MergeState.DocMap	A map of doc IDs.
MergeTrigger	MergeTrigger is passed to `MergePolicy.findMerges(MergeTrigger, SegmentInfos, MergePolicy.MergeContext)` to indicate the event that triggered the merge.
MinDocIterator	Docs iterator that starts iterating from a configurable minimum document
MinimizationOperations	Operations for minimizing automata.
MMapDirectory	File-based `Directory` implementation that uses mmap for reading, and `FSDirectory.FSIndexOutput` for writing.
ModuleResourceLoader	Simple `ResourceLoader` that uses `Module.getResourceAsStream(String)` and `Class.forName(Module,String)` to open resources and classes, respectively.
MonotonicBlockPackedReader	Provides random access to a stream written with `MonotonicBlockPackedWriter`.
MonotonicBlockPackedWriter	A writer for large monotonically increasing sequences of positive longs.
MSBRadixSorter	Radix sorter for variable-length strings.
MultiBits	Concatenates multiple Bits together, on every lookup.
MultiCollector	A `Collector` which allows running a search with several `Collector`s.
MultiCollectorManager	A `CollectorManager` implements which wrap a set of `CollectorManager` as `MultiCollector` acts for `Collector`.
MultiDocValues	A wrapper for CompositeIndexReader providing access to DocValues.
MultiDocValues.MultiSortedDocValues	Implements SortedDocValues over n subs, using an OrdinalMap
MultiDocValues.MultiSortedSetDocValues	Implements MultiSortedSetDocValues over n subs, using an OrdinalMap
MultiFields	Provides a single `Fields` term index view over an `IndexReader`.
MultiLeafKnnCollector	MultiLeafKnnCollector is a specific KnnCollector that can exchange the top collected results across segments through a shared global queue.
MultiLeafReader	Utility methods for working with a `IndexReader` as if it were a `LeafReader`.
MultiLevelSkipListReader	This abstract class reads skip lists with multiple levels.
MultiLevelSkipListWriter	This abstract class writes skip lists with multiple levels.
MultiPhraseQuery	A generalized version of `PhraseQuery`, with the possibility of adding more than one term at the same position that are treated as a disjunction (OR).
MultiPhraseQuery.Builder	A builder for multi-phrase queries
MultiPhraseQuery.UnionFullPostingsEnum	Slower version of UnionPostingsEnum that delegates offsets and positions, for use by MatchesIterator
MultiPhraseQuery.UnionPostingsEnum	Takes the logical union of multiple PostingsEnum iterators.
MultiPostingsEnum	Exposes `PostingsEnum`, merged from `PostingsEnum` API of sub-segments.
MultiPostingsEnum.EnumWithSlice	Holds a `PostingsEnum` along with the corresponding `ReaderSlice`.
MultiReader	A `CompositeReader` which reads multiple indexes, appending their content.
Multiset<T>	A `Multiset` is a set that allows for duplicate elements.
MultiSimilarity	Implements the CombSUM method for combining evidence from multiple similarity values described in: Joseph A.
MultiTermQuery	An abstract `Query` that matches documents containing a subset of terms provided by a `FilteredTermsEnum` enumeration.
MultiTermQuery.RewriteMethod	Abstract class that defines how the query is rewritten.
MultiTermQuery.TopTermsBlendedFreqScoringRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, but adjusts the frequencies used for scoring to be blended across the terms, otherwise the rarest term typically ranks highest (often not useful eg in the set of expanded terms in a FuzzyQuery).
MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, but the scores are only computed as the boost.
MultiTermQuery.TopTermsScoringBooleanQueryRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, and keeps the scores as computed by the query.
MultiTerms	Exposes flex API, merged from flex API of sub-segments.
MultiTermsEnum	Exposes `TermsEnum` API, merged from `TermsEnum` API of sub-segments.
MutablePointTree	One leaf `PointValues.PointTree` whose order of points can be changed.
MutablePointTreeReaderUtils	Utility APIs for sorting and partitioning buffered points.
MutableValue	Base class for all mutable values.
MutableValueBool	`MutableValue` implementation of type `boolean`.
MutableValueDate	`MutableValue` implementation of type `Date`.
MutableValueDouble	`MutableValue` implementation of type `double`.
MutableValueFloat	`MutableValue` implementation of type `float`.
MutableValueInt	`MutableValue` implementation of type `int`.
MutableValueLong	`MutableValue` implementation of type `long`.
MutableValueStr	`MutableValue` implementation of type `String`.
NamedMatches	Utility class to help extract the set of sub queries that have matched from a larger query.
NamedSPILoader<S extends NamedSPILoader.NamedSPI>	Helper class for loading named SPIs from classpath (e.g.
NamedSPILoader.NamedSPI	Interface to support `NamedSPILoader.lookup(String)` by name.
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.
NeighborArray	NeighborArray encodes the neighbors of a node and their mutual scores in the HNSW graph as a pair of growable arrays.
NeighborQueue	NeighborQueue uses a `LongHeap` to store lists of arcs in an HNSW graph, represented as a neighbor node id with an associated score packed together as a sortable long, which is sorted primarily by score.
NGramPhraseQuery	This is a `PhraseQuery` which is optimized for n-gram phrase query.
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.
NoDeletionPolicy	An `IndexDeletionPolicy` which keeps all index commits around, never deleting them.
NoLockFactory	Use this `LockFactory` to disable locking entirely.
NoMergePolicy	A `MergePolicy` which never returns merges to execute.
NoMergeScheduler	A `MergeScheduler` which never executes any merges.
NoOutputs	A null FST `Outputs` implementation; use this if you just want to build an FSA.
Normalization	This class acts as the base class for the implementations of the term frequency normalization methods in the DFR framework.
Normalization.NoNormalization	Implementation used when there is no normalization.
NormalizationH1	Normalization model that assumes a uniform distribution of the term frequency.
NormalizationH2	Normalization model in which the term frequency is inversely related to the length.
NormalizationH3	Dirichlet Priors normalization
NormalizationZ	Pareto-Zipf Normalization
NormsConsumer	Abstract API that consumes normalization values.
NormsFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
NormsFormat	Encodes/decodes per-document score normalization values.
NormsProducer	Abstract API that produces field normalization values
NotDocIdSet	This `DocIdSet` encodes the negation of another `DocIdSet`.
NRTCachingDirectory	Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.
NumericComparator<T extends Number>	Abstract numeric comparator for comparing numeric values.
NumericDocValues	A per-document numeric value.
NumericDocValuesField	Field that stores a per-document `long` value for scoring, sorting or value retrieval.
NumericUtils	Helper APIs to encode numeric values as sortable bytes and vice-versa.
ObjectCursor<VType>	Forked from HPPC, holding int index and Object value.
OffHeapByteVectorValues	Read the vector values from the index input.
OffHeapByteVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OffHeapFloatVectorValues	Read the vector values from the index input.
OffHeapFloatVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OffHeapFSTStore	Provides off heap storage of finite state machine (FST), using underlying index input instead of byte store on heap
OffHeapQuantizedByteVectorValues	Read the quantized vector values and their score correction values from the index input.
OffHeapQuantizedByteVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OfflinePointReader	Reads points from disk in a fixed-with format, previously written with `OfflinePointWriter`.
OfflinePointWriter	Writes points to disk in a fixed-with format.
OfflineSorter	On-disk sorting of byte arrays.
OfflineSorter.BufferSize	A bit more descriptive unit for constructors.
OfflineSorter.ByteSequencesReader	Utility class to read length-prefixed byte[] entries from an input.
OfflineSorter.ByteSequencesWriter	Utility class to emit length-prefixed byte[] entries to an output stream for sorting.
OffsetAttribute	The start and end character offset of a Token.
OffsetAttributeImpl	Default implementation of `OffsetAttribute`.
OneMergeWrappingMergePolicy	A wrapping merge policy that wraps the `MergePolicy.OneMerge` objects returned by the wrapped merge policy.
OnHeapFSTStore	Provides storage of finite state machine (FST), using byte array or byte store allocated on heap.
OnHeapHnswGraph	An `HnswGraph` where all nodes and connections are held in memory.
Operations	Automata operations.
OrdinalMap	Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.
OrdinalTranslatedKnnCollector	Wraps a provided KnnCollector object, translating the provided vectorId ordinal to a documentId
OrdTermState	An ordinal based `TermState`
OrdToDocDISIReaderConfiguration	Configuration for `DirectMonotonicReader` and `IndexedDISI` for reading sparse vectors.
Outputs<T>	Represents the outputs for an FST, providing the basic algebra required for building and traversing the FST.
OutputStreamDataOutput	A `DataOutput` wrapping a plain `OutputStream`.
OutputStreamIndexOutput	Implementation class for buffered `IndexOutput` that writes to an `OutputStream`.
PackedDataInput	A `DataInput` wrapper to read unaligned, variable-length packed integers.
PackedDataOutput	A `DataOutput` wrapper to write unaligned, variable-length packed integers.
PackedInts	Simplistic compression for array of unsigned long values.
PackedInts.Decoder	A decoder for packed integers.
PackedInts.Encoder	An encoder for packed integers.
PackedInts.Format	A format to write packed ints.
PackedInts.FormatAndBits	Simple class that holds a format and a number of bits per value.
PackedInts.Mutable	A packed integer array that can be modified.
PackedInts.NullReader	A `PackedInts.Reader` which has all its values equal to 0 (bitsPerValue = 0).
PackedInts.Reader	A read-only random access array of positive integers.
PackedInts.ReaderIterator	Run-once iterator interface, to decode previously saved PackedInts.
PackedInts.Writer	A write-once Writer.
PackedLongValues	Utility class to compress integers into a `LongValues` instance.
PackedLongValues.Builder	A Builder for a `PackedLongValues` instance.
PackedTokenAttributeImpl	Default implementation of the common attributes used by Lucene: `CharTermAttribute` `TypeAttribute` `PositionIncrementAttribute` `PositionLengthAttribute` `OffsetAttribute` `TermFrequencyAttribute`
PagedBytes	Represents a logical byte[] as a series of pages.
PagedBytes.Reader	Provides methods to read BytesRefs from a frozen PagedBytes.
PagedGrowableWriter	A `PagedGrowableWriter`.
PagedMutable	A `PagedMutable`.
PairOutputs<A,B>	An FST `Outputs` implementation, holding two other outputs.
PairOutputs.Pair<A,B>	Holds a single pair of two outputs.
ParallelCompositeReader	An `CompositeReader` which reads multiple, parallel indexes.
ParallelLeafReader	An `LeafReader` which reads multiple, parallel indexes.
PayloadAttribute	The payload of a Token.
PayloadAttributeImpl	Default implementation of `PayloadAttribute`.
PerFieldDocValuesFormat	Enables per field docvalues support.
PerFieldKnnVectorsFormat	Enables per field numeric vector support.
PerFieldKnnVectorsFormat.FieldsReader	VectorReader that can wrap multiple delegate readers, selected by field.
PerFieldPostingsFormat	Enables per field postings support.
PerFieldSimilarityWrapper	Provides the ability to use a different `Similarity` for different fields.
PersistentSnapshotDeletionPolicy	A `SnapshotDeletionPolicy` which adds a persistence layer so that snapshots can be maintained across the life of an application.
PhraseMatcher	Base class for exact and sloppy phrase matching
PhraseQuery	A Query that matches documents containing a particular sequence of terms.
PhraseQuery.Builder	A builder for phrase queries.
PhraseQuery.PostingsAndFreq	Term postings and position information for phrase matching
PhraseWeight	Expert: Weight class for phrase matching
Point	Represents a point on the earth's surface.
PointInSetQuery	Abstract query class to find all documents whose single or multi-dimensional point values, previously indexed with e.g.
PointInSetQuery.Stream	Iterator of encoded point values.
PointRangeQuery	Abstract class for range queries against single or multidimensional points such as `IntPoint`.
PointReader	One pass iterator through all points previously written with a `PointWriter`, abstracting away whether points are read from (offline) disk or simple arrays in heap.
PointsFormat	Encodes/decodes indexed points.
PointsReader	Abstract API to visit point values.
PointsWriter	Abstract API to write points
PointValue	Represents a dimensional point value written in the BKD tree.
PointValues	Access to indexed numeric values.
PointValues.IntersectVisitor	We recurse the `PointValues.PointTree`, using a provided instance of this to guide the recursion.
PointValues.PointTree	Basic operations to read the KD-tree.
PointValues.Relation	Used by `PointValues.intersect(org.apache.lucene.index.PointValues.IntersectVisitor)` to check how each recursive cell corresponds to the query.
PointWriter	Appends many points, and then at the end provides a `PointReader` to iterate those points.
Polygon	Represents a closed polygon on the earth's surface.
PositionIncrementAttribute	Determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching.
PositionIncrementAttributeImpl	Default implementation of `PositionIncrementAttribute`.
PositionLengthAttribute	Determines how many positions this token spans.
PositionLengthAttributeImpl	Default implementation of `PositionLengthAttribute`.
PositiveIntOutputs	An FST `Outputs` implementation where each output is a non-negative long value.
PositiveScoresOnlyCollector	A `Collector` implementation which wraps another `Collector` and makes sure only documents with scores > 0 are collected.
PostingsEnum	Iterates through the postings.
PostingsFormat	Encodes/decodes terms, postings, and proximity data.
PostingsReaderBase	The core terms dictionaries (BlockTermsReader, BlockTreeTermsReader) interact with a single instance of this class to manage creation of `PostingsEnum` and `PostingsEnum` instances.
PostingsWriterBase	Class that plugs into term dictionaries, such as `Lucene90BlockTreeTermsWriter`, and handles writing postings.
PrefixCodedTerms	Prefix codes term instances (prefixes are shared).
PrefixCodedTerms.Builder	Builds a PrefixCodedTerms: call add repeatedly, then finish.
PrefixCodedTerms.TermIterator	An iterator over the list of terms stored in a `PrefixCodedTerms`.
PrefixQuery	A Query that matches documents containing terms with a specified prefix.
PrintStreamInfoStream	InfoStream implementation over a `PrintStream` such as `System.out`.
PriorityQueue<T>	A priority queue maintains a partial ordering of its elements such that the least element can always be found in constant time.
Pruning	Controls `LeafFieldComparator` how to skip documents
PushPostingsWriterBase	Extension of `PostingsWriterBase`, adding a push API for writing each element of the postings.
QuantizedByteVectorValues	A version of `ByteVectorValues`, but additionally retrieving score correction offset for Scalar quantization scores.
QuantizedVectorsReader	Quantized vector reader
Query	The abstract base class for queries.
QueryBuilder	Creates queries from the `Analyzer` chain.
QueryBuilder.TermAndBoost	Wraps a term and boost
QueryCache	A cache for queries.
QueryCachingPolicy	A policy defining which filters should be cached.
QueryRescorer	A `Rescorer` that uses a provided Query to assign scores to the first-pass hits.
QueryTimeout	Query timeout abstraction that controls whether a query should continue or be stopped.
QueryTimeoutImpl	An implementation of `QueryTimeout` that can be used by the `ExitableDirectoryReader` class to time out and exit out when a query takes a long time to rewrite.
QueryVisitor	Allows recursion through a query tree
RadixSelector	Radix selector.
RamUsageEstimator	Estimates the size (memory representation) of Java objects.
RandomAccessInput	Random Access Index API.
RandomAccessQuantizedByteVectorValues	Random access values for `byte[]`, but also includes accessing the score correction constant for the current vector in the buffer.
RandomAccessVectorValues	Provides random access to vectors by dense ordinal.
RandomAccessVectorValues.Bytes	Byte vector values.
RandomAccessVectorValues.Floats	Float vector values.
RandomVectorScorer	A `RandomVectorScorer` for scoring random nodes in batches against an abstract query.
RandomVectorScorer.AbstractRandomVectorScorer	Creates a default scorer for random access vectors.
RandomVectorScorerSupplier	A supplier that creates `RandomVectorScorer` from an ordinal.
RangeFieldQuery	Query class for searching `RangeField` types by a defined `PointValues.Relation`.
RangeFieldQuery.QueryType	Used by `RangeFieldQuery` to check how each internal or leaf node relates to the query.
RateLimitedIndexOutput	A `rate limiting` `IndexOutput`
RateLimiter	Abstract base class to rate limit IO.
RateLimiter.SimpleRateLimiter	Simple class to rate limit IO.
ReaderManager	Utility class to safely share `DirectoryReader` instances across multiple threads, while periodically reopening.
ReaderSlice	Subreader slice from a parent composite reader.
ReaderUtil	Common util methods for dealing with `IndexReader`s and `IndexReaderContext`s.
Rectangle	Represents a lat/lon rectangle.
RecyclingByteBlockAllocator	A `ByteBlockPool.Allocator` implementation that recycles unused byte blocks in a buffer and reuses them in subsequent calls to `RecyclingByteBlockAllocator.getByteBlock()`.
RecyclingIntBlockAllocator	A `IntBlockPool.Allocator` implementation that recycles unused int blocks in a buffer and reuses them in subsequent calls to `RecyclingIntBlockAllocator.getIntBlock()`.
RefCount<T>	Manages reference counting for a given object.
ReferenceManager<G>	Utility class to safely share instances of a certain type across multiple threads, while periodically refreshing them.
ReferenceManager.RefreshListener	Use to receive notification when a refresh has finished.
RegExp	Regular Expression extension to `Automaton`.
RegExp.Kind	The type of expression represented by a RegExp node.
RegexpQuery	A fast regular expression query based on the `org.apache.lucene.util.automaton` package.
Rescorer	Re-scores the topN results (`TopDocs`) from an original query.
ResourceLoader	Abstraction for loading resources (streams, files, and classes).
ResourceLoaderAware	Interface for a component that needs to be initialized by an implementation of `ResourceLoader`.
RoaringDocIdSet	`DocIdSet` implementation inspired from http://roaringbitmap.org/
RoaringDocIdSet.Builder	A builder of `RoaringDocIdSet`s.
RollingBuffer<T extends RollingBuffer.Resettable>	Acts like forever growing T[], but internally uses a circular buffer to reuse instances of T.
RollingBuffer.Resettable	Implement to reset an instance
RunAutomaton	Finite-state automaton with fast run operation.
SameThreadExecutorService	An `ExecutorService` that executes tasks immediately in the calling thread during submit.
ScalarQuantizedVectorScorer	Default scalar quantized implementation of `FlatVectorsScorer`.
ScalarQuantizedVectorScorer.ScalarQuantizedRandomVectorScorerSupplier	Quantized vector scorer supplier
ScalarQuantizedVectorSimilarity	Calculates and adjust the scores correctly for quantized vectors given the scalar quantization parameters
ScalarQuantizedVectorSimilarity.ByteVectorComparator	Compares two byte vectors
ScalarQuantizedVectorSimilarity.DotProduct	Calculates dot product on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.Euclidean	Calculates euclidean distance on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.MaximumInnerProduct	Calculates max inner product on quantized vectors, applying the appropriate corrections
ScalarQuantizer	Will scalar quantize float vectors into `int8` byte values.
Scorable	Allows access to the score of a Query
Scorable.ChildScorable	A child Scorer and its relationship to its parent.
ScoreCachingWrappingScorer	A `Scorer` which wraps another scorer and caches the score of the current document.
ScoreDoc	Holds one hit in `TopDocs`.
ScoreMode	Different modes of search.
Scorer	Expert: Common scoring functionality for different types of queries.
ScorerSupplier	A supplier of `Scorer`.
ScoringRewrite<B>	Base rewrite method that translates each term into a query, and keeps the scores as computed by the query.
SearcherFactory	Factory class used by `SearcherManager` to create new IndexSearchers.
SearcherLifetimeManager	Keeps track of current plus old IndexSearchers, closing the old ones once they have timed out.
SearcherLifetimeManager.PruneByAge	Simple pruner that drops any searcher older by more than the specified seconds, than the newest searcher.
SearcherLifetimeManager.Pruner	See `SearcherLifetimeManager.prune(org.apache.lucene.search.SearcherLifetimeManager.Pruner)`.
SearcherManager	Utility class to safely share `IndexSearcher` instances across multiple threads, while periodically reopening.
SegmentCacheable	Interface defining whether or not an object can be cached against a `LeafReader`
SegmentCommitInfo	Embeds a [read-only] SegmentInfo and adds per-commit fields.
SegmentInfo	Information about a segment such as its name, directory, and files related to the segment.
SegmentInfoFormat	Expert: Controls the format of the `SegmentInfo` (segment metadata file).
SegmentInfos	A collection of segmentInfo objects with methods for operating on those segments in relation to the file system.
SegmentInfos.FindSegmentsFile<T>	Utility class for executing code that needs to do something with the current segments file.
SegmentReader	IndexReader implementation over a single segment.
SegmentReaderAccess	Access to `SegmentReader` internals exposed to the test framework.
SegmentReadState	Holder class for common parameters used during read.
SegmentWriteState	Holder class for common parameters used during write.
Selector	An implementation of a selection algorithm, ie.
SentenceAttribute	This attribute tracks what sentence a given token belongs to as well as potentially other sentence specific attributes.
SentenceAttributeImpl	Default implementation of `SentenceAttribute`.
SentinelIntSet	A native int hash-based set where one value is reserved to mean "EMPTY" internally.
SerialMergeScheduler	A `MergeScheduler` that simply does each merge sequentially, using the current thread.
SetOnce<T>	A convenient class which offers a semi-immutable object wrapper implementation which allows one to set the value of an object exactly once, and retrieve it many times.
SetOnce.AlreadySetException	Thrown when `SetOnce.set(Object)` is called more than once.
ShapeDocValuesField	A doc values field for `LatLonShape` and `XYShape` that uses `ShapeDocValues` as the underlying binary doc value format.
ShapeField	A base shape utility class used for both LatLon (spherical) and XY (cartesian) shape fields.
ShapeField.DecodedTriangle	Represents a encoded triangle using `ShapeField.decodeTriangle(byte[], DecodedTriangle)`.
ShapeField.DecodedTriangle.TYPE	type of triangle
ShapeField.QueryRelation	Query Relation Types *
ShapeField.Triangle	polygons are decomposed into tessellated triangles using `Tessellator` these triangles are encoded and inserted as separate indexed POINT fields
Similarity	Similarity defines the components of Lucene scoring.
Similarity.SimScorer	Stores the weight for a query across the indexed collection.
SimilarityBase	A subclass of `Similarity` that provides a simplified API for its descendants.
SimpleCollector	Base `Collector` implementation that is used to collect all contexts.
SimpleFieldComparator<T>	Base `FieldComparator` implementation that is used for all contexts.
SimpleFSLockFactory	Implements `LockFactory` using `Files.createFile(java.nio.file.Path, java.nio.file.attribute.FileAttribute<?>...)`.
SimpleMergedSegmentWarmer	A very simple merged segment warmer that just ensures data structures are initialized.
SimpleWKTShapeParser	Parses shape geometry represented in WKT format
SimpleWKTShapeParser.ShapeType	Enumerated type for Shapes
SingleInstanceLockFactory	Implements `LockFactory` for a single in-process instance, meaning all locking will take place through this one instance.
SingleTermsEnum	Subclass of FilteredTermsEnum for enumerating a single term.
SleepingLockWrapper	Directory that wraps another, and that sleeps and retries if obtaining the lock fails.
SloppyMath	Math functions that trade off accuracy for speed.
SloppyPhraseMatcher	Find all slop-valid position-combinations (matches) encountered while traversing/hopping the PhrasePositions.
SlowCodecReaderWrapper	Wraps arbitrary readers for merging.
SlowImpactsEnum	`ImpactsEnum` that doesn't index impacts but implements the API in a legal way.
SmallFloat	Floating point numbers smaller than 32 bits.
SnapshotDeletionPolicy	An `IndexDeletionPolicy` that wraps any other `IndexDeletionPolicy` and adds the ability to hold and later release snapshots of an index.
SoftDeletesDirectoryReaderWrapper	This reader filters out documents that have a doc values value in the given field and treat these documents as soft deleted.
SoftDeletesRetentionMergePolicy	This `MergePolicy` allows to carry over soft deleted documents across merges.
Sort	Encapsulates sort criteria for returned hits.
SortedDocValues	A per-document byte[] with presorted values.
SortedDocValuesField	Field that stores a per-document `BytesRef` value, indexed for sorting.
SortedNumericDocValues	A list of per-document numeric values, sorted according to `Long.compare(long, long)`.
SortedNumericDocValuesField	Field that stores a per-document `long` values for scoring, sorting or value retrieval.
SortedNumericSelector	Selects a value from the document's list to use as the representative value
SortedNumericSelector.Type	Type of selection to perform.
SortedNumericSortField	SortField for `SortedNumericDocValues`.
SortedNumericSortField.Provider	A SortFieldProvider for this sort field
SortedSetDocValues	A multi-valued version of `SortedDocValues`.
SortedSetDocValuesField	Field that stores a set of per-document `BytesRef` values, indexed for faceting,grouping,joining.
SortedSetSelector	Selects a value from the document's set to use as the representative value
SortedSetSelector.Type	Type of selection to perform.
SortedSetSortField	SortField for `SortedSetDocValues`.
SortedSetSortField.Provider	A SortFieldProvider for this sort
Sorter	Sorts documents of a given index by returning a permutation on the document IDs.
Sorter	Base class for sorting algorithms implementations.
Sorter.DocMap	A permutation of doc IDs.
SortField	Stores information about how to sort documents by terms in an individual field.
SortField.Provider	A SortFieldProvider for field sorts
SortField.Type	Specifies the type of the terms to be sorted, or special types such as CUSTOM
SortFieldProvider	Reads/Writes a named SortField from a segment info file, used to record index sorts
SortingCodecReader	An `CodecReader` which supports sorting documents by a given `Sort`.
SortRescorer	A `Rescorer` that re-sorts according to a provided Sort.
SparseFixedBitSet	A bit set that only stores longs that have at least one bit which is set.
StableMSBRadixSorter	Stable radix sorter for variable-length strings.
StableMSBRadixSorter.MergeSorter	A MergeSorter taking advantage of temporary storage.
StandardAnalyzer	Filters `StandardTokenizer` with `LowerCaseFilter` and `StopFilter`, using a configurable list of stop words.
StandardDirectoryReader	Default implementation of `DirectoryReader`.
StandardTokenizer	A grammar-based tokenizer constructed with JFlex.
StandardTokenizerFactory	Factory for `StandardTokenizer`.
StandardTokenizerImpl	This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29.
StatePair	Pair of states.
Stats	BlockTree statistics for a single field returned by `FieldReader.getStats()`.
StopFilter	Removes stop words from a token stream.
StopwordAnalyzerBase	Base class for Analyzers that need to make use of stopword sets.
StoredField	A field whose value is stored so that `IndexSearcher.storedFields()` and `IndexReader.storedFields()` will return the field and its value.
StoredFields	API for reading stored fields.
StoredFieldsFormat	Controls the format of stored fields
StoredFieldsReader	Codec API for reading stored fields.
StoredFieldsWriter	Codec API for writing stored fields: For every document, `StoredFieldsWriter.startDocument()` is called, informing the Codec that a new document has started.
StoredFieldVisitor	Expert: provides a low-level means of accessing the stored field values in an index.
StoredFieldVisitor.Status	Enumeration of possible return values for `StoredFieldVisitor.needsField(org.apache.lucene.index.FieldInfo)`.
StoredValue	Abstraction around a stored value.
StoredValue.Type	Type of a `StoredValue`.
StringField	A field that is indexed but not tokenized: the entire String value is indexed as a single token.
StringHelper	Methods for manipulating strings.
StringSorter	A `BytesRef` sorter tries to use a efficient radix sorter if `StringSorter.cmp` is a `BytesRefComparator`, otherwise fallback to `StringSorter.fallbackSorter(java.util.Comparator<org.apache.lucene.util.BytesRef>)`
SuppressForbidden	Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
SynonymQuery	A query that treats multiple terms as synonyms.
SynonymQuery.Builder	A builder for `SynonymQuery`.
TaskExecutor	Executor wrapper responsible for the execution of concurrent tasks.
Term	A Term represents a word from text.
TermAndVector	Word2Vec unit composed by a term with the associated vector
TermFrequencyAttribute	Sets the custom term frequency of a term within one document.
TermFrequencyAttributeImpl	Default implementation of `TermFrequencyAttribute`.
TermInSetQuery	Specialization for a disjunction over many terms that, by default, behaves like a `ConstantScoreQuery` over a `BooleanQuery` containing only `BooleanClause.Occur.SHOULD` clauses.
TermOrdValComparator	Sorts by field's natural Term sort order, using ordinals.
TermQuery	A Query that matches documents containing a term.
TermRangeQuery	A Query that matches documents within an range of terms.
Terms	Access to the terms in a specific field.
TermScorer	Expert: A `Scorer` for documents matching a `Term`.
TermsEnum	Iterator to seek (`TermsEnum.seekCeil(BytesRef)`, `TermsEnum.seekExact(BytesRef)`) or step through (`BytesRefIterator.next()` terms to obtain frequency information (`TermsEnum.docFreq()`), `PostingsEnum` or `PostingsEnum` for the current term (`TermsEnum.postings(org.apache.lucene.index.PostingsEnum)`.
TermsEnum.SeekStatus	Represents returned result from `TermsEnum.seekCeil(org.apache.lucene.util.BytesRef)`.
TermState	Encapsulates all required internal state to position the associated `TermsEnum` without re-seeking.
TermStates	Maintains a `IndexReader` `TermState` view over `IndexReader` instances containing a single term.
TermStatistics	Contains statistics for a specific term
TermStats	Holder for per-term statistics.
TermToBytesRefAttribute	This attribute is requested by TermsHashPerField to index the contents.
TermVectors	API for reading term vectors.
TermVectorsFormat	Controls the format of term vectors
TermVectorsReader	Codec API for reading term vectors:
TermVectorsWriter	Codec API for writing term vectors: For every document, `TermVectorsWriter.startDocument(int)` is called, informing the Codec how many fields will be written.
Tessellator	Computes a triangular mesh tessellation for a given polygon.
Tessellator.Monitor	Implementation of this interface will receive calls with internal data at each step of the triangulation algorithm.
Tessellator.Node	Circular Doubly-linked list used for polygon coordinates
Tessellator.Triangle	Triangle in the tessellated mesh
TestSecrets	A set of static methods returning accessors for internal, package-private functionality in Lucene.
TextField	A field that is indexed and tokenized, without term vectors.
TFIDFSimilarity	Implementation of `Similarity` with the Vector Space Model.
ThreadInterruptedException	Thrown by lucene on detecting that Thread.interrupt() had been called.
TieredMergePolicy	Merges segments of approximately equal size, subject to an allowed number of segments per tier.
TieredMergePolicy.MergeScore	Holds score and explanation for a single candidate merge.
TimeLimitingCollector	Deprecated. Use `IndexSearcher.setTimeout(QueryTimeout)` to time out queries.
TimeLimitingCollector.TimeExceededException	Thrown when elapsed search time exceeds allowed search time.
TimeLimitingCollector.TimerThread	Thread used to timeout search requests.
TimeLimitingKnnCollectorManager	A `KnnCollectorManager` that collects results with a timeout.
TimSorter	`Sorter` implementation based on the TimSort algorithm.
TokenFilter	A TokenFilter is a TokenStream whose input is another TokenStream.
TokenFilterFactory	Abstract parent class for analysis factories that create `TokenFilter` instances.
Tokenizer	A Tokenizer is a TokenStream whose input is a Reader.
TokenizerFactory	Abstract parent class for analysis factories that create `Tokenizer` instances.
TokenStream	A `TokenStream` enumerates the sequence of tokens, either from `Field`s of a `Document` or from query text.
TokenStreamToAutomaton	Consumes a TokenStream and creates an `Automaton` where the transition labels are UTF8 bytes (or Unicode code points if unicodeArcs is true) from the `TermToBytesRefAttribute`.
TooComplexToDeterminizeException	This exception is thrown when determinizing an automaton would require too much work.
TopDocs	Represents hits returned by `IndexSearcher.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.
TopFieldCollectorManager	Create a TopFieldCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments if the primary sort is by relevancy.
TopFieldDocs	Represents hits returned by `IndexSearcher.search(Query,int,Sort)`.
TopKnnCollector	TopKnnCollector is a specific KnnCollector.
TopKnnCollectorManager	TopKnnCollectorManager responsible for creating `TopKnnCollector` instances.
TopScoreDocCollector	A `Collector` implementation that collects the top-scoring hits, returning them as a `TopDocs`.
TopScoreDocCollector.ScorerLeafCollector	Scorable leaf collector
TopScoreDocCollectorManager	Create a TopScoreDocCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments
TopTermsRewrite<B>	Base rewrite method for collecting only the top terms via a priority queue.
ToStringUtils	Helper methods to ease implementing `Object.toString()`.
TotalHitCountCollector	Just counts the total number of hits.
TotalHitCountCollectorManager	Collector manager based on `TotalHitCountCollector` that allows users to parallelize counting the number of hits, expected to be used mostly wrapped in `MultiCollectorManager`.
TotalHits	Description of the total number of hits of a query.
TotalHits.Relation	How the `TotalHits.value` should be interpreted.
TrackingDirectoryWrapper	A delegating Directory that records which files were written to and deleted.
Transition	Holds one transition from an `Automaton`.
TwoPhaseCommit	An interface for implementations that support 2-phase commit.
TwoPhaseCommitTool	A utility for executing 2-phase commit on several objects.
TwoPhaseCommitTool.CommitFailException	Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to commit().
TwoPhaseCommitTool.PrepareCommitFailException	Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to prepareCommit().
TwoPhaseIterator	Returned by `Scorer.twoPhaseIterator()` to expose an approximation of a `DocIdSetIterator`.
TypeAttribute	A Token's lexical type.
TypeAttributeImpl	Default implementation of `TypeAttribute`.
UnicodeUtil	Class to encode java's UTF16 char[] into UTF8 byte[] without always allocating a new byte[] as String.getBytes(StandardCharsets.UTF_8) does.
UnicodeUtil.UTF8CodePoint	Holds a codepoint along with the number of bytes required to represent it in UTF8
Unwrappable<T>	An object with this interface is a wrapper around another object (e.g., a filter with a delegate).
UpgradeIndexMergePolicy	This `MergePolicy` is used for upgrading all existing segments of an index when calling `IndexWriter.forceMerge(int)`.
UsageTrackingQueryCachingPolicy	A `QueryCachingPolicy` that tracks usage statistics of recently-used filters in order to decide on which filters are worth caching.
UTF32ToUTF8	Converts UTF-32 automata to the equivalent UTF-8 representation.
Util	Static helper methods.
Util.FSTPath<T>	Represents a path in TopNSearcher.
Util.Result<T>	Holds a single input (IntsRef) + output, returned by `shortestPaths()`.
Util.TopNSearcher<T>	Utility class to find top N shortest paths from start point(s).
Util.TopResults<T>	Holds the results for a top N search using `Util.TopNSearcher`
VectorEncoding	The numeric datatype of the vector values.
VectorizationProvider	A provider of vectorization implementations.
VectorScorer	Computes the similarity score between a given query vector and different document vectors.
VectorSimilarityFunction	Vector similarity function; used in search to return top K most similar vectors to a target vector.
VectorUtil	Utilities for computations with numeric arrays, especially algebraic operations like vector dot products.
VectorUtilSupport	Interface for implementations of VectorUtil support.
VectorValues	Deprecated. use `FloatVectorValues` instead
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.
VirtualMethod<C>	A utility for keeping backwards compatibility on previously abstract methods (or similar replacements).
WeakIdentityMap<K,V>	Implements a combination of `WeakHashMap` and `IdentityHashMap`.
Weight	Expert: Calculate query weights and build query scorers.
Weight.DefaultBulkScorer	Just wraps a Scorer and performs top scoring using it.
WildcardQuery	Implements the wildcard search query.
WordlistLoader	Loader for text files that represent a list of stopwords.
XYCircle	Represents a circle on the XY plane.
XYDocValuesField	An per-document location field.
XYDocValuesPointInGeometryQuery	XYGeometry query for `XYDocValuesField`.
XYEncodingUtils	reusable cartesian geometry encoding methods
XYGeometry	Cartesian Geometry object.
XYLine	Represents a line in cartesian space.
XYPoint	Represents a point on the earth's surface.
XYPointField	An indexed XY position field.
XYPolygon	Represents a polygon in cartesian space.
XYRectangle	Represents a x/y cartesian rectangle.
XYShape	A cartesian shape utility class for indexing and searching geometries whose vertices are unitless x, y values.
XYShapeDocValues	A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `XYShape` geometries in a `XYShapeDocValuesField`
XYShapeDocValuesField	Concrete implementation of a `ShapeDocValuesField` for cartesian geometries.