All Classes
| Class | Description |
|---|---|
| AbstractBoolean2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2ByteFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2CharFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2DoubleFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2IntFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2LongFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBoolean2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractBooleanBidirectionalIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractBooleanBigList |
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractBooleanBigList.BooleanRandomAccessSubList | |
| AbstractBooleanBigList.BooleanSubList |
A class implementing a sublist view.
|
| AbstractBooleanBigListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractBooleanCollection |
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractBooleanIterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractBooleanList |
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractBooleanList.BooleanRandomAccessSubList | |
| AbstractBooleanList.BooleanSubList |
A class implementing a sublist view.
|
| AbstractBooleanListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractBooleanSet |
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractBooleanSpliterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractBooleanStack | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractByte2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2BooleanMap.BasicEntry |
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).
|
| AbstractByte2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractByte2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2FloatMap.BasicEntry |
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).
|
| AbstractByte2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractByte2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ShortMap.BasicEntry |
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).
|
| AbstractByte2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractByte2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2BooleanMap.BasicEntry |
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).
|
| AbstractChar2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractChar2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2FloatMap.BasicEntry |
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).
|
| AbstractChar2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractChar2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2ShortMap.BasicEntry |
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).
|
| AbstractChar2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractChar2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2BooleanMap.BasicEntry |
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).
|
| AbstractDouble2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractDouble2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2FloatMap.BasicEntry |
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).
|
| AbstractDouble2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractDouble2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ShortMap.BasicEntry |
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).
|
| AbstractDouble2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractDouble2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2BooleanMap.BasicEntry |
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).
|
| AbstractFloat2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ByteFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ByteMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ByteMap.BasicEntry |
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).
|
| AbstractFloat2ByteMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2ByteSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2CharFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2CharMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2CharMap.BasicEntry |
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).
|
| AbstractFloat2CharMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2CharSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2DoubleFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2DoubleMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2DoubleMap.BasicEntry |
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).
|
| AbstractFloat2DoubleMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2DoubleSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2FloatMap.BasicEntry |
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).
|
| AbstractFloat2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2IntFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2IntMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2IntMap.BasicEntry |
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).
|
| AbstractFloat2IntMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2IntSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2LongFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2LongMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2LongMap.BasicEntry |
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).
|
| AbstractFloat2LongMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2LongSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ObjectMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ObjectMap.BasicEntry<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).
|
| AbstractFloat2ObjectMap.BasicEntrySet<V> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2ObjectSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ReferenceMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceMap.BasicEntry<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).
|
| AbstractFloat2ReferenceMap.BasicEntrySet<V> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2ReferenceSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ShortMap.BasicEntry |
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).
|
| AbstractFloat2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractFloat2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloatBidirectionalIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractFloatBigList |
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractFloatBigList.FloatRandomAccessSubList | |
| AbstractFloatBigList.FloatSubList |
A class implementing a sublist view.
|
| AbstractFloatBigListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractFloatCollection |
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatComparator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its only previous abstract
method is now a default method of the type-specific interface.
|
| AbstractFloatIterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractFloatList |
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractFloatList.FloatRandomAccessSubList | |
| AbstractFloatList.FloatSubList |
A class implementing a sublist view.
|
| AbstractFloatListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractFloatPriorityQueue | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractFloatSet |
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractFloatSortedSet |
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| AbstractFloatSpliterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractFloatStack | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractInt2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractInt2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractInt2BooleanMap.BasicEntry |
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).
|
| AbstractInt2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractInt2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractInt2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractInt2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractInt2FloatMap.BasicEntry |
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).
|
| AbstractInt2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractInt2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractInt2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractInt2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractInt2ShortMap.BasicEntry |
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).
|
| AbstractInt2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractInt2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractLong2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractLong2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractLong2BooleanMap.BasicEntry |
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).
|
| AbstractLong2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractLong2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractLong2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractLong2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractLong2FloatMap.BasicEntry |
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).
|
| AbstractLong2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractLong2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractLong2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractLong2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractLong2ShortMap.BasicEntry |
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).
|
| AbstractLong2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractLong2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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).
|
| AbstractObject2BooleanMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractObject2BooleanSortedMap<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).
|
| AbstractObject2FloatMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractObject2FloatSortedMap<K> |
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).
|
| AbstractObject2ShortMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractObject2ShortSortedMap<K> |
An abstract class providing basic methods for sorted maps 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).
|
| AbstractReference2BooleanMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractReference2BooleanSortedMap<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).
|
| AbstractReference2FloatMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractReference2FloatSortedMap<K> |
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).
|
| AbstractReference2ShortMap.BasicEntrySet<K> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractReference2ShortSortedMap<K> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2BooleanMap.BasicEntry |
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).
|
| AbstractShort2BooleanMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ByteFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ByteMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ByteMap.BasicEntry |
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).
|
| AbstractShort2ByteMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2ByteSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2CharFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2CharMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2CharMap.BasicEntry |
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).
|
| AbstractShort2CharMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2CharSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2DoubleFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2DoubleMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2DoubleMap.BasicEntry |
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).
|
| AbstractShort2DoubleMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2DoubleSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2FloatMap.BasicEntry |
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).
|
| AbstractShort2FloatMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2IntFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2IntMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2IntMap.BasicEntry |
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).
|
| AbstractShort2IntMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2IntSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2LongFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2LongMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2LongMap.BasicEntry |
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).
|
| AbstractShort2LongMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2LongSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ObjectMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ObjectMap.BasicEntry<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).
|
| AbstractShort2ObjectMap.BasicEntrySet<V> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2ObjectSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ReferenceMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ReferenceMap.BasicEntry<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).
|
| AbstractShort2ReferenceMap.BasicEntrySet<V> |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2ReferenceSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ShortMap.BasicEntry |
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).
|
| AbstractShort2ShortMap.BasicEntrySet |
This class provides a basic implementation for an Entry set which forwards some queries to the map.
|
| AbstractShort2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShortBidirectionalIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractShortBigList |
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractShortBigList.ShortRandomAccessSubList | |
| AbstractShortBigList.ShortSubList |
A class implementing a sublist view.
|
| AbstractShortBigListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractShortCollection |
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortComparator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its only previous abstract
method is now a default method of the type-specific interface.
|
| AbstractShortIterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractShortList |
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractShortList.ShortRandomAccessSubList | |
| AbstractShortList.ShortSubList |
A class implementing a sublist view.
|
| AbstractShortListIterator | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractShortPriorityQueue | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| AbstractShortSet |
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractShortSortedSet |
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| AbstractShortSpliterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractShortStack | Deprecated.
As of fastutil 8 this class is no longer necessary, as its previous abstract
methods are now default methods of the type-specific interface.
|
| Boolean2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2ByteFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2CharFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2DoubleFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2FloatFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2IntFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2LongFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2ObjectFunction<V> |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2ReferenceFunction<V> |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Boolean2ShortFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| BooleanArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| BooleanBidirectionalIterable |
A type-specific
Iterable that further strengthens the specification of Iterable.iterator(). |
| BooleanBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| BooleanBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| BooleanBigList |
A type-specific
BigList; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanBigListIterator |
A type-specific
BigListIterator. |
| BooleanBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| BooleanBigListIterators.AbstractIndexBasedBigIterator |
A skeletal implementation for an iterator backed by an index based data store.
|
| BooleanBigListIterators.AbstractIndexBasedBigListIterator |
A skeletal implementation for a list-iterator backed by an index based data store.
|
| BooleanBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| BooleanBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| BooleanBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| BooleanBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| BooleanBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| BooleanBigLists.ListBigList |
A class exposing a list as a big list.
|
| BooleanBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| BooleanBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| BooleanBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| BooleanBigSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators on
big (potentially greater then
Integer.MAX_VALUE items long). |
| BooleanBigSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanBigSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanBigSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanBinaryOperator |
A type-specific
BinaryOperator; provides methods operating both on objects
and on primitives. |
| BooleanBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanByteImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanByteMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanBytePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanCharImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanCharMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanCharPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanCollection |
A type-specific
Collection; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| BooleanCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| BooleanCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| BooleanCollections.IterableCollection |
A collection wrapper class for iterables.
|
| BooleanComparator |
A type-specific
Comparator; provides methods to compare two primitive types both as objects
and as primitive types. |
| BooleanComparators |
A class providing static methods and objects that do useful things with comparators.
|
| BooleanConsumer |
A type-specific
Consumer; provides methods to consume a primitive type both as object
and as primitive. |
| BooleanDoubleImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanDoubleMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanDoublePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanHash |
A type-specific
Hash interface. |
| BooleanHash.Strategy |
A type-specific hash strategy.
|
| BooleanImmutableList |
A type-specific array-based immutable list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| BooleanIntImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanIntMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanIntPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanIterables |
A class providing static methods and objects that do useful things with type-specific iterables.
|
| BooleanIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| BooleanIterators.AbstractIndexBasedIterator |
A skeletal implementation for an iterator backed by an index-based data store.
|
| BooleanIterators.AbstractIndexBasedListIterator |
A skeletal implementation for a list-iterator backed by an index-based data store.
|
| BooleanIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| BooleanIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| BooleanIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| BooleanIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| BooleanList |
A type-specific
List; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanListIterator |
A type-specific bidirectional iterator that is also a
ListIterator. |
| BooleanLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| BooleanLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| BooleanLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| BooleanLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| BooleanLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| BooleanLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| BooleanLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access lists.
|
| BooleanLongImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanLongMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanLongPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanObjectImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanObjectMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanObjectPair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanOpenHashSet |
A type-specific hash set with with a fast, small-footprint implementation.
|
| BooleanPredicate |
A type-specific
Predicate; provides methods to test a primitive type both as object
and as primitive. |
| BooleanReferenceImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanReferenceMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanReferencePair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanSet |
A type-specific
Set; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| BooleanSets.EmptySet |
An immutable class representing the empty set and implementing a type-specific set interface.
|
| BooleanSets.Singleton |
An immutable class representing a type-specific singleton set.
|
| BooleanSets.SynchronizedSet |
A synchronized wrapper class for sets.
|
| BooleanSets.UnmodifiableSet |
An unmodifiable wrapper class for sets.
|
| BooleanShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanSpliterator |
A type-specific
Spliterator; provides an additional methods to avoid (un)boxing, and
the possibility to skip elements. |
| BooleanSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators.
|
| BooleanSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanSpliterators.EmptySpliterator |
A class returning no elements and a type-specific spliterator interface.
|
| BooleanSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| BooleanStack |
A type-specific
Stack; provides some additional methods that use polymorphism to avoid (un)boxing. |
| BooleanUnaryOperator |
A type-specific
UnaryOperator; provides methods operating both on objects
and on primitives. |
| Byte2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Byte2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Byte2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Byte2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| ByteBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Char2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Char2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Char2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Char2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Char2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Char2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Char2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Char2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Char2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Char2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Char2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Char2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Char2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Char2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Char2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Char2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Char2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Char2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Char2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Char2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Char2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Char2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Char2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Char2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Char2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Char2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Char2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Char2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Char2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Char2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Char2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Char2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Char2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Char2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Char2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Char2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Char2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Char2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Char2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Char2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Char2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Char2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Char2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Char2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Char2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Char2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Char2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Char2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Char2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Char2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Char2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Char2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Char2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| CharBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Double2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Double2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Double2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| DoubleBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2ByteArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ByteAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ByteFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ByteFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2ByteFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2ByteFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2ByteFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2ByteFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2ByteLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ByteMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ByteMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ByteMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2ByteMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ByteMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2ByteMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2ByteMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2ByteMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2ByteOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ByteOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ByteRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ByteSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ByteSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2ByteSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ByteSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2ByteSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ByteSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2ByteSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2CharArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2CharAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2CharFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2CharFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2CharFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2CharFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2CharFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2CharFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2CharLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2CharMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2CharMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2CharMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2CharMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2CharMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2CharMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2CharMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2CharMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2CharOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2CharOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2CharRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2CharSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2CharSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2CharSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2CharSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2CharSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2CharSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2CharSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2DoubleArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2DoubleAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2DoubleFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2DoubleFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2DoubleFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2DoubleFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2DoubleFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2DoubleFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2DoubleLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2DoubleMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2DoubleMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2DoubleMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2DoubleMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2DoubleMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2DoubleMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2DoubleMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2DoubleMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2DoubleOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2DoubleOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2DoubleRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2DoubleSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2DoubleSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2DoubleSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2DoubleSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2DoubleSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2DoubleSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2DoubleSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2FloatFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2IntArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2IntAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2IntFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2IntFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2IntFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2IntFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2IntFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2IntFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2IntLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2IntMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2IntMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2IntMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2IntMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2IntMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2IntMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2IntMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2IntMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2IntOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2IntOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2IntRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2IntSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2IntSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2IntSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2IntSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2IntSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2IntSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2IntSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2LongArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2LongAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2LongFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2LongFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2LongFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2LongFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2LongFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2LongFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2LongLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2LongMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2LongMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2LongMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2LongMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2LongMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2LongMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2LongMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2LongMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2LongOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2LongOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2LongRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2LongSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2LongSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2LongSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2LongSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2LongSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2LongSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2LongSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2ObjectArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ObjectAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ObjectFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ObjectFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Float2ObjectFunctions.PrimitiveFunction<V> |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2ObjectFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Float2ObjectFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Float2ObjectFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Float2ObjectLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ObjectMap<V> |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ObjectMap.Entry<V> |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ObjectMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Float2ObjectMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ObjectMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Float2ObjectMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Float2ObjectMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Float2ObjectMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Float2ObjectOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ObjectOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ObjectRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ObjectSortedMap<V> |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ObjectSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Float2ObjectSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ObjectSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Float2ObjectSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ObjectSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Float2ObjectSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Float2ReferenceArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ReferenceAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ReferenceFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ReferenceFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Float2ReferenceFunctions.PrimitiveFunction<V> |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2ReferenceFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Float2ReferenceFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Float2ReferenceFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Float2ReferenceLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ReferenceMap<V> |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ReferenceMap.Entry<V> |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ReferenceMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Float2ReferenceMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ReferenceMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Float2ReferenceMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Float2ReferenceMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Float2ReferenceMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Float2ReferenceOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ReferenceOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ReferenceRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ReferenceSortedMap<V> |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ReferenceSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Float2ReferenceSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ReferenceSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Float2ReferenceSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ReferenceSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Float2ReferenceSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Float2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ShortFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Float2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Float2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Float2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Float2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Float2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Float2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Float2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Float2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Float2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Float2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Float2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| FloatArrayFIFOQueue |
A type-specific array-based FIFO queue, supporting also deque operations.
|
| FloatArrayIndirectPriorityQueue |
A type-specific array-based semi-indirect priority queue.
|
| FloatArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatArrayPriorityQueue |
A type-specific array-based priority queue.
|
| FloatArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| FloatAVLTreeSet |
A type-specific AVL tree set with a fast, small-footprint implementation.
|
| FloatBidirectionalIterable |
A type-specific
Iterable that further strengthens the specification of Iterable.iterator(). |
| FloatBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| FloatBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatBigList |
A type-specific
BigList; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBigListIterator |
A type-specific
BigListIterator. |
| FloatBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| FloatBigListIterators.AbstractIndexBasedBigIterator |
A skeletal implementation for an iterator backed by an index based data store.
|
| FloatBigListIterators.AbstractIndexBasedBigListIterator |
A skeletal implementation for a list-iterator backed by an index based data store.
|
| FloatBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| FloatBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| FloatBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| FloatBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| FloatBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| FloatBigLists.ListBigList |
A class exposing a list as a big list.
|
| FloatBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| FloatBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| FloatBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| FloatBigSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators on
big (potentially greater then
Integer.MAX_VALUE items long). |
| FloatBigSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatBigSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatBigSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatBinaryOperator |
A type-specific
BinaryOperator; provides methods operating both on objects
and on primitives. |
| FloatBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatByteImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatByteMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBytePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatCharImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatCharMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatCharPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatCollection |
A type-specific
Collection; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| FloatCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| FloatCollections.IterableCollection |
A collection wrapper class for iterables.
|
| FloatComparator |
A type-specific
Comparator; provides methods to compare two primitive types both as objects
and as primitive types. |
| FloatComparators |
A class providing static methods and objects that do useful things with comparators.
|
| FloatConsumer |
A type-specific
Consumer; provides methods to consume a primitive type both as object
and as primitive. |
| FloatDoubleImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatDoubleMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatDoublePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatFloatImmutableSortedPair |
A type-specific immutable
SortedPair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatFloatSortedPair |
A type-specific immutable
SortedPair. |
| FloatHash |
A type-specific
Hash interface. |
| FloatHash.Strategy |
A type-specific hash strategy.
|
| FloatHeapIndirectPriorityQueue |
A type-specific heap-based indirect priority queue.
|
| FloatHeapPriorityQueue |
A type-specific heap-based priority queue.
|
| FloatHeaps |
A class providing static methods and objects that do useful things with heaps.
|
| FloatHeapSemiIndirectPriorityQueue |
A type-specific heap-based semi-indirect priority queue.
|
| FloatImmutableList |
A type-specific array-based immutable list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatIndirectHeaps |
A class providing static methods and objects that do useful things with indirect heaps.
|
| FloatIndirectPriorityQueue |
A type-specific
IndirectPriorityQueue. |
| FloatIntImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatIntMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatIntPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatIterables |
A class providing static methods and objects that do useful things with type-specific iterables.
|
| FloatIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| FloatIterators.AbstractIndexBasedIterator |
A skeletal implementation for an iterator backed by an index-based data store.
|
| FloatIterators.AbstractIndexBasedListIterator |
A skeletal implementation for a list-iterator backed by an index-based data store.
|
| FloatIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| FloatIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| FloatIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| FloatIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| FloatLinkedOpenCustomHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| FloatLinkedOpenHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| FloatList |
A type-specific
List; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatListIterator |
A type-specific bidirectional iterator that is also a
ListIterator. |
| FloatLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| FloatLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| FloatLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| FloatLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| FloatLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| FloatLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| FloatLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access lists.
|
| FloatLongImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatLongMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatLongPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatObjectImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatObjectMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatObjectPair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatOpenCustomHashSet |
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| FloatOpenHashBigSet |
A type-specific hash big set with with a fast, small-footprint implementation.
|
| FloatOpenHashSet |
A type-specific hash set with with a fast, small-footprint implementation.
|
| FloatPredicate |
A type-specific
Predicate; provides methods to test a primitive type both as object
and as primitive. |
| FloatPriorityQueue |
A type-specific
PriorityQueue; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatPriorityQueues |
A class providing static methods and objects that do useful things with type-specific priority queues.
|
| FloatPriorityQueues.SynchronizedPriorityQueue |
A synchronized wrapper class for priority queues.
|
| FloatRBTreeSet |
A type-specific red-black tree set with a fast, small-footprint implementation.
|
| FloatReferenceImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatReferenceMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatReferencePair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSemiIndirectHeaps |
A class providing static methods and objects that do useful things with semi-indirect heaps.
|
| FloatSet |
A type-specific
Set; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| FloatSets.EmptySet |
An immutable class representing the empty set and implementing a type-specific set interface.
|
| FloatSets.Singleton |
An immutable class representing a type-specific singleton set.
|
| FloatSets.SynchronizedSet |
A synchronized wrapper class for sets.
|
| FloatSets.UnmodifiableSet |
An unmodifiable wrapper class for sets.
|
| FloatShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSortedSet |
A type-specific
SortedSet; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSortedSets |
A class providing static methods and objects that do useful things with type-specific sorted sets.
|
| FloatSortedSets.EmptySet |
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| FloatSortedSets.Singleton |
A class representing a singleton sorted set.
|
| FloatSortedSets.SynchronizedSortedSet |
A synchronized wrapper class for sorted sets.
|
| FloatSortedSets.UnmodifiableSortedSet |
An unmodifiable wrapper class for sorted sets.
|
| FloatSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators.
|
| FloatSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatSpliterators.EmptySpliterator |
A class returning no elements and a type-specific spliterator interface.
|
| FloatSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| FloatStack |
A type-specific
Stack; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatUnaryOperator |
A type-specific
UnaryOperator; provides methods operating both on objects
and on primitives. |
| Int2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Int2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Int2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Int2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Int2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Int2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Int2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Int2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Int2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Int2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Int2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Int2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Int2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Int2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Int2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Int2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Int2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Int2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Int2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Int2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Int2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Int2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Int2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Int2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Int2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Int2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Int2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Int2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Int2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Int2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Int2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Int2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Int2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Int2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Int2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Int2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Int2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Int2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Int2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Int2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Int2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Int2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Int2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Int2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Int2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Int2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Int2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Int2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Int2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Int2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Int2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Int2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Int2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Int2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Int2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Int2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Int2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Int2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Int2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Int2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Int2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Int2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Int2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Int2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Int2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Int2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Int2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Int2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Int2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Int2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Int2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Int2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Int2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Int2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Int2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Int2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Int2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Int2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Int2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Int2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Int2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Int2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| IntBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| IntShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Long2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Long2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Long2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Long2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Long2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Long2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Long2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Long2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Long2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Long2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Long2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Long2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Long2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Long2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Long2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Long2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Long2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Long2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Long2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Long2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Long2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Long2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Long2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Long2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Long2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Long2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Long2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Long2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Long2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Long2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Long2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Long2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Long2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Long2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Long2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Long2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Long2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Long2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Long2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Long2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Long2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Long2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Long2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Long2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Long2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Long2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Long2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Long2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Long2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Long2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Long2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Long2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Long2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Long2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Long2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Long2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Long2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Long2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Long2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Long2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Long2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Long2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Long2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Long2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Long2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Long2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Long2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Long2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Long2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Long2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Long2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Long2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Long2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Long2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Long2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Long2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Long2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Long2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Long2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Long2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Long2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Long2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| LongBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| LongShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| Object2BooleanFunction<K> |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| ObjectBooleanImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectBooleanMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectBooleanPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectFloatImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectFloatMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectFloatPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectShortImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectShortMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ObjectShortPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Reference2BooleanArrayMap<K> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Reference2BooleanFunction<K> |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.PrimitiveFunction<K> |
An adapter for mapping generic total functions to partial primitive functions.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| ReferenceBooleanImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceBooleanMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceBooleanPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceFloatImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceFloatMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceFloatPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceShortImmutablePair<K> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceShortMutablePair<K> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ReferenceShortPair<K> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2BooleanFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2BooleanFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2BooleanMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2BooleanMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2BooleanSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2ByteArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ByteAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ByteFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2ByteFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2ByteFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2ByteFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2ByteFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2ByteFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2ByteLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ByteMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ByteMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ByteMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2ByteMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2ByteMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2ByteMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2ByteMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2ByteMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2ByteOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ByteOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ByteRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ByteSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ByteSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2ByteSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2ByteSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2ByteSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2ByteSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2ByteSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2CharArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2CharAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2CharFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2CharFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2CharFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2CharFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2CharFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2CharFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2CharLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2CharMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2CharMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2CharMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2CharMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2CharMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2CharMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2CharMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2CharMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2CharOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2CharOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2CharRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2CharSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2CharSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2CharSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2CharSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2CharSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2CharSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2CharSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2DoubleArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2DoubleAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2DoubleFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2DoubleFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2DoubleFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2DoubleFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2DoubleFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2DoubleFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2DoubleLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2DoubleMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2DoubleMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2DoubleMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2DoubleMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2DoubleMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2DoubleMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2DoubleMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2DoubleMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2DoubleOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2DoubleOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2DoubleRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2DoubleSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2DoubleSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2DoubleSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2DoubleSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2DoubleSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2DoubleSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2DoubleSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2FloatFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2FloatFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2FloatMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2FloatMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2FloatSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2IntArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2IntAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2IntFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2IntFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2IntFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2IntFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2IntFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2IntFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2IntLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2IntMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2IntMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2IntMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2IntMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2IntMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2IntMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2IntMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2IntMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2IntOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2IntOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2IntRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2IntSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2IntSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2IntSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2IntSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2IntSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2IntSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2IntSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2LongArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2LongAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2LongFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2LongFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2LongFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2LongFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2LongFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2LongFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2LongLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2LongMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2LongMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2LongMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2LongMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2LongMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2LongMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2LongMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2LongMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2LongOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2LongOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2LongRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2LongSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2LongSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2LongSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2LongSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2LongSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2LongSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2LongSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Short2ObjectArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ObjectAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ObjectFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2ObjectFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Short2ObjectFunctions.PrimitiveFunction<V> |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2ObjectFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Short2ObjectFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Short2ObjectFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Short2ObjectLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ObjectMap<V> |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ObjectMap.Entry<V> |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ObjectMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Short2ObjectMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2ObjectMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Short2ObjectMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Short2ObjectMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Short2ObjectMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Short2ObjectOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ObjectOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ObjectRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ObjectSortedMap<V> |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ObjectSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Short2ObjectSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2ObjectSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Short2ObjectSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Short2ObjectSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Short2ObjectSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Short2ReferenceArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ReferenceAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ReferenceFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2ReferenceFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Short2ReferenceFunctions.PrimitiveFunction<V> |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2ReferenceFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Short2ReferenceFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Short2ReferenceFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Short2ReferenceLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ReferenceMap<V> |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ReferenceMap.Entry<V> |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ReferenceMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Short2ReferenceMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2ReferenceMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Short2ReferenceMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Short2ReferenceMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Short2ReferenceMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Short2ReferenceOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ReferenceOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ReferenceRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ReferenceSortedMap<V> |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ReferenceSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Short2ReferenceSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2ReferenceSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Short2ReferenceSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Short2ReferenceSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Short2ReferenceSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Short2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ShortFunction |
A type-specific
Function; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Short2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Short2ShortFunctions.PrimitiveFunction |
An adapter for mapping generic total functions to partial primitive functions.
|
| Short2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Short2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Short2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Short2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ShortMap |
A type-specific
Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ShortMap.Entry |
A type-specific
Map.Entry; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Short2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Short2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Short2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Short2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Short2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Short2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ShortSortedMap |
A type-specific
SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Short2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Short2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Short2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Short2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Short2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| ShortArrayFIFOQueue |
A type-specific array-based FIFO queue, supporting also deque operations.
|
| ShortArrayFrontCodedBigList |
Compact storage of big lists of arrays using front coding.
|
| ShortArrayFrontCodedList |
Compact storage of lists of arrays using front coding.
|
| ShortArrayIndirectPriorityQueue |
A type-specific array-based semi-indirect priority queue.
|
| ShortArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ShortArrayPriorityQueue |
A type-specific array-based priority queue.
|
| ShortArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| ShortAVLTreeSet |
A type-specific AVL tree set with a fast, small-footprint implementation.
|
| ShortBidirectionalIterable |
A type-specific
Iterable that further strengthens the specification of Iterable.iterator(). |
| ShortBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| ShortBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ShortBigList |
A type-specific
BigList; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortBigListIterator |
A type-specific
BigListIterator. |
| ShortBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| ShortBigListIterators.AbstractIndexBasedBigIterator |
A skeletal implementation for an iterator backed by an index based data store.
|
| ShortBigListIterators.AbstractIndexBasedBigListIterator |
A skeletal implementation for a list-iterator backed by an index based data store.
|
| ShortBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| ShortBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| ShortBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| ShortBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| ShortBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| ShortBigLists.ListBigList |
A class exposing a list as a big list.
|
| ShortBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| ShortBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| ShortBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| ShortBigSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators on
big (potentially greater then
Integer.MAX_VALUE items long). |
| ShortBigSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortBigSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortBigSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortBinaryOperator |
A type-specific
BinaryOperator; provides methods operating both on objects
and on primitives. |
| ShortBooleanImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortBooleanMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortBooleanPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortByteImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortByteMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortBytePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortCharImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortCharMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortCharPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortCollection |
A type-specific
Collection; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| ShortCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| ShortCollections.IterableCollection |
A collection wrapper class for iterables.
|
| ShortComparator |
A type-specific
Comparator; provides methods to compare two primitive types both as objects
and as primitive types. |
| ShortComparators |
A class providing static methods and objects that do useful things with comparators.
|
| ShortConsumer |
A type-specific
Consumer; provides methods to consume a primitive type both as object
and as primitive. |
| ShortDoubleImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortDoubleMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortDoublePair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortFloatImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortFloatMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortFloatPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortHash |
A type-specific
Hash interface. |
| ShortHash.Strategy |
A type-specific hash strategy.
|
| ShortHeapIndirectPriorityQueue |
A type-specific heap-based indirect priority queue.
|
| ShortHeapPriorityQueue |
A type-specific heap-based priority queue.
|
| ShortHeaps |
A class providing static methods and objects that do useful things with heaps.
|
| ShortHeapSemiIndirectPriorityQueue |
A type-specific heap-based semi-indirect priority queue.
|
| ShortImmutableList |
A type-specific array-based immutable list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ShortIndirectHeaps |
A class providing static methods and objects that do useful things with indirect heaps.
|
| ShortIndirectPriorityQueue |
A type-specific
IndirectPriorityQueue. |
| ShortIntImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortIntMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortIntPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortIterables |
A class providing static methods and objects that do useful things with type-specific iterables.
|
| ShortIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| ShortIterators.AbstractIndexBasedIterator |
A skeletal implementation for an iterator backed by an index-based data store.
|
| ShortIterators.AbstractIndexBasedListIterator |
A skeletal implementation for a list-iterator backed by an index-based data store.
|
| ShortIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| ShortIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| ShortIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| ShortIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| ShortLinkedOpenCustomHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ShortLinkedOpenHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ShortList |
A type-specific
List; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortListIterator |
A type-specific bidirectional iterator that is also a
ListIterator. |
| ShortLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| ShortLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| ShortLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| ShortLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| ShortLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| ShortLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| ShortLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access lists.
|
| ShortLongImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortLongMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortLongPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortObjectImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortObjectMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortObjectPair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortOpenCustomHashSet |
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| ShortOpenHashSet |
A type-specific hash set with with a fast, small-footprint implementation.
|
| ShortPredicate |
A type-specific
Predicate; provides methods to test a primitive type both as object
and as primitive. |
| ShortPriorityQueue |
A type-specific
PriorityQueue; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortPriorityQueues |
A class providing static methods and objects that do useful things with type-specific priority queues.
|
| ShortPriorityQueues.SynchronizedPriorityQueue |
A synchronized wrapper class for priority queues.
|
| ShortRBTreeSet |
A type-specific red-black tree set with a fast, small-footprint implementation.
|
| ShortReferenceImmutablePair<V> |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortReferenceMutablePair<V> |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortReferencePair<V> |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSemiIndirectHeaps |
A class providing static methods and objects that do useful things with semi-indirect heaps.
|
| ShortSet |
A type-specific
Set; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| ShortSets.EmptySet |
An immutable class representing the empty set and implementing a type-specific set interface.
|
| ShortSets.Singleton |
An immutable class representing a type-specific singleton set.
|
| ShortSets.SynchronizedSet |
A synchronized wrapper class for sets.
|
| ShortSets.UnmodifiableSet |
An unmodifiable wrapper class for sets.
|
| ShortShortImmutablePair |
A type-specific immutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortShortImmutableSortedPair |
A type-specific immutable
SortedPair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortShortMutablePair |
A type-specific mutable
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortShortPair |
A type-specific
Pair; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortShortSortedPair |
A type-specific immutable
SortedPair. |
| ShortSortedSet |
A type-specific
SortedSet; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSortedSets |
A class providing static methods and objects that do useful things with type-specific sorted sets.
|
| ShortSortedSets.EmptySet |
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| ShortSortedSets.Singleton |
A class representing a singleton sorted set.
|
| ShortSortedSets.SynchronizedSortedSet |
A synchronized wrapper class for sorted sets.
|
| ShortSortedSets.UnmodifiableSortedSet |
An unmodifiable wrapper class for sorted sets.
|
| ShortSpliterators |
A class providing static methods and objects that do useful things with type-specific spliterators.
|
| ShortSpliterators.AbstractIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortSpliterators.EarlyBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortSpliterators.EmptySpliterator |
A class returning no elements and a type-specific spliterator interface.
|
| ShortSpliterators.LateBindingSizeIndexBasedSpliterator |
A skeletal implementation for a spliterator backed by an index based data store.
|
| ShortStack |
A type-specific
Stack; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortUnaryOperator |
A type-specific
UnaryOperator; provides methods operating both on objects
and on primitives. |