Alle Klassen und Schnittstellen

Klasse	Beschreibung
AbstractBooleanCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractBooleanList	Abstract implementation of the BooleanList interface.
AbstractBooleanPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractByte2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByte2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractByte2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractByteCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractByteList	Abstract implementation of the ByteList interface.
AbstractBytePriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractByteSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractChar2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractChar2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractChar2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractCharCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractCharList	Abstract implementation of the CharList interface.
AbstractCharPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractCharSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractDouble2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDouble2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractDouble2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractDoubleCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractDoubleList	Abstract implementation of the DoubleList interface.
AbstractDoublePriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractDoubleSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractFloat2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloat2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractFloat2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractFloatCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractFloatList	Abstract implementation of the FloatList interface.
AbstractFloatPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractFloatSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractInt2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractInt2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractInt2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractIntCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractIntList	Abstract implementation of the IntList interface.
AbstractIntPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractIntSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractLong2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLong2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractLong2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractLongCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractLongList	Abstract implementation of the LongList interface.
AbstractLongPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractLongSet	Abstract Type Specific Set that reduces boxing/unboxing
AbstractObject2BooleanMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2BooleanMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2ByteMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2ByteMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2CharMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2CharMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2DoubleMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2DoubleMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2FloatMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2FloatMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2IntMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2IntMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2LongMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2LongMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2ObjectMap<T,V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2ObjectMap.BasicEntry<T,V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObject2ShortMap<T>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractObject2ShortMap.BasicEntry<T>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractObjectCollection<T>	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractObjectList<T>	Abstract implementation of the ObjectList interface.
AbstractObjectPriorityQueue<T>	Helper class that implements all the essential methods for the PriorityQueues
AbstractObjectSet<T>	Abstract Type Specific Set that reduces boxing/unboxing
AbstractShort2BooleanMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2BooleanMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2ByteMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2ByteMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2CharMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2CharMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2DoubleMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2DoubleMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2FloatMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2FloatMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2IntMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2IntMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2LongMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2LongMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2ObjectMap<V>	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2ObjectMap.BasicEntry<V>	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShort2ShortMap	A Base Implementation of a Type Specific Map to reduce boxing/unboxing
AbstractShort2ShortMap.BasicEntry	A Simple Type Specific Entry class to reduce boxing/unboxing
AbstractShortCollection	Abstract Type Specific Collection that reduces boxing/unboxing
AbstractShortList	Abstract implementation of the ShortList interface.
AbstractShortPriorityQueue	Helper class that implements all the essential methods for the PriorityQueues
AbstractShortSet	Abstract Type Specific Set that reduces boxing/unboxing
Boolean2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Boolean2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
BooleanArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
BooleanArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
BooleanArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
BooleanArrays	A Helper class for Arrays
BooleanAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
BooleanAsyncBuilder.BaseBooleanTask	Base Task of the Actions that can be performed.
BooleanBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
BooleanBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanBooleanImmutablePair	Mutable Pair Implementation that
BooleanBooleanMutablePair	Mutable Pair Implementation that
BooleanBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanByteImmutablePair	Mutable Pair Implementation that
BooleanByteMutablePair	Mutable Pair Implementation that
BooleanBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanCharImmutablePair	Mutable Pair Implementation that
BooleanCharMutablePair	Mutable Pair Implementation that
BooleanCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanCollection	A Type-Specific Collection that reduces (un)boxing
BooleanCollections	A Helper class for Collections
BooleanCollections.EmptyCollection	Empty Collection implementation for the empty collection function
BooleanCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
BooleanCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
BooleanComparator	Type-Specific Class for Comparator to reduce (un)boxing
BooleanComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
BooleanConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
BooleanDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanDoubleImmutablePair	Mutable Pair Implementation that
BooleanDoubleMutablePair	Mutable Pair Implementation that
BooleanDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanFloatImmutablePair	Mutable Pair Implementation that
BooleanFloatMutablePair	Mutable Pair Implementation that
BooleanFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
BooleanHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
BooleanIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanIntImmutablePair	Mutable Pair Implementation that
BooleanIntMutablePair	Mutable Pair Implementation that
BooleanIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanIterable	A Type-Specific Iterable that reduces (un)boxing
BooleanIterables	A Helper class for Iterables
BooleanIterator	A Type-Specific Iterator that reduces (un)boxing
BooleanIterators	A Helper class for Iterators
BooleanLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
BooleanList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
BooleanListIterator	A Type Specific ListIterator that reduces boxing/unboxing
BooleanLists	A Helper class for Lists
BooleanLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanLongImmutablePair	Mutable Pair Implementation that
BooleanLongMutablePair	Mutable Pair Implementation that
BooleanLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanObjectImmutablePair<V>	Mutable Pair Implementation that
BooleanObjectMutablePair<V>	Mutable Pair Implementation that
BooleanObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
BooleanPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
BooleanPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
BooleanPriorityQueues	A Helper class for PriorityQueues
BooleanPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
BooleanPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
BooleanShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
BooleanShortImmutablePair	Mutable Pair Implementation that
BooleanShortMutablePair	Mutable Pair Implementation that
BooleanShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
BooleanShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
BooleanSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
BooleanSplititerators	Helper class that provides SplitIterators for normal and stream usage
BooleanStack	A Type-Specific Stack that reduces (un)boxing
BooleanStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
BooleanStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
BooleanSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
BooleanTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
Byte2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Byte2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Byte2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Byte2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Byte2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Byte2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Byte2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Byte2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Byte2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Byte2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Byte2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Byte2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Byte2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Byte2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Byte2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Byte2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Byte2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Byte2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Byte2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Byte2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Byte2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Byte2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Byte2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Byte2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Byte2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Byte2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Byte2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Byte2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Byte2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Byte2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Byte2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Byte2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Byte2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Byte2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Byte2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Byte2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Byte2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Byte2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Byte2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Byte2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
ByteArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
ByteArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
ByteArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
ByteArrays	A Helper class for Arrays
ByteArraySet	A Type Specific ArraySet implementation.
ByteAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
ByteAsyncBuilder.BaseByteTask	Base Task of the Actions that can be performed.
ByteAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
ByteBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
ByteBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteBooleanImmutablePair	Mutable Pair Implementation that
ByteBooleanMutablePair	Mutable Pair Implementation that
ByteBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteByteImmutablePair	Mutable Pair Implementation that
ByteByteMutablePair	Mutable Pair Implementation that
ByteBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteCharImmutablePair	Mutable Pair Implementation that
ByteCharMutablePair	Mutable Pair Implementation that
ByteCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteCollection	A Type-Specific Collection that reduces (un)boxing
ByteCollections	A Helper class for Collections
ByteCollections.EmptyCollection	Empty Collection implementation for the empty collection function
ByteCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
ByteCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
ByteComparator	Type-Specific Class for Comparator to reduce (un)boxing
ByteComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
ByteConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
ByteDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteDoubleImmutablePair	Mutable Pair Implementation that
ByteDoubleMutablePair	Mutable Pair Implementation that
ByteDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteFloatImmutablePair	Mutable Pair Implementation that
ByteFloatMutablePair	Mutable Pair Implementation that
ByteFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ByteHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
ByteIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteIntImmutablePair	Mutable Pair Implementation that
ByteIntMutablePair	Mutable Pair Implementation that
ByteIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteIterable	A Type-Specific Iterable that reduces (un)boxing
ByteIterables	A Helper class for Iterables
ByteIterator	A Type-Specific Iterator that reduces (un)boxing
ByteIterators	A Helper class for Iterators
ByteLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
ByteLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
ByteLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
ByteList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
ByteListIterator	A Type Specific ListIterator that reduces boxing/unboxing
ByteLists	A Helper class for Lists
ByteLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteLongImmutablePair	Mutable Pair Implementation that
ByteLongMutablePair	Mutable Pair Implementation that
ByteLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
ByteObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteObjectImmutablePair<V>	Mutable Pair Implementation that
ByteObjectMutablePair<V>	Mutable Pair Implementation that
ByteObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
ByteOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ByteOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
BytePredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
BytePriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
BytePriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
BytePriorityQueues	A Helper class for PriorityQueues
BytePriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
BytePriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
ByteRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
ByteSet	A Type Specific Set class to reduce boxing/unboxing
ByteSets	A Helper class for sets
ByteSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
ByteShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ByteShortImmutablePair	Mutable Pair Implementation that
ByteShortMutablePair	Mutable Pair Implementation that
ByteShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ByteShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ByteSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
ByteSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
ByteSplititerators	Helper class that provides SplitIterators for normal and stream usage
ByteStack	A Type-Specific Stack that reduces (un)boxing
ByteStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
ByteStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
ByteSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
ByteTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
ByteUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Char2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Char2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Char2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Char2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Char2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Char2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Char2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Char2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Char2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Char2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Char2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Char2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Char2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Char2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Char2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Char2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Char2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Char2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Char2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Char2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Char2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Char2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Char2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Char2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Char2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Char2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Char2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Char2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Char2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Char2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Char2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Char2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Char2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Char2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Char2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Char2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Char2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Char2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Char2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Char2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
CharArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
CharArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CharArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
CharArrays	A Helper class for Arrays
CharArraySet	A Type Specific ArraySet implementation.
CharAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
CharAsyncBuilder.BaseCharTask	Base Task of the Actions that can be performed.
CharAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
CharBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
CharBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharBooleanImmutablePair	Mutable Pair Implementation that
CharBooleanMutablePair	Mutable Pair Implementation that
CharBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharByteImmutablePair	Mutable Pair Implementation that
CharByteMutablePair	Mutable Pair Implementation that
CharBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharCharImmutablePair	Mutable Pair Implementation that
CharCharMutablePair	Mutable Pair Implementation that
CharCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharCollection	A Type-Specific Collection that reduces (un)boxing
CharCollections	A Helper class for Collections
CharCollections.EmptyCollection	Empty Collection implementation for the empty collection function
CharCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
CharCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
CharComparator	Type-Specific Class for Comparator to reduce (un)boxing
CharComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
CharConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
CharDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharDoubleImmutablePair	Mutable Pair Implementation that
CharDoubleMutablePair	Mutable Pair Implementation that
CharDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharFloatImmutablePair	Mutable Pair Implementation that
CharFloatMutablePair	Mutable Pair Implementation that
CharFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
CharHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
CharIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharIntImmutablePair	Mutable Pair Implementation that
CharIntMutablePair	Mutable Pair Implementation that
CharIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharIterable	A Type-Specific Iterable that reduces (un)boxing
CharIterables	A Helper class for Iterables
CharIterator	A Type-Specific Iterator that reduces (un)boxing
CharIterators	A Helper class for Iterators
CharLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
CharLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
CharLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
CharList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
CharListIterator	A Type Specific ListIterator that reduces boxing/unboxing
CharLists	A Helper class for Lists
CharLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharLongImmutablePair	Mutable Pair Implementation that
CharLongMutablePair	Mutable Pair Implementation that
CharLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
CharObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharObjectImmutablePair<V>	Mutable Pair Implementation that
CharObjectMutablePair<V>	Mutable Pair Implementation that
CharObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
CharOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
CharOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
CharPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
CharPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
CharPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
CharPriorityQueues	A Helper class for PriorityQueues
CharPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
CharPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
CharRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
CharSet	A Type Specific Set class to reduce boxing/unboxing
CharSets	A Helper class for sets
CharSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
CharShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
CharShortImmutablePair	Mutable Pair Implementation that
CharShortMutablePair	Mutable Pair Implementation that
CharShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
CharShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
CharSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
CharSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
CharSplititerators	Helper class that provides SplitIterators for normal and stream usage
CharStack	A Type-Specific Stack that reduces (un)boxing
CharStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
CharStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
CharSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
CharTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
CharUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
CopyOnWriteBooleanArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteByteArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteCharArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteDoubleArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteFloatArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteIntArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteLongArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteObjectArrayList<T>	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
CopyOnWriteShortArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
Double2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Double2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Double2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Double2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Double2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Double2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Double2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Double2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Double2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Double2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Double2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Double2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Double2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Double2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Double2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Double2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Double2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Double2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Double2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Double2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Double2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Double2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Double2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Double2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Double2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Double2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Double2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Double2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Double2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Double2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Double2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Double2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Double2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Double2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Double2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Double2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Double2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Double2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Double2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Double2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Double2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
DoubleArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
DoubleArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
DoubleArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
DoubleArrays	A Helper class for Arrays
DoubleArraySet	A Type Specific ArraySet implementation.
DoubleAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
DoubleAsyncBuilder.BaseDoubleTask	Base Task of the Actions that can be performed.
DoubleAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
DoubleBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
DoubleBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleBooleanImmutablePair	Mutable Pair Implementation that
DoubleBooleanMutablePair	Mutable Pair Implementation that
DoubleBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleByteImmutablePair	Mutable Pair Implementation that
DoubleByteMutablePair	Mutable Pair Implementation that
DoubleBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleCharImmutablePair	Mutable Pair Implementation that
DoubleCharMutablePair	Mutable Pair Implementation that
DoubleCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleCollection	A Type-Specific Collection that reduces (un)boxing
DoubleCollections	A Helper class for Collections
DoubleCollections.EmptyCollection	Empty Collection implementation for the empty collection function
DoubleCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
DoubleCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
DoubleComparator	Type-Specific Class for Comparator to reduce (un)boxing
DoubleComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
DoubleConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
DoubleDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleDoubleImmutablePair	Mutable Pair Implementation that
DoubleDoubleMutablePair	Mutable Pair Implementation that
DoubleDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleFloatImmutablePair	Mutable Pair Implementation that
DoubleFloatMutablePair	Mutable Pair Implementation that
DoubleFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
DoubleHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
DoubleIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleIntImmutablePair	Mutable Pair Implementation that
DoubleIntMutablePair	Mutable Pair Implementation that
DoubleIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleIterable	A Type-Specific Iterable that reduces (un)boxing
DoubleIterables	A Helper class for Iterables
DoubleIterator	A Type-Specific Iterator that reduces (un)boxing
DoubleIterators	A Helper class for Iterators
DoubleLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
DoubleLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
DoubleLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
DoubleList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
DoubleListIterator	A Type Specific ListIterator that reduces boxing/unboxing
DoubleLists	A Helper class for Lists
DoubleLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleLongImmutablePair	Mutable Pair Implementation that
DoubleLongMutablePair	Mutable Pair Implementation that
DoubleLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
DoubleObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleObjectImmutablePair<V>	Mutable Pair Implementation that
DoubleObjectMutablePair<V>	Mutable Pair Implementation that
DoubleObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
DoubleOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
DoubleOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
DoublePredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
DoublePriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
DoublePriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
DoublePriorityQueues	A Helper class for PriorityQueues
DoublePriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
DoublePriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
DoubleRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
DoubleSet	A Type Specific Set class to reduce boxing/unboxing
DoubleSets	A Helper class for sets
DoubleSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
DoubleShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
DoubleShortImmutablePair	Mutable Pair Implementation that
DoubleShortMutablePair	Mutable Pair Implementation that
DoubleShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
DoubleShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
DoubleSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
DoubleSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
DoubleSplititerators	Helper class that provides SplitIterators for normal and stream usage
DoubleStack	A Type-Specific Stack that reduces (un)boxing
DoubleStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
DoubleStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
DoubleSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
DoubleTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
DoubleUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Enum2BooleanMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2ByteMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2CharMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2DoubleMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2FloatMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2IntMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2LongMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2ObjectMap<T extends Enum<T>,V>	A Type Specific EnumMap implementation that allows for Primitive Values.
Enum2ShortMap<T extends Enum<T>>	A Type Specific EnumMap implementation that allows for Primitive Values.
Float2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Float2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Float2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Float2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Float2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Float2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Float2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Float2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Float2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Float2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Float2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Float2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Float2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Float2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Float2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Float2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Float2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Float2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Float2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Float2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Float2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Float2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Float2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Float2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Float2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Float2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Float2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Float2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Float2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Float2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Float2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Float2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Float2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Float2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Float2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Float2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Float2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Float2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Float2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Float2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Float2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
FloatArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
FloatArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
FloatArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
FloatArrays	A Helper class for Arrays
FloatArraySet	A Type Specific ArraySet implementation.
FloatAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
FloatAsyncBuilder.BaseFloatTask	Base Task of the Actions that can be performed.
FloatAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
FloatBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
FloatBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatBooleanImmutablePair	Mutable Pair Implementation that
FloatBooleanMutablePair	Mutable Pair Implementation that
FloatBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatByteImmutablePair	Mutable Pair Implementation that
FloatByteMutablePair	Mutable Pair Implementation that
FloatBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatCharImmutablePair	Mutable Pair Implementation that
FloatCharMutablePair	Mutable Pair Implementation that
FloatCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatCollection	A Type-Specific Collection that reduces (un)boxing
FloatCollections	A Helper class for Collections
FloatCollections.EmptyCollection	Empty Collection implementation for the empty collection function
FloatCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
FloatCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
FloatComparator	Type-Specific Class for Comparator to reduce (un)boxing
FloatComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
FloatConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
FloatDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatDoubleImmutablePair	Mutable Pair Implementation that
FloatDoubleMutablePair	Mutable Pair Implementation that
FloatDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatFloatImmutablePair	Mutable Pair Implementation that
FloatFloatMutablePair	Mutable Pair Implementation that
FloatFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
FloatHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
FloatIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatIntImmutablePair	Mutable Pair Implementation that
FloatIntMutablePair	Mutable Pair Implementation that
FloatIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatIterable	A Type-Specific Iterable that reduces (un)boxing
FloatIterables	A Helper class for Iterables
FloatIterator	A Type-Specific Iterator that reduces (un)boxing
FloatIterators	A Helper class for Iterators
FloatLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
FloatLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
FloatLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
FloatList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
FloatListIterator	A Type Specific ListIterator that reduces boxing/unboxing
FloatLists	A Helper class for Lists
FloatLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatLongImmutablePair	Mutable Pair Implementation that
FloatLongMutablePair	Mutable Pair Implementation that
FloatLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
FloatObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatObjectImmutablePair<V>	Mutable Pair Implementation that
FloatObjectMutablePair<V>	Mutable Pair Implementation that
FloatObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
FloatOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
FloatOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
FloatPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
FloatPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
FloatPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
FloatPriorityQueues	A Helper class for PriorityQueues
FloatPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
FloatPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
FloatRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
FloatSet	A Type Specific Set class to reduce boxing/unboxing
FloatSets	A Helper class for sets
FloatSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
FloatShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
FloatShortImmutablePair	Mutable Pair Implementation that
FloatShortMutablePair	Mutable Pair Implementation that
FloatShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
FloatShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
FloatSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
FloatSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
FloatSplititerators	Helper class that provides SplitIterators for normal and stream usage
FloatStack	A Type-Specific Stack that reduces (un)boxing
FloatStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
FloatStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
FloatSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
FloatTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
FloatUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
HashUtil	Helper class that is used for HashMap functions reduce duplicated code
IArray	A Helper interface that allows to detect if the Underlying implementation is using a Array.
IBooleanArray	Type-Specific Helper class to get the underlying array of array implementations.
IByteArray	Type-Specific Helper class to get the underlying array of array implementations.
ICharArray	Type-Specific Helper class to get the underlying array of array implementations.
IDoubleArray	Type-Specific Helper class to get the underlying array of array implementations.
IFloatArray	Type-Specific Helper class to get the underlying array of array implementations.
IIntArray	Type-Specific Helper class to get the underlying array of array implementations.
ILongArray	Type-Specific Helper class to get the underlying array of array implementations.
ImmutableBooleanList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableByte2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByte2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableByteList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableByteOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableChar2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableChar2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableCharList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableCharOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableDouble2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDouble2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableDoubleList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableDoubleOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableFloat2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloat2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableFloatList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableFloatOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableInt2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableInt2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableIntList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableIntOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableLong2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLong2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableLongList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableLongOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableObject2BooleanOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2ByteOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2CharOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2DoubleOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2FloatOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2IntOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2LongOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2ObjectOpenHashMap<T,V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObject2ShortOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableObjectList<T>	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableObjectOpenHashSet<T>	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ImmutableShort2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShort2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
ImmutableShortList	A Type-Specific Immutable implementation of list that is written to reduce (un)boxing
ImmutableShortOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
Int2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Int2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Int2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Int2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Int2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Int2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Int2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Int2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Int2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Int2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Int2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Int2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Int2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Int2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Int2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Int2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Int2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Int2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Int2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Int2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Int2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Int2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Int2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Int2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Int2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Int2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Int2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Int2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Int2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Int2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Int2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Int2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Int2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Int2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Int2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Int2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Int2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Int2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Int2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Int2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Int2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
IntArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
IntArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
IntArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
IntArrays	A Helper class for Arrays
IntArraySet	A Type Specific ArraySet implementation.
IntAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
IntAsyncBuilder.BaseIntTask	Base Task of the Actions that can be performed.
IntAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
IntBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
IntBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntBooleanImmutablePair	Mutable Pair Implementation that
IntBooleanMutablePair	Mutable Pair Implementation that
IntBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntByteImmutablePair	Mutable Pair Implementation that
IntByteMutablePair	Mutable Pair Implementation that
IntBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntCharImmutablePair	Mutable Pair Implementation that
IntCharMutablePair	Mutable Pair Implementation that
IntCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntCollection	A Type-Specific Collection that reduces (un)boxing
IntCollections	A Helper class for Collections
IntCollections.EmptyCollection	Empty Collection implementation for the empty collection function
IntCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
IntCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
IntComparator	Type-Specific Class for Comparator to reduce (un)boxing
IntComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
IntConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
IntDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntDoubleImmutablePair	Mutable Pair Implementation that
IntDoubleMutablePair	Mutable Pair Implementation that
IntDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntFloatImmutablePair	Mutable Pair Implementation that
IntFloatMutablePair	Mutable Pair Implementation that
IntFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
IntHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
IntIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntIntImmutablePair	Mutable Pair Implementation that
IntIntMutablePair	Mutable Pair Implementation that
IntIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntIterable	A Type-Specific Iterable that reduces (un)boxing
IntIterables	A Helper class for Iterables
IntIterator	A Type-Specific Iterator that reduces (un)boxing
IntIterators	A Helper class for Iterators
IntLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
IntLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
IntLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
IntList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
IntListIterator	A Type Specific ListIterator that reduces boxing/unboxing
IntLists	A Helper class for Lists
IntLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntLongImmutablePair	Mutable Pair Implementation that
IntLongMutablePair	Mutable Pair Implementation that
IntLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
IntObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntObjectImmutablePair<V>	Mutable Pair Implementation that
IntObjectMutablePair<V>	Mutable Pair Implementation that
IntObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
IntOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
IntOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
IntPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
IntPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
IntPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
IntPriorityQueues	A Helper class for PriorityQueues
IntPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
IntPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
IntRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
IntSet	A Type Specific Set class to reduce boxing/unboxing
IntSets	A Helper class for sets
IntSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
IntShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
IntShortImmutablePair	Mutable Pair Implementation that
IntShortMutablePair	Mutable Pair Implementation that
IntShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
IntShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
IntSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
IntSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
IntSplititerators	Helper class that provides SplitIterators for normal and stream usage
IntStack	A Type-Specific Stack that reduces (un)boxing
IntStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
IntStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
IntSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
IntTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
IntUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
IObjectArray<T>	Type-Specific Helper class to get the underlying array of array implementations.
IShortArray	Type-Specific Helper class to get the underlying array of array implementations.
ISizeProvider
ISizeProvider.CollectionSize	Collection implementation of the SizeProvider
ITrimmable	Interface that allows to test for if a collection is trimmable.
LinkedEnum2BooleanMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2ByteMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2CharMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2DoubleMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2FloatMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2IntMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2LongMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2ObjectMap<T extends Enum<T>,V>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
LinkedEnum2ShortMap<T extends Enum<T>>	A Type Specific LinkedEnumMap implementation that allows for Primitive Values and faster iteration.
Long2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Long2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Long2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Long2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Long2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Long2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Long2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Long2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Long2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Long2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Long2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Long2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Long2ShortFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Long2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Long2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Long2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Long2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Long2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Long2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Long2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Long2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Long2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Long2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Long2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Long2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Long2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Long2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Long2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Long2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Long2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Long2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Long2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Long2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Long2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Long2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Long2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Long2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Long2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Long2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Long2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Long2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
LongArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
LongArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
LongArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
LongArrays	A Helper class for Arrays
LongArraySet	A Type Specific ArraySet implementation.
LongAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
LongAsyncBuilder.BaseLongTask	Base Task of the Actions that can be performed.
LongAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
LongBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
LongBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongBooleanImmutablePair	Mutable Pair Implementation that
LongBooleanMutablePair	Mutable Pair Implementation that
LongBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongByteImmutablePair	Mutable Pair Implementation that
LongByteMutablePair	Mutable Pair Implementation that
LongBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongCharImmutablePair	Mutable Pair Implementation that
LongCharMutablePair	Mutable Pair Implementation that
LongCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongCollection	A Type-Specific Collection that reduces (un)boxing
LongCollections	A Helper class for Collections
LongCollections.EmptyCollection	Empty Collection implementation for the empty collection function
LongCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
LongCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
LongComparator	Type-Specific Class for Comparator to reduce (un)boxing
LongComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
LongConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
LongDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongDoubleImmutablePair	Mutable Pair Implementation that
LongDoubleMutablePair	Mutable Pair Implementation that
LongDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongFloatImmutablePair	Mutable Pair Implementation that
LongFloatMutablePair	Mutable Pair Implementation that
LongFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
LongHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
LongIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongIntImmutablePair	Mutable Pair Implementation that
LongIntMutablePair	Mutable Pair Implementation that
LongIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongIterable	A Type-Specific Iterable that reduces (un)boxing
LongIterables	A Helper class for Iterables
LongIterator	A Type-Specific Iterator that reduces (un)boxing
LongIterators	A Helper class for Iterators
LongLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
LongLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
LongLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
LongList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
LongListIterator	A Type Specific ListIterator that reduces boxing/unboxing
LongLists	A Helper class for Lists
LongLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongLongImmutablePair	Mutable Pair Implementation that
LongLongMutablePair	Mutable Pair Implementation that
LongLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
LongObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongObjectImmutablePair<V>	Mutable Pair Implementation that
LongObjectMutablePair<V>	Mutable Pair Implementation that
LongObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
LongOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
LongOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
LongPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
LongPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
LongPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
LongPriorityQueues	A Helper class for PriorityQueues
LongPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
LongPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
LongRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
LongSet	A Type Specific Set class to reduce boxing/unboxing
LongSets	A Helper class for sets
LongSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
LongShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
LongShortImmutablePair	Mutable Pair Implementation that
LongShortMutablePair	Mutable Pair Implementation that
LongShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
LongShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
LongSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
LongSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
LongSplititerators	Helper class that provides SplitIterators for normal and stream usage
LongStack	A Type-Specific Stack that reduces (un)boxing
LongStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
LongStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
LongSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
LongTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
LongUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Object2BooleanArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2BooleanAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2BooleanConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2BooleanConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2BooleanLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2BooleanLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2BooleanMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2BooleanMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2BooleanMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2BooleanMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2BooleanMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2BooleanMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2BooleanMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2BooleanMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2BooleanMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2BooleanMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2BooleanMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2BooleanMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2BooleanMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2BooleanMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2BooleanMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2BooleanMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2BooleanMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2BooleanNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2BooleanOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2BooleanOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2BooleanOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2BooleanOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2BooleanRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2BooleanSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2BooleanSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2ByteAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2ByteConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ByteConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2ByteLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2ByteLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2ByteMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ByteMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2ByteMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2ByteMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2ByteMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2ByteMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2ByteMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2ByteMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2ByteMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2ByteMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2ByteMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2ByteMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2ByteMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2ByteMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2ByteMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2ByteMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2ByteMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2ByteNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2ByteOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2ByteOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2ByteOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ByteOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2ByteSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ByteSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2CharAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2CharConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2CharConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2CharLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2CharLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2CharMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2CharMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2CharMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2CharMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2CharMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2CharMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2CharMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2CharMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2CharMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2CharMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2CharMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2CharMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2CharMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2CharMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2CharMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2CharMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2CharMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2CharNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2CharOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2CharOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2CharOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2CharOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2CharSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2CharSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2DoubleAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2DoubleConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2DoubleConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2DoubleLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2DoubleLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2DoubleMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2DoubleMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2DoubleMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2DoubleMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2DoubleMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2DoubleMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2DoubleMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2DoubleMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2DoubleMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2DoubleMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2DoubleMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2DoubleMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2DoubleMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2DoubleMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2DoubleMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2DoubleMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2DoubleMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2DoubleNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2DoubleOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2DoubleOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2DoubleOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2DoubleOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2DoubleSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2DoubleSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2FloatAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2FloatConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2FloatConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2FloatLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2FloatLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2FloatMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2FloatMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2FloatMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2FloatMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2FloatMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2FloatMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2FloatMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2FloatMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2FloatMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2FloatMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2FloatMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2FloatMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2FloatMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2FloatMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2FloatMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2FloatMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2FloatMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2FloatNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2FloatOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2FloatOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2FloatOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2FloatOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2FloatSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2FloatSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2IntAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2IntConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2IntConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2IntLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2IntLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2IntMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2IntMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2IntMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2IntMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2IntMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2IntMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2IntMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2IntMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2IntMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2IntMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2IntMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2IntMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2IntMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2IntMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2IntMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2IntMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2IntMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2IntNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2IntOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2IntOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2IntOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2IntOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2IntSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2IntSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2LongAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2LongConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2LongConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2LongLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2LongLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2LongMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2LongMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2LongMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2LongMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2LongMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2LongMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2LongMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2LongMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2LongMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2LongMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2LongMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2LongMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2LongMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2LongMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2LongMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2LongMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2LongMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2LongNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2LongOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2LongOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2LongOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2LongOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2LongSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2LongSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectArrayMap<T,V>	A Very Specific Type Specific implementation of a ArrayMap.
Object2ObjectAVLTreeMap<T,V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2ObjectConcurrentMap<T,V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ObjectConcurrentOpenHashMap<T,V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2ObjectLinkedOpenCustomHashMap<T,V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2ObjectLinkedOpenHashMap<T,V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2ObjectMap<T,V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ObjectMap.BuilderCache<T,V>	Builder Cache for allowing to buildMaps
Object2ObjectMap.Entry<T,V>	Type Specific Map Entry that reduces boxing/unboxing
Object2ObjectMap.FastEntrySet<T,V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2ObjectMaps.EmptyMap<T,V>	Empty Map impementation that is used for the emptyMap() function
Object2ObjectMaps.SingletonMap<T,V>	Singleton Map instance that is used in the helper method
Object2ObjectMaps.SynchronizedMap<T,V>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2ObjectMaps.SynchronizedNavigableMap<T,V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2ObjectMaps.SynchronizedOrderedMap<T,V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2ObjectMaps.SynchronizedSortedMap<T,V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2ObjectMaps.UnmodifyableEntry<T,V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2ObjectMaps.UnmodifyableEntrySet<T,V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2ObjectMaps.UnmodifyableMap<T,V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2ObjectMaps.UnmodifyableNavigableMap<T,V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2ObjectMaps.UnmodifyableOrderedEntrySet<T,V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2ObjectMaps.UnmodifyableOrderedMap<T,V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2ObjectMaps.UnmodifyableSortedMap<T,V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2ObjectNavigableMap<T,V>	A Type Specific Navigable Map interface with a couple helper methods
Object2ObjectOpenCustomHashMap<T,V>	A Type Specific HashMap that allows for custom HashControl.
Object2ObjectOpenHashMap<T,V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2ObjectOrderedMap<T,V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ObjectOrderedMap.FastOrderedSet<T,V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectRBTreeMap<T,V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2ObjectSortedMap<T,V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ObjectSortedMap.FastSortedSet<T,V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortArrayMap<T>	A Very Specific Type Specific implementation of a ArrayMap.
Object2ShortAVLTreeMap<T>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Object2ShortConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ShortConcurrentOpenHashMap<T>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Object2ShortLinkedOpenCustomHashMap<T>	A Type Specific LinkedHashMap that allows for custom HashControl.
Object2ShortLinkedOpenHashMap<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Object2ShortMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ShortMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2ShortMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2ShortMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Object2ShortMaps.EmptyMap<T>	Empty Map impementation that is used for the emptyMap() function
Object2ShortMaps.SingletonMap<T>	Singleton Map instance that is used in the helper method
Object2ShortMaps.SynchronizedMap<T>	The Synchronized Map implementation used by the synchronizedMap helper function
Object2ShortMaps.SynchronizedNavigableMap<T>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Object2ShortMaps.SynchronizedOrderedMap<T>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Object2ShortMaps.SynchronizedSortedMap<T>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Object2ShortMaps.UnmodifyableEntry<T>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Object2ShortMaps.UnmodifyableEntrySet<T>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Object2ShortMaps.UnmodifyableMap<T>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Object2ShortMaps.UnmodifyableNavigableMap<T>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Object2ShortMaps.UnmodifyableOrderedEntrySet<T>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Object2ShortMaps.UnmodifyableOrderedMap<T>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Object2ShortMaps.UnmodifyableSortedMap<T>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Object2ShortNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2ShortOpenCustomHashMap<T>	A Type Specific HashMap that allows for custom HashControl.
Object2ShortOpenHashMap<T>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Object2ShortOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ShortOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortRBTreeMap<T>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Object2ShortSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ShortSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
ObjectArrayFIFOQueue<T>	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
ObjectArrayList<T>	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
ObjectArrayPriorityQueue<T>	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
ObjectArrays	A Helper class for Arrays
ObjectArraySet<T>	A Type Specific ArraySet implementation.
ObjectAsyncBuilder<T>	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
ObjectAsyncBuilder.BaseObjectTask<T>	Base Task of the Actions that can be performed.
ObjectAVLTreeSet<T>	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
ObjectBidirectionalIterator<T>	This is a basically a ListIterator without the index functions.
ObjectBooleanConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectBooleanImmutablePair<T>	Mutable Pair Implementation that
ObjectBooleanMutablePair<T>	Mutable Pair Implementation that
ObjectBooleanPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectBooleanUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectByteConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectByteImmutablePair<T>	Mutable Pair Implementation that
ObjectByteMutablePair<T>	Mutable Pair Implementation that
ObjectBytePair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectByteUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectCharConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectCharImmutablePair<T>	Mutable Pair Implementation that
ObjectCharMutablePair<T>	Mutable Pair Implementation that
ObjectCharPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectCharUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectCollection<T>	A Type-Specific Collection that reduces (un)boxing
ObjectCollections	A Helper class for Collections
ObjectCollections.EmptyCollection<T>	Empty Collection implementation for the empty collection function
ObjectCollections.SynchronizedCollection<T>	Synchronized Collection Wrapper for the synchronizedCollection function
ObjectCollections.UnmodifiableCollection<T>	Unmodifyable Collection Wrapper for the unmodifyableCollection method
ObjectDoubleConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectDoubleImmutablePair<T>	Mutable Pair Implementation that
ObjectDoubleMutablePair<T>	Mutable Pair Implementation that
ObjectDoublePair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectDoubleUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectFloatConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectFloatImmutablePair<T>	Mutable Pair Implementation that
ObjectFloatMutablePair<T>	Mutable Pair Implementation that
ObjectFloatPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectFloatUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectHeapPriorityQueue<T>	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
ObjectIntConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectIntImmutablePair<T>	Mutable Pair Implementation that
ObjectIntMutablePair<T>	Mutable Pair Implementation that
ObjectIntPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectIntUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectIterable<T>	A Type-Specific Iterable that reduces (un)boxing
ObjectIterables	A Helper class for Iterables
ObjectIterator<T>	A Type-Specific Iterator that reduces (un)boxing
ObjectIterators	A Helper class for Iterators
ObjectLinkedList<T>	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
ObjectLinkedOpenCustomHashSet<T>	A Type Specific LinkedHashSet that allows for custom HashControl.
ObjectLinkedOpenHashSet<T>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
ObjectList<T>	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
ObjectListIterator<T>	A Type Specific ListIterator that reduces boxing/unboxing
ObjectLists	A Helper class for Lists
ObjectLongConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectLongImmutablePair<T>	Mutable Pair Implementation that
ObjectLongMutablePair<T>	Mutable Pair Implementation that
ObjectLongPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectLongUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectNavigableSet<T>	A Type Specific Navigable Set interface with a couple helper methods
ObjectObjectConsumer<T,V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectObjectImmutablePair<T,V>	Mutable Pair Implementation that
ObjectObjectMutablePair<T,V>	Mutable Pair Implementation that
ObjectObjectPair<T,V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectObjectUnaryOperator<T,V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectOpenCustomHashSet<T>	A Type Specific HashSet that allows for custom HashControl.
ObjectOpenHashSet<T>	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ObjectOrderedSet<T>	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
ObjectPriorityDequeue<T>	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
ObjectPriorityQueue<T>	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
ObjectPriorityQueues	A Helper class for PriorityQueues
ObjectPriorityQueues.SynchronizedPriorityDequeue<T>	Wrapper class for synchronization
ObjectPriorityQueues.SynchronizedPriorityQueue<T>	Wrapper class for synchronization
ObjectRBTreeSet<T>	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
ObjectSet<T>	A Type Specific Set class to reduce boxing/unboxing
ObjectSets	A Helper class for sets
ObjectSets.UnmodifiableSet<T>	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
ObjectShortConsumer<T>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ObjectShortImmutablePair<T>	Mutable Pair Implementation that
ObjectShortMutablePair<T>	Mutable Pair Implementation that
ObjectShortPair<T>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ObjectShortUnaryOperator<T>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ObjectSortedSet<T>	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
ObjectSplititerator<T>	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
ObjectSplititerators	Helper class that provides SplitIterators for normal and stream usage
ObjectStrategy<T>	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
ObjectStrategy.IdentityStrategy<T>	A Strategy that uses Identity HashCode instead of the normal hashing function.
ObjectStrategy.NormalStrategy<T>	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
ObjectSupplier<T>	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
ObjectTask<T>	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
Predicate<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
SanityChecks	Helper class that provides functions that are shared within the library.
Short2BooleanArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2BooleanAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2BooleanConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2BooleanConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2BooleanLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2BooleanLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2BooleanMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2BooleanMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2BooleanMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2BooleanMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2BooleanMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2BooleanMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2BooleanMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2BooleanMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2BooleanMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2BooleanMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2BooleanMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2BooleanMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2BooleanMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2BooleanMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2BooleanMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2BooleanMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2BooleanMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2BooleanMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2BooleanNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2BooleanOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2BooleanOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2BooleanOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2BooleanOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2BooleanRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2BooleanSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2BooleanSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ByteArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2ByteAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2ByteConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2ByteConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2ByteFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2ByteLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2ByteLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2ByteMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2ByteMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2ByteMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2ByteMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2ByteMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2ByteMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2ByteMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2ByteMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2ByteMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2ByteMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2ByteMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2ByteMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2ByteMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2ByteMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2ByteMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2ByteMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2ByteMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2ByteMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2ByteNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2ByteOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2ByteOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2ByteOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2ByteOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ByteRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2ByteSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2ByteSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2CharArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2CharAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2CharConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2CharConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2CharFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2CharLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2CharLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2CharMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2CharMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2CharMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2CharMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2CharMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2CharMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2CharMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2CharMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2CharMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2CharMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2CharMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2CharMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2CharMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2CharMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2CharMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2CharMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2CharMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2CharMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2CharNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2CharOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2CharOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2CharOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2CharOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2CharRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2CharSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2CharSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2DoubleArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2DoubleAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2DoubleConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2DoubleConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2DoubleFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2DoubleLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2DoubleLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2DoubleMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2DoubleMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2DoubleMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2DoubleMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2DoubleMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2DoubleMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2DoubleMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2DoubleMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2DoubleMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2DoubleMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2DoubleMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2DoubleMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2DoubleMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2DoubleMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2DoubleMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2DoubleMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2DoubleMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2DoubleMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2DoubleNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2DoubleOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2DoubleOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2DoubleOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2DoubleOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2DoubleRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2DoubleSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2DoubleSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2FloatArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2FloatAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2FloatConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2FloatConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2FloatFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2FloatLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2FloatLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2FloatMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2FloatMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2FloatMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2FloatMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2FloatMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2FloatMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2FloatMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2FloatMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2FloatMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2FloatMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2FloatMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2FloatMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2FloatMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2FloatMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2FloatMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2FloatMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2FloatMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2FloatMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2FloatNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2FloatOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2FloatOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2FloatOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2FloatOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2FloatRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2FloatSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2FloatSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2IntArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2IntAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2IntConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2IntConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2IntFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2IntLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2IntLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2IntMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2IntMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2IntMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2IntMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2IntMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2IntMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2IntMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2IntMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2IntMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2IntMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2IntMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2IntMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2IntMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2IntMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2IntMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2IntMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2IntMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2IntMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2IntNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2IntOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2IntOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2IntOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2IntOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2IntRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2IntSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2IntSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2LongArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2LongAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2LongConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2LongConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2LongFunction	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Short2LongLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2LongLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2LongMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2LongMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2LongMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2LongMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2LongMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2LongMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2LongMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2LongMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2LongMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2LongMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2LongMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2LongMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2LongMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2LongMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2LongMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2LongMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2LongMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2LongMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2LongNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2LongOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2LongOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2LongOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2LongOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2LongRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2LongSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2LongSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ObjectArrayMap<V>	A Very Specific Type Specific implementation of a ArrayMap.
Short2ObjectAVLTreeMap<V>	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2ObjectConcurrentMap<V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2ObjectConcurrentOpenHashMap<V>	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2ObjectLinkedOpenCustomHashMap<V>	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2ObjectLinkedOpenHashMap<V>	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2ObjectMap<V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2ObjectMap.BuilderCache<V>	Builder Cache for allowing to buildMaps
Short2ObjectMap.Entry<V>	Type Specific Map Entry that reduces boxing/unboxing
Short2ObjectMap.FastEntrySet<V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2ObjectMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2ObjectMaps.EmptyMap<V>	Empty Map impementation that is used for the emptyMap() function
Short2ObjectMaps.SingletonMap<V>	Singleton Map instance that is used in the helper method
Short2ObjectMaps.SynchronizedMap<V>	The Synchronized Map implementation used by the synchronizedMap helper function
Short2ObjectMaps.SynchronizedNavigableMap<V>	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2ObjectMaps.SynchronizedOrderedMap<V>	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2ObjectMaps.SynchronizedSortedMap<V>	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2ObjectMaps.UnmodifyableEntry<V>	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2ObjectMaps.UnmodifyableEntrySet<V>	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2ObjectMaps.UnmodifyableMap<V>	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2ObjectMaps.UnmodifyableNavigableMap<V>	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2ObjectMaps.UnmodifyableOrderedEntrySet<V>	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2ObjectMaps.UnmodifyableOrderedMap<V>	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2ObjectMaps.UnmodifyableSortedMap<V>	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2ObjectNavigableMap<V>	A Type Specific Navigable Map interface with a couple helper methods
Short2ObjectOpenCustomHashMap<V>	A Type Specific HashMap that allows for custom HashControl.
Short2ObjectOpenHashMap<V>	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2ObjectOrderedMap<V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2ObjectOrderedMap.FastOrderedSet<V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ObjectRBTreeMap<V>	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2ObjectSortedMap<V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2ObjectSortedMap.FastSortedSet<V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ShortArrayMap	A Very Specific Type Specific implementation of a ArrayMap.
Short2ShortAVLTreeMap	A Simple Type Specific AVL TreeMap implementation that reduces boxing/unboxing.
Short2ShortConcurrentMap	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Short2ShortConcurrentOpenHashMap	A TypeSpecific ConcurrentHashMap implementation that is based on Guavas approach and backing array implementations.
Short2ShortLinkedOpenCustomHashMap	A Type Specific LinkedHashMap that allows for custom HashControl.
Short2ShortLinkedOpenHashMap	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
Short2ShortMap	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Short2ShortMap.BuilderCache	Builder Cache for allowing to buildMaps
Short2ShortMap.Entry	Type Specific Map Entry that reduces boxing/unboxing
Short2ShortMap.FastEntrySet	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Short2ShortMaps	A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
Short2ShortMaps.EmptyMap	Empty Map impementation that is used for the emptyMap() function
Short2ShortMaps.SingletonMap	Singleton Map instance that is used in the helper method
Short2ShortMaps.SynchronizedMap	The Synchronized Map implementation used by the synchronizedMap helper function
Short2ShortMaps.SynchronizedNavigableMap	The Synchronized Navigable Map implementation used by the synchronizedMap helper function
Short2ShortMaps.SynchronizedOrderedMap	The Synchronized Ordered Map implementation used by the synchronizedMap helper function
Short2ShortMaps.SynchronizedSortedMap	The Synchronized Sorted Map implementation used by the synchronizedMap helper function
Short2ShortMaps.UnmodifyableEntry	The Unmodifyable Entry implementation for the helper function unmodifiableEntry()
Short2ShortMaps.UnmodifyableEntrySet	The Unmodifyable Set implementation for the Unmodifyable Map implementation
Short2ShortMaps.UnmodifyableMap	The Unmodifyable Map implementation that is sued for the unmodifyableMap function
Short2ShortMaps.UnmodifyableNavigableMap	The Unmodifyable Navigable Map implementation that is sued for the unmodifyableMap function
Short2ShortMaps.UnmodifyableOrderedEntrySet	The Unmodifyable Ordered Set implementation for the Unmodifyable Ordered Map implementation
Short2ShortMaps.UnmodifyableOrderedMap	The Unmodifyable Ordered Map implementation that is sued for the unmodifyableMap function
Short2ShortMaps.UnmodifyableSortedMap	The Unmodifyable Sorted Map implementation that is sued for the unmodifyableMap function
Short2ShortNavigableMap	A Type Specific Navigable Map interface with a couple helper methods
Short2ShortOpenCustomHashMap	A Type Specific HashMap that allows for custom HashControl.
Short2ShortOpenHashMap	A Type Specific Custom implementation of the HashMap Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys and values.
Short2ShortOrderedMap	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Short2ShortOrderedMap.FastOrderedSet	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Short2ShortRBTreeMap	A Simple Type Specific RB TreeMap implementation that reduces boxing/unboxing.
Short2ShortSortedMap	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Short2ShortSortedMap.FastSortedSet	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
ShortArrayFIFOQueue	A Simple First In First Out Priority Queue that is a Good Replacement for a linked list (or ArrayDequeue) Its specific implementation uses a backing array that grows and shrinks as it is needed.
ShortArrayList	A Type-Specific Array-based implementation of list that is written to reduce (un)boxing
ShortArrayPriorityQueue	A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases.
ShortArrays	A Helper class for Arrays
ShortArraySet	A Type Specific ArraySet implementation.
ShortAsyncBuilder	The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
ShortAsyncBuilder.BaseShortTask	Base Task of the Actions that can be performed.
ShortAVLTreeSet	A Simple Type Specific AVL TreeSet implementation that reduces boxing/unboxing.
ShortBidirectionalIterator	A Type-Specific ObjectBidirectionalIterator to reduce (un)boxing
ShortBooleanConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortBooleanImmutablePair	Mutable Pair Implementation that
ShortBooleanMutablePair	Mutable Pair Implementation that
ShortBooleanPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortBooleanUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortByteConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortByteImmutablePair	Mutable Pair Implementation that
ShortByteMutablePair	Mutable Pair Implementation that
ShortBytePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortByteUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortCharConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortCharImmutablePair	Mutable Pair Implementation that
ShortCharMutablePair	Mutable Pair Implementation that
ShortCharPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortCharUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortCollection	A Type-Specific Collection that reduces (un)boxing
ShortCollections	A Helper class for Collections
ShortCollections.EmptyCollection	Empty Collection implementation for the empty collection function
ShortCollections.SynchronizedCollection	Synchronized Collection Wrapper for the synchronizedCollection function
ShortCollections.UnmodifiableCollection	Unmodifyable Collection Wrapper for the unmodifyableCollection method
ShortComparator	Type-Specific Class for Comparator to reduce (un)boxing
ShortComparator.Reversed	A Type Specific Reversed Comparator to reduce boxing/unboxing
ShortConsumer	Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
ShortDoubleConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortDoubleImmutablePair	Mutable Pair Implementation that
ShortDoubleMutablePair	Mutable Pair Implementation that
ShortDoublePair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortDoubleUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortFloatConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortFloatImmutablePair	Mutable Pair Implementation that
ShortFloatMutablePair	Mutable Pair Implementation that
ShortFloatPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortFloatUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortFunction<V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ShortHeapPriorityQueue	A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations
ShortIntConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortIntImmutablePair	Mutable Pair Implementation that
ShortIntMutablePair	Mutable Pair Implementation that
ShortIntPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortIntUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortIterable	A Type-Specific Iterable that reduces (un)boxing
ShortIterables	A Helper class for Iterables
ShortIterator	A Type-Specific Iterator that reduces (un)boxing
ShortIterators	A Helper class for Iterators
ShortLinkedList	A Type-Specific LinkedList implementation of list that is written to reduce (un)boxing
ShortLinkedOpenCustomHashSet	A Type Specific LinkedHashSet that allows for custom HashControl.
ShortLinkedOpenHashSet	A Type Specific LinkedHashMap implementation that uses specific arrays to create links between nodes to remove the wrapping of elements to greatly reduce memory usage.
ShortList	A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
ShortListIterator	A Type Specific ListIterator that reduces boxing/unboxing
ShortLists	A Helper class for Lists
ShortLongConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortLongImmutablePair	Mutable Pair Implementation that
ShortLongMutablePair	Mutable Pair Implementation that
ShortLongPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortLongUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortNavigableSet	A Type Specific Navigable Set interface with a couple helper methods
ShortObjectConsumer<V>	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortObjectImmutablePair<V>	Mutable Pair Implementation that
ShortObjectMutablePair<V>	Mutable Pair Implementation that
ShortObjectPair<V>	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortObjectUnaryOperator<V>	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortOpenCustomHashSet	A Type Specific HashSet that allows for custom HashControl.
ShortOpenHashSet	A Type Specific Custom implementation of the HashSet Instead of using Wrapper Object Arrays for storing keys and values there is dedicated arrays for storing keys.
ShortOrderedSet	A Special Set Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
ShortPredicate	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ShortPriorityDequeue	A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
ShortPriorityQueue	A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
ShortPriorityQueues	A Helper class for PriorityQueues
ShortPriorityQueues.SynchronizedPriorityDequeue	Wrapper class for synchronization
ShortPriorityQueues.SynchronizedPriorityQueue	Wrapper class for synchronization
ShortRBTreeSet	A Simple Type Specific RB TreeSet implementation that reduces boxing/unboxing.
ShortSet	A Type Specific Set class to reduce boxing/unboxing
ShortSets	A Helper class for sets
ShortSets.UnmodifiableSet	Unmodifyable Set wrapper that helps is used with unmodifyableSet function
ShortShortConsumer	A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
ShortShortImmutablePair	Mutable Pair Implementation that
ShortShortMutablePair	Mutable Pair Implementation that
ShortShortPair	Key Value Pair Interface that allows to reduce boxing/unboxing.
ShortShortUnaryOperator	A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
ShortSortedSet	A Type Specific SortedSet implementation to reduce boxing/unboxing with a couple extra methods that allow greater control over sets.
ShortSplititerator	A Type Specific Split-Iterator that reduces boxing/unboxing It fills the gaps of the java and uses this collection interfaces
ShortSplititerators	Helper class that provides SplitIterators for normal and stream usage
ShortStack	A Type-Specific Stack that reduces (un)boxing
ShortStrategy	A Type Specific Strategy class that allows to give control hashcode generation and equals comparason for maps
ShortStrategy.NormalStrategy	A Strategy that simulates the normal Hash Collection Behavior if you want to use Hash Control Collections to replace normal ones.
ShortSupplier	Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
ShortTask	A Type Specific Task interface that allows you to keep track of the task that is currently running. It extends Runnable future and supports said functions but also provides quality of life functions like: - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed
ShortUnaryOperator	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
Stack<T>	The Stack Interface represents the Last-In-First-Out layout (LIFO).
ToByteFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToCharFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToDoubleFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToFloatFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToIntFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToLongFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
ToShortFunction<T>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
UnaryOperator<T,V>	A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.