|
|||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
Interface Summary | |
---|---|
Object2BooleanFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2BooleanMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2BooleanMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2BooleanMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2BooleanSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2BooleanSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2ByteFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ByteMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2ByteMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2ByteMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2ByteSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ByteSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2CharFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2CharMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2CharMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2CharMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2CharSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2CharSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2DoubleFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2DoubleMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2DoubleMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2DoubleMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2DoubleSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2DoubleSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2FloatFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2FloatMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2FloatMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2FloatMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2FloatSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2FloatSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2IntFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2IntMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2IntMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2IntMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2IntSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2IntSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2LongFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2LongMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2LongMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2LongMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2LongSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2LongSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Object2ObjectFunction<K,V> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ObjectMap<K,V> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2ObjectMap.Entry<K,V> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2ObjectMap.FastEntrySet<K,V> | An entry set providing fast iteration. |
Object2ObjectSortedMap<K,V> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ObjectSortedMap.FastSortedEntrySet<K,V> | A sorted entry set providing fast iteration. |
Object2ReferenceFunction<K,V> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ReferenceMap<K,V> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2ReferenceMap.Entry<K,V> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2ReferenceMap.FastEntrySet<K,V> | An entry set providing fast iteration. |
Object2ReferenceSortedMap<K,V> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ReferenceSortedMap.FastSortedEntrySet<K,V> | A sorted entry set providing fast iteration. |
Object2ShortFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ShortMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Object2ShortMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Object2ShortMap.FastEntrySet<K> | An entry set providing fast iteration. |
Object2ShortSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Object2ShortSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
ObjectBidirectionalIterator<K> | A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing, and the possibility to skip elements backwards. |
ObjectBigList<K> | A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ObjectBigListIterator<K> | A type-specific BigListIterator . |
ObjectCollection<K> | A type-specific Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
ObjectIterable<K> | A type-specific Iterable that strengthens that specification of Iterable.iterator() . |
ObjectIterator<K> | A type-specific Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
ObjectList<K> | A type-specific List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ObjectListIterator<K> | A type-specific bidirectional iterator that is also a ListIterator . |
ObjectSet<K> | A type-specific Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ObjectSortedSet<K> | A type-specific SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2BooleanFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2BooleanMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2BooleanMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2BooleanMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2BooleanSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2BooleanSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2ByteFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ByteMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2ByteMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2ByteMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2ByteSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ByteSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2CharFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2CharMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2CharMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2CharMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2CharSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2CharSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2DoubleFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2DoubleMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2DoubleMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2DoubleMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2DoubleSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2DoubleSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2FloatFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2FloatMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2FloatMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2FloatMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2FloatSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2FloatSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2IntFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2IntMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2IntMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2IntMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2IntSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2IntSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2LongFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2LongMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2LongMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2LongMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2LongSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2LongSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
Reference2ObjectFunction<K,V> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ObjectMap<K,V> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2ObjectMap.Entry<K,V> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2ObjectMap.FastEntrySet<K,V> | An entry set providing fast iteration. |
Reference2ObjectSortedMap<K,V> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ObjectSortedMap.FastSortedEntrySet<K,V> | A sorted entry set providing fast iteration. |
Reference2ReferenceFunction<K,V> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ReferenceMap<K,V> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2ReferenceMap.Entry<K,V> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2ReferenceMap.FastEntrySet<K,V> | An entry set providing fast iteration. |
Reference2ReferenceSortedMap<K,V> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ReferenceSortedMap.FastSortedEntrySet<K,V> | A sorted entry set providing fast iteration. |
Reference2ShortFunction<K> | A type-specific Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ShortMap<K> | A type-specific Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
Reference2ShortMap.Entry<K> | A type-specific Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
Reference2ShortMap.FastEntrySet<K> | An entry set providing fast iteration. |
Reference2ShortSortedMap<K> | A type-specific SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Reference2ShortSortedMap.FastSortedEntrySet<K> | A sorted entry set providing fast iteration. |
ReferenceBigList<K> | A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ReferenceCollection<K> | A type-specific Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
ReferenceList<K> | A type-specific List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ReferenceSet<K> | A type-specific Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
ReferenceSortedSet<K> | A type-specific SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Class Summary | |
---|---|
AbstractObject2BooleanFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2BooleanMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2BooleanMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2BooleanSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2ByteFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2ByteMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2ByteMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2ByteSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2CharFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2CharMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2CharMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2CharSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2DoubleFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2DoubleMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2DoubleMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2DoubleSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2FloatFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2FloatMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2FloatMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2FloatSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2IntFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2IntMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2IntMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2IntSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2LongFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2LongMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2LongMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2LongSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2ObjectFunction<K,V> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2ObjectMap<K,V> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2ObjectMap.BasicEntry<K,V> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2ObjectSortedMap<K,V> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2ReferenceFunction<K,V> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2ReferenceMap<K,V> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2ReferenceMap.BasicEntry<K,V> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2ReferenceSortedMap<K,V> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObject2ShortFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractObject2ShortMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractObject2ShortMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractObject2ShortSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractObjectBidirectionalIterator<K> | An abstract class facilitating the creation of type-specific bidirectional iterators. |
AbstractObjectBigList<K> | An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
AbstractObjectBigList.ObjectSubList<K> | |
AbstractObjectBigListIterator<K> | An abstract class facilitating the creation of type-specific big-list iterators. |
AbstractObjectCollection<K> | An abstract class providing basic methods for collections implementing a type-specific interface. |
AbstractObjectIterator<K> | An abstract class facilitating the creation of type-specific iterators. |
AbstractObjectList<K> | An abstract class providing basic methods for lists implementing a type-specific list interface. |
AbstractObjectList.ObjectSubList<K> | |
AbstractObjectListIterator<K> | An abstract class facilitating the creation of type-specific list iterators. |
AbstractObjectSet<K> | An abstract class providing basic methods for sets implementing a type-specific interface. |
AbstractObjectSortedSet<K> | An abstract class providing basic methods for sorted sets implementing a type-specific interface. |
AbstractReference2BooleanFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2BooleanMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2BooleanMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2BooleanSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2ByteFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2ByteMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2ByteMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2ByteSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2CharFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2CharMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2CharMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2CharSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2DoubleFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2DoubleMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2DoubleMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2DoubleSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2FloatFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2FloatMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2FloatMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2FloatSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2IntFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2IntMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2IntMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2IntSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2LongFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2LongMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2LongMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2LongSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2ObjectFunction<K,V> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2ObjectMap<K,V> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2ObjectMap.BasicEntry<K,V> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2ObjectSortedMap<K,V> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2ReferenceFunction<K,V> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2ReferenceMap<K,V> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2ReferenceMap.BasicEntry<K,V> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2ReferenceSortedMap<K,V> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReference2ShortFunction<K> | An abstract class providing basic methods for functions implementing a type-specific interface. |
AbstractReference2ShortMap<K> | An abstract class providing basic methods for maps implementing a type-specific interface. |
AbstractReference2ShortMap.BasicEntry<K> | This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps). |
AbstractReference2ShortSortedMap<K> | An abstract class providing basic methods for sorted maps implementing a type-specific interface. |
AbstractReferenceBigList<K> | An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
AbstractReferenceBigList.ReferenceSubList<K> | |
AbstractReferenceCollection<K> | An abstract class providing basic methods for collections implementing a type-specific interface. |
AbstractReferenceList<K> | An abstract class providing basic methods for lists implementing a type-specific list interface. |
AbstractReferenceList.ReferenceSubList<K> | |
AbstractReferenceSet<K> | An abstract class providing basic methods for sets implementing a type-specific interface. |
AbstractReferenceSortedSet<K> | An abstract class providing basic methods for sorted sets implementing a type-specific interface. |
Object2BooleanArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2BooleanAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2BooleanFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2BooleanFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2BooleanFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2BooleanFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2BooleanFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2BooleanLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2BooleanLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2BooleanMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2BooleanMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2BooleanMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2BooleanMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2BooleanMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2BooleanOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2BooleanOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2BooleanRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2BooleanSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2BooleanSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2BooleanSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2BooleanSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2BooleanSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2ByteArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2ByteAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2ByteFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2ByteFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2ByteFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2ByteFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2ByteFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2ByteLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ByteLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ByteMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2ByteMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2ByteMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2ByteMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2ByteMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2ByteOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2ByteOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2ByteRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2ByteSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2ByteSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2ByteSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2ByteSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2ByteSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2CharArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2CharAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2CharFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2CharFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2CharFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2CharFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2CharFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2CharLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2CharLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2CharMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2CharMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2CharMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2CharMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2CharMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2CharOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2CharOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2CharRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2CharSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2CharSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2CharSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2CharSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2CharSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2DoubleArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2DoubleAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2DoubleFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2DoubleFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2DoubleFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2DoubleFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2DoubleFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2DoubleLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2DoubleLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2DoubleMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2DoubleMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2DoubleMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2DoubleMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2DoubleMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2DoubleOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2DoubleOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2DoubleRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2DoubleSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2DoubleSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2DoubleSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2DoubleSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2DoubleSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2FloatArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2FloatAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2FloatFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2FloatFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2FloatFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2FloatFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2FloatFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2FloatLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2FloatLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2FloatMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2FloatMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2FloatMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2FloatMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2FloatMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2FloatOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2FloatOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2FloatRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2FloatSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2FloatSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2FloatSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2FloatSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2FloatSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2IntArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2IntAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2IntFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2IntFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2IntFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2IntFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2IntFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2IntLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2IntLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2IntMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2IntMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2IntMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2IntMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2IntMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2IntOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2IntOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2IntRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2IntSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2IntSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2IntSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2IntSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2IntSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2LongArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2LongAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2LongFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2LongFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2LongFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2LongFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2LongFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2LongLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2LongLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2LongMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2LongMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2LongMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2LongMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2LongMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2LongOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2LongOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2LongRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2LongSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2LongSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2LongSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2LongSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2LongSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Object2ObjectArrayMap<K,V> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2ObjectAVLTreeMap<K,V> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2ObjectFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2ObjectFunctions.EmptyFunction<K,V> | An immutable class representing an empty type-specific function. |
Object2ObjectFunctions.Singleton<K,V> | An immutable class representing a type-specific singleton function. |
Object2ObjectFunctions.SynchronizedFunction<K,V> | A synchronized wrapper class for functions. |
Object2ObjectFunctions.UnmodifiableFunction<K,V> | An unmodifiable wrapper class for functions. |
Object2ObjectLinkedOpenCustomHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ObjectLinkedOpenHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ObjectMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2ObjectMaps.EmptyMap<K,V> | An immutable class representing an empty type-specific map. |
Object2ObjectMaps.Singleton<K,V> | An immutable class representing a type-specific singleton map. |
Object2ObjectMaps.SynchronizedMap<K,V> | A synchronized wrapper class for maps. |
Object2ObjectMaps.UnmodifiableMap<K,V> | An unmodifiable wrapper class for maps. |
Object2ObjectOpenCustomHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2ObjectOpenHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation. |
Object2ObjectRBTreeMap<K,V> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2ObjectSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2ObjectSortedMaps.EmptySortedMap<K,V> | An immutable class representing an empty type-specific sorted map. |
Object2ObjectSortedMaps.Singleton<K,V> | An immutable class representing a type-specific singleton sorted map. |
Object2ObjectSortedMaps.SynchronizedSortedMap<K,V> | A synchronized wrapper class for sorted maps. |
Object2ObjectSortedMaps.UnmodifiableSortedMap<K,V> | An unmodifiable wrapper class for sorted maps. |
Object2ReferenceArrayMap<K,V> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2ReferenceAVLTreeMap<K,V> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2ReferenceFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2ReferenceFunctions.EmptyFunction<K,V> | An immutable class representing an empty type-specific function. |
Object2ReferenceFunctions.Singleton<K,V> | An immutable class representing a type-specific singleton function. |
Object2ReferenceFunctions.SynchronizedFunction<K,V> | A synchronized wrapper class for functions. |
Object2ReferenceFunctions.UnmodifiableFunction<K,V> | An unmodifiable wrapper class for functions. |
Object2ReferenceLinkedOpenCustomHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ReferenceLinkedOpenHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ReferenceMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2ReferenceMaps.EmptyMap<K,V> | An immutable class representing an empty type-specific map. |
Object2ReferenceMaps.Singleton<K,V> | An immutable class representing a type-specific singleton map. |
Object2ReferenceMaps.SynchronizedMap<K,V> | A synchronized wrapper class for maps. |
Object2ReferenceMaps.UnmodifiableMap<K,V> | An unmodifiable wrapper class for maps. |
Object2ReferenceOpenCustomHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2ReferenceOpenHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation. |
Object2ReferenceRBTreeMap<K,V> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2ReferenceSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2ReferenceSortedMaps.EmptySortedMap<K,V> | An immutable class representing an empty type-specific sorted map. |
Object2ReferenceSortedMaps.Singleton<K,V> | An immutable class representing a type-specific singleton sorted map. |
Object2ReferenceSortedMaps.SynchronizedSortedMap<K,V> | A synchronized wrapper class for sorted maps. |
Object2ReferenceSortedMaps.UnmodifiableSortedMap<K,V> | An unmodifiable wrapper class for sorted maps. |
Object2ShortArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Object2ShortAVLTreeMap<K> | A type-specific AVL tree map with a fast, small-footprint implementation. |
Object2ShortFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Object2ShortFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Object2ShortFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Object2ShortFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Object2ShortFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Object2ShortLinkedOpenCustomHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ShortLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Object2ShortMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Object2ShortMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Object2ShortMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Object2ShortMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Object2ShortMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Object2ShortOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Object2ShortOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Object2ShortRBTreeMap<K> | A type-specific red-black tree map with a fast, small-footprint implementation. |
Object2ShortSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Object2ShortSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Object2ShortSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Object2ShortSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Object2ShortSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
ObjectArrayFIFOQueue<K> | A type-specific array-based FIFO queue, supporting also deque operations. |
ObjectArrayIndirectPriorityQueue<K> | A type-specific array-based semi-indirect priority queue. |
ObjectArrayList<K> | A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
ObjectArrayPriorityQueue<K> | A type-specific array-based priority queue. |
ObjectArrays | A class providing static methods and objects that do useful things with type-specific arrays. |
ObjectArraySet<K> | A simple, brute-force implementation of a set based on a backing array. |
ObjectAVLTreeSet<K> | A type-specific AVL tree set with a fast, small-footprint implementation. |
ObjectBigArrayBigList<K> | A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing. |
ObjectBigArrays | A class providing static methods and objects that do useful things with big arrays. |
ObjectBigListIterators | A class providing static methods and objects that do useful things with type-specific iterators. |
ObjectBigListIterators.BigListIteratorListIterator<K> | A class exposing a list iterator as a big-list iterator.. |
ObjectBigListIterators.EmptyBigListIterator<K> | A class returning no elements and a type-specific big list iterator interface. |
ObjectBigListIterators.UnmodifiableBigListIterator<K> | An unmodifiable wrapper class for big list iterators. |
ObjectBigLists | A class providing static methods and objects that do useful things with type-specific big lists. |
ObjectBigLists.EmptyBigList<K> | An immutable class representing an empty type-specific big list. |
ObjectBigLists.ListBigList<K> | A class exposing a list as a big list. |
ObjectBigLists.Singleton<K> | An immutable class representing a type-specific singleton big list. |
ObjectBigLists.SynchronizedBigList<K> | A synchronized wrapper class for big lists. |
ObjectBigLists.UnmodifiableBigList<K> | An unmodifiable wrapper class for big lists. |
ObjectCollections | A class providing static methods and objects that do useful things with type-specific collections. |
ObjectCollections.EmptyCollection<K> | An immutable class representing an empty type-specific collection. |
ObjectCollections.IterableCollection<K> | A collection wrapper class for iterables. |
ObjectCollections.SynchronizedCollection<K> | A synchronized wrapper class for collections. |
ObjectCollections.UnmodifiableCollection<K> | An unmodifiable wrapper class for collections. |
ObjectComparators | A class providing static methods and objects that do useful things with comparators. |
ObjectHeapIndirectPriorityQueue<K> | A type-specific heap-based indirect priority queue. |
ObjectHeapPriorityQueue<K> | A type-specific heap-based priority queue. |
ObjectHeaps | A class providing static methods and objects that do useful things with heaps. |
ObjectHeapSemiIndirectPriorityQueue<K> | A type-specific heap-based semi-indirect priority queue. |
ObjectIndirectHeaps | A class providing static methods and objects that do useful things with indirect heaps. |
ObjectIterators | A class providing static methods and objects that do useful things with type-specific iterators. |
ObjectIterators.EmptyIterator<K> | A class returning no elements and a type-specific iterator interface. |
ObjectIterators.UnmodifiableBidirectionalIterator<K> | An unmodifiable wrapper class for bidirectional iterators. |
ObjectIterators.UnmodifiableIterator<K> | An unmodifiable wrapper class for iterators. |
ObjectIterators.UnmodifiableListIterator<K> | An unmodifiable wrapper class for list iterators. |
ObjectLinkedOpenCustomHashSet<K> | A type-specific linked hash set with with a fast, small-footprint implementation. |
ObjectLinkedOpenHashSet<K> | A type-specific linked hash set with with a fast, small-footprint implementation. |
ObjectLists | A class providing static methods and objects that do useful things with type-specific lists. |
ObjectLists.EmptyList<K> | An immutable class representing an empty type-specific list. |
ObjectLists.Singleton<K> | An immutable class representing a type-specific singleton list. |
ObjectLists.SynchronizedList<K> | A synchronized wrapper class for lists. |
ObjectLists.UnmodifiableList<K> | An unmodifiable wrapper class for lists. |
ObjectOpenCustomHashSet<K> | A type-specific hash set with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
ObjectOpenHashBigSet<K> | A type-specific hash big set with with a fast, small-footprint implementation. |
ObjectOpenHashSet<K> | A type-specific hash set with with a fast, small-footprint implementation. |
ObjectRBTreeSet<K> | A type-specific red-black tree set with a fast, small-footprint implementation. |
ObjectSemiIndirectHeaps | A class providing static methods and objects that do useful things with semi-indirect heaps. |
ObjectSets | A class providing static methods and objects that do useful things with type-specific sets. |
ObjectSets.EmptySet<K> | An immutable class representing the empty set and implementing a type-specific set interface. |
ObjectSets.Singleton<K> | An immutable class representing a type-specific singleton set. |
ObjectSets.SynchronizedSet<K> | A synchronized wrapper class for sets. |
ObjectSets.UnmodifiableSet<K> | An unmodifiable wrapper class for sets. |
ObjectSortedSets | A class providing static methods and objects that do useful things with type-specific sorted sets. |
ObjectSortedSets.EmptySet<K> | An immutable class representing the empty sorted set and implementing a type-specific set interface. |
ObjectSortedSets.Singleton<K> | A class representing a singleton sorted set. |
ObjectSortedSets.SynchronizedSortedSet<K> | A synchronized wrapper class for sorted sets. |
ObjectSortedSets.UnmodifiableSortedSet<K> | An unmodifiable wrapper class for sorted sets. |
Reference2BooleanArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2BooleanFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2BooleanFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2BooleanFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2BooleanFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2BooleanFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2BooleanLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2BooleanMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2BooleanMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2BooleanMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2BooleanMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2BooleanMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2BooleanOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2BooleanOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2BooleanSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2BooleanSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2BooleanSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2BooleanSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2BooleanSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2ByteArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2ByteFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2ByteFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2ByteFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2ByteFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2ByteFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2ByteLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2ByteMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2ByteMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2ByteMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2ByteMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2ByteMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2ByteOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2ByteOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2ByteSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2ByteSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2ByteSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2ByteSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2ByteSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2CharArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2CharFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2CharFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2CharFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2CharFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2CharFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2CharLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2CharMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2CharMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2CharMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2CharMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2CharMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2CharOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2CharOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2CharSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2CharSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2CharSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2CharSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2CharSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2DoubleArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2DoubleFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2DoubleFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2DoubleFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2DoubleFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2DoubleFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2DoubleLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2DoubleMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2DoubleMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2DoubleMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2DoubleMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2DoubleMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2DoubleOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2DoubleOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2DoubleSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2DoubleSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2DoubleSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2DoubleSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2DoubleSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2FloatArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2FloatFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2FloatFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2FloatFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2FloatFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2FloatFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2FloatLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2FloatMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2FloatMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2FloatMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2FloatMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2FloatMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2FloatOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2FloatOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2FloatSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2FloatSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2FloatSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2FloatSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2FloatSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2IntArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2IntFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2IntFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2IntFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2IntFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2IntFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2IntLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2IntMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2IntMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2IntMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2IntMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2IntMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2IntOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2IntOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2IntSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2IntSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2IntSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2IntSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2IntSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2LongArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2LongFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2LongFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2LongFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2LongFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2LongFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2LongLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2LongMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2LongMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2LongMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2LongMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2LongMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2LongOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2LongOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2LongSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2LongSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2LongSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2LongSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2LongSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
Reference2ObjectArrayMap<K,V> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2ObjectFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2ObjectFunctions.EmptyFunction<K,V> | An immutable class representing an empty type-specific function. |
Reference2ObjectFunctions.Singleton<K,V> | An immutable class representing a type-specific singleton function. |
Reference2ObjectFunctions.SynchronizedFunction<K,V> | A synchronized wrapper class for functions. |
Reference2ObjectFunctions.UnmodifiableFunction<K,V> | An unmodifiable wrapper class for functions. |
Reference2ObjectLinkedOpenHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2ObjectMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2ObjectMaps.EmptyMap<K,V> | An immutable class representing an empty type-specific map. |
Reference2ObjectMaps.Singleton<K,V> | An immutable class representing a type-specific singleton map. |
Reference2ObjectMaps.SynchronizedMap<K,V> | A synchronized wrapper class for maps. |
Reference2ObjectMaps.UnmodifiableMap<K,V> | An unmodifiable wrapper class for maps. |
Reference2ObjectOpenCustomHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2ObjectOpenHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2ObjectSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2ObjectSortedMaps.EmptySortedMap<K,V> | An immutable class representing an empty type-specific sorted map. |
Reference2ObjectSortedMaps.Singleton<K,V> | An immutable class representing a type-specific singleton sorted map. |
Reference2ObjectSortedMaps.SynchronizedSortedMap<K,V> | A synchronized wrapper class for sorted maps. |
Reference2ObjectSortedMaps.UnmodifiableSortedMap<K,V> | An unmodifiable wrapper class for sorted maps. |
Reference2ReferenceArrayMap<K,V> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2ReferenceFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2ReferenceFunctions.EmptyFunction<K,V> | An immutable class representing an empty type-specific function. |
Reference2ReferenceFunctions.Singleton<K,V> | An immutable class representing a type-specific singleton function. |
Reference2ReferenceFunctions.SynchronizedFunction<K,V> | A synchronized wrapper class for functions. |
Reference2ReferenceFunctions.UnmodifiableFunction<K,V> | An unmodifiable wrapper class for functions. |
Reference2ReferenceLinkedOpenHashMap<K,V> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2ReferenceMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2ReferenceMaps.EmptyMap<K,V> | An immutable class representing an empty type-specific map. |
Reference2ReferenceMaps.Singleton<K,V> | An immutable class representing a type-specific singleton map. |
Reference2ReferenceMaps.SynchronizedMap<K,V> | A synchronized wrapper class for maps. |
Reference2ReferenceMaps.UnmodifiableMap<K,V> | An unmodifiable wrapper class for maps. |
Reference2ReferenceOpenCustomHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2ReferenceOpenHashMap<K,V> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2ReferenceSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2ReferenceSortedMaps.EmptySortedMap<K,V> | An immutable class representing an empty type-specific sorted map. |
Reference2ReferenceSortedMaps.Singleton<K,V> | An immutable class representing a type-specific singleton sorted map. |
Reference2ReferenceSortedMaps.SynchronizedSortedMap<K,V> | A synchronized wrapper class for sorted maps. |
Reference2ReferenceSortedMaps.UnmodifiableSortedMap<K,V> | An unmodifiable wrapper class for sorted maps. |
Reference2ShortArrayMap<K> | A simple, brute-force implementation of a map based on two parallel backing arrays. |
Reference2ShortFunctions | A class providing static methods and objects that do useful things with type-specific functions. |
Reference2ShortFunctions.EmptyFunction<K> | An immutable class representing an empty type-specific function. |
Reference2ShortFunctions.Singleton<K> | An immutable class representing a type-specific singleton function. |
Reference2ShortFunctions.SynchronizedFunction<K> | A synchronized wrapper class for functions. |
Reference2ShortFunctions.UnmodifiableFunction<K> | An unmodifiable wrapper class for functions. |
Reference2ShortLinkedOpenHashMap<K> | A type-specific linked hash map with with a fast, small-footprint implementation. |
Reference2ShortMaps | A class providing static methods and objects that do useful things with type-specific maps. |
Reference2ShortMaps.EmptyMap<K> | An immutable class representing an empty type-specific map. |
Reference2ShortMaps.Singleton<K> | An immutable class representing a type-specific singleton map. |
Reference2ShortMaps.SynchronizedMap<K> | A synchronized wrapper class for maps. |
Reference2ShortMaps.UnmodifiableMap<K> | An unmodifiable wrapper class for maps. |
Reference2ShortOpenCustomHashMap<K> | A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time. |
Reference2ShortOpenHashMap<K> | A type-specific hash map with a fast, small-footprint implementation. |
Reference2ShortSortedMaps | A class providing static methods and objects that do useful things with type-specific sorted maps. |
Reference2ShortSortedMaps.EmptySortedMap<K> | An immutable class representing an empty type-specific sorted map. |
Reference2ShortSortedMaps.Singleton<K> | An immutable class representing a type-specific singleton sorted map. |
Reference2ShortSortedMaps.SynchronizedSortedMap<K> | A synchronized wrapper class for sorted maps. |
Reference2ShortSortedMaps.UnmodifiableSortedMap<K> | An unmodifiable wrapper class for sorted maps. |
ReferenceArrayList<K> | A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
ReferenceArraySet<K> | A simple, brute-force implementation of a set based on a backing array. |
ReferenceBigArrayBigList<K> | A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing. |
ReferenceBigLists | A class providing static methods and objects that do useful things with type-specific big lists. |
ReferenceBigLists.EmptyBigList<K> | An immutable class representing an empty type-specific big list. |
ReferenceBigLists.ListBigList<K> | A class exposing a list as a big list. |
ReferenceBigLists.Singleton<K> | An immutable class representing a type-specific singleton big list. |
ReferenceBigLists.SynchronizedBigList<K> | A synchronized wrapper class for big lists. |
ReferenceBigLists.UnmodifiableBigList<K> | An unmodifiable wrapper class for big lists. |
ReferenceCollections | A class providing static methods and objects that do useful things with type-specific collections. |
ReferenceCollections.EmptyCollection<K> | An immutable class representing an empty type-specific collection. |
ReferenceCollections.IterableCollection<K> | A collection wrapper class for iterables. |
ReferenceCollections.SynchronizedCollection<K> | A synchronized wrapper class for collections. |
ReferenceCollections.UnmodifiableCollection<K> | An unmodifiable wrapper class for collections. |
ReferenceLinkedOpenHashSet<K> | A type-specific linked hash set with with a fast, small-footprint implementation. |
ReferenceLists | A class providing static methods and objects that do useful things with type-specific lists. |
ReferenceLists.EmptyList<K> | An immutable class representing an empty type-specific list. |
ReferenceLists.Singleton<K> | An immutable class representing a type-specific singleton list. |
ReferenceLists.SynchronizedList<K> | A synchronized wrapper class for lists. |
ReferenceLists.UnmodifiableList<K> | An unmodifiable wrapper class for lists. |
ReferenceOpenHashBigSet<K> | A type-specific hash big set with with a fast, small-footprint implementation. |
ReferenceOpenHashSet<K> | A type-specific hash set with with a fast, small-footprint implementation. |
ReferenceSets | A class providing static methods and objects that do useful things with type-specific sets. |
ReferenceSets.EmptySet<K> | An immutable class representing the empty set and implementing a type-specific set interface. |
ReferenceSets.Singleton<K> | An immutable class representing a type-specific singleton set. |
ReferenceSets.SynchronizedSet<K> | A synchronized wrapper class for sets. |
ReferenceSets.UnmodifiableSet<K> | An unmodifiable wrapper class for sets. |
ReferenceSortedSets | A class providing static methods and objects that do useful things with type-specific sorted sets. |
ReferenceSortedSets.EmptySet<K> | An immutable class representing the empty sorted set and implementing a type-specific set interface. |
ReferenceSortedSets.Singleton<K> | A class representing a singleton sorted set. |
ReferenceSortedSets.SynchronizedSortedSet<K> | A synchronized wrapper class for sorted sets. |
ReferenceSortedSets.UnmodifiableSortedSet<K> | An unmodifiable wrapper class for sorted sets. |
Provides type-specific classes for object elements or keys.
Whenever possible, fastutil
provides both typical
collections, which compare objects using equals()
, and
reference-based collections, which use equality
(==
). See the related comments in the overview.
Of course, reference-based sorted sets and maps make no sense, and are not generated.
|
|||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |