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


Music Dashboard
You've stumbled upon a little dashboard I hacked together to show what I'm currently listening to! It's not much currently, but I hope to add more features, including integration of the last.fm API.
- Andrew
You've stumbled upon a little dashboard I hacked together to show what I'm currently listening to! It's not much currently, but I hope to add more features, including integration of the last.fm API.
- Andrew
Try reloading the page to see if that fixes it. If this error persists, let me know and I'll look into it!


Thank you for registering for HackCWRU 2017! You will hear more from us shortly.
Click the Spartan to take you back
If you are a high school student, please print this form
and bring it to check in.
We participate in Major League Hacking (MLH) as a MLH Member Event.
You authorize us to share certain application/registration information for event administration,
ranking, MLH administration, and occasional messages about hackathons in line with the
MLH Privacy Policy


{% extends "base.html" %} {% block content %}
Please provide a response
In the last 14 days, have you received a COVID Alert exposure notification on your cell phone?


Faster than Work Sheets
many questions for you
many questions for you
many questions for you
many questions for you
many questions for you
No stressing about whether everyone joined your video conference.
No stressing about whether everyone joined your video conference.
No stressing about whether everyone joined your video conference.
Choose from millions of free teacher-created quizzes or quickly make your own.
Choose from millions of free teacher-created quizzes or quickly make your own.
Choose from millions of free teacher-created quizzes or quickly make your own.
Assign e-learning with or without deadlines for asynchronous learning.
Use study tools like retakes and flashcards to help employees retain information over time.


Categorizing emails2
Thank you for your interest in participating in this experiment!
Please enter your Prolific ID. (Note: It can be found when going to your account info)


According to one or two of my correspondents, it is high time I injected some explicitly religious content into the Hooting Yard Advent Calendar. We have had a Mayan bat god, and Our Lady of the Arctic Wastes, but these are not enough for the more devout among my readers. Today, then, a picture which will I hope give rise to earnest discussions of faith, fury, and foolishness.


You need to enable JavaScript to run this app.
John Doe
Log Out
ADD YOUR WORKOUT
NOW!
#NOPAIN #NOGAIN
Couples retreat weekend
Save an extra 20%
when you buy 2 pairs of boots
Splash Chic
Women's Wet Gear
Kid Klimbers
Children's Gear
Pack It In
Camping Gear
Nature's AC
Men's Shorts
Trail Review
Trail Review
Asphalt
National Park
See Review


- Copy or move photos to another folder
You can specify sub folders and file names freely at shooting date etc.
- Change file date
Specified date and difference date can be set. It is effective when you forget to change the time zone of the camera.
- File creation date
- File modified date
- File access date
- Exif date
- Remove Exif data
- GPS data
- All Exif data


There are three doors. Behind two doors there are BAD THINGS. Behind one door is an AWESOME THING. Choose a door...


Kia Ora all! My name is Sebastian Chapman, but I normally go by Seb or Bas.
If you'd like to know a little about me head over to my about me page.
Or, get straight into reading one of the following blog posts!
- Identity, Values and Strengths Exploration
- What are the differences between relative, absolute, and fixed positioning?
- Learning plan
- HTML, CSS, JS, Frankenstein, and the DOM
- What is Emotional Intelligence?
- My Approach to problem solving.
- Neuroplasticity and Growth Mindset Blog
- Things I’ve learned about myself and my ego as a result of the core learning.


--- layout: default title: 404 - Page not found permalink: /404.html ---
Image found from VectorStock here. Check it out!


Coming Soon - Lightweight syntax highlighting outputting static HTML. No frontend bloat. (Gutenberg required).
Changing Times
As part of my life changing direction and my desire to work collaborating with others Kebo is transforming into my personal plugin repository. I will be reviewing and updating all the existing plugins, ensuring all are updated to make the most of Gutenberg.
This site will be replaced soon with a more permanent site, with dedicated documentation. I look forward to continuing to solve problems for, and to empower, the WordPress community.