|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
See:
Description
| Interface Summary | |
|---|---|
| Compilable | The Compilable interface specifies a general way in
which an object may be compiled to an object output. |
| Distance<E> | The Distance interface provides a general method for
defining distances between two objects. |
| FeatureExtractor<E> | A FeatureExtractor provides a method of converting
generic input objects into feature vectors. |
| PriorityQueue<E> | A PriorityQueue is an ordered collection that supports
peek and pop methods to inspect and return the greatest element in
the queue. |
| Proximity<E> | The Proximity interface provides a general method for
defining closeness between two objects. |
| Scored | The Scored interface should be implemented by objects
that return a double-valued score. |
| Class Summary | |
|---|---|
| AbstractCommand | A CommandLineArguments object represents a the
command-line arguments. |
| AbstractExternalizable | The AbstractExternalizer is an adapter for read
resolved externalizables. |
| Arrays | Static utility methods for processing arrays. |
| BoundedPriorityQueue<E> | A BoundedPriorityQueue implements a priority queue
with an upper bound on the number of elements. |
| Collections | Static utility methods for processing collections. |
| CommaSeparatedValues | A CommaSeparatedValues object represents a
two-dimensional array of strings which may be read and written in
comma-separated-value string representation. |
| Counter | A reassignable integer usable for counting. |
| Exceptions | Static utility methods for handling exceptions. |
| Factory<E> | A Factory provides a generic interface for object
creation of a specified type. |
| FastCache<K,V> | A FastCache is a map implemented with soft references,
optimistic copy-on-write updates, and approximate count-based
pruning. |
| Files | Static utility methods for processing files. |
| FilterComparator<E> | Provides a generic filter for comparators, holding a reference to a contained comparator and allowing it to be retrieved, and a comparison operation that delegates to the contained comparator. |
| HardFastCache<K,V> | A HardFastCache is a map implemented with hard
references, optimistic copy-on-write updates, and approximate
count-based pruning. |
| Iterators | Static utility methods for iteration. |
| Iterators.Array<E> | An Iterator.Array iterates over the elements of an
array specified at construction time. |
| Iterators.ArraySlice<E> | An Iterators.ArraySlice iterates over a slice of
an array specified by start index and length. |
| Iterators.Buffered<E> | An Iterators.Buffered uses a single method to return
objects, buffering the result and returning it as the next element
if it is non-null. |
| Iterators.Empty<E> | An Iterator.Empty is an iterator with no
objects. |
| Iterators.Filter<E> | An Iterators.Filter filters the stream of objects
returned by another iterator by subjecting them to an acceptance
test. |
| Iterators.Modifier<E> | An Iterator.Modifier uses a single abstract method
to operate on the elements returned by an underlying iterator
to return modified objects. |
| Iterators.Pair<E> | An Iterators.Pair provides an iterator
over a sequence of exactly two elements. |
| Iterators.Sequence<E> | An Iterators.Sequence iterates over the elements of an
ordered sequence of iterators in turn. |
| Iterators.Singleton<E> | An Iterator.Singleton is an iterator over a
singleton object. |
| Math | A math utility class with static methods. |
| MinMaxHeap<E extends Scored> | A MinMaxHeap provides a heap-like data structure that
provides fast access to both the minimum and maximum elements of
the heap. |
| NBestSet<E> | An NBestSet is an ordered set with a maximum number of
elements specified at construction. |
| ObjectToCounterMap<E> | An ObjectToCounterMap maintains a mapping from objects
to integer counters, which may be incremented or set. |
| ObjectToDoubleMap<E> | An ObjectToDoubleMap maintains a mapping from
objects to double-valued counters, which may be incremented or set. |
| ObjectToSet<K,M> | An ObjectToSet provides a Map from
arbitrary objects to objects of class Set. |
| Pair<A,B> | The Pair class represents an immutable pair of objects
of heterogeneous type. |
| Reflection | Utility classes for handling reflection. |
| ReversibleComparator<E> | Provides a filtering comparator that supports inverting the order of the comparison. |
| ReversibleMTFListComparator<E> | A ReversibleMTFListComparator contains an ordered list
of comparators, any member of which can be reversed or moved to the
front of the list. |
| ScoredObject<E> | A ScoredObject provides an implementation of the
Scored interface with an attached object. |
| Sgml | The Sgml class contains static methods for processing SGML
into unicode characters. |
| SmallObjectToDoubleMap<E extends Comparable<E>> | A SmallObjectToDoubleMap provides a space-efficient
implementation of an immutable map from objects to doubles. |
| SmallSet<E> | The SmallSet class implements immutable instances the
Set interface tailored for sets with a small number of
members. |
| Streams | Static utility methods for processing input and output streams, readers and writers. |
| Strings | Static utility methods for processing strings, characters and string buffers. |
| Tuple<E> | A tuple is an immutable ordered list of objects or
null values with equality conditions determined
pointwise. |
| XML | Static utility methods and classes for processing XML. |
Classes for general Java utilities.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||