Class IntIntHashMap

    • Field Detail


        public static final int DEFAULT_EXPECTED_ELEMENTS
        See Also:
        Constant Field Values

        public static final float MIN_LOAD_FACTOR
        Minimal sane load factor (99 empty slots per 100).
        See Also:
        Constant Field Values

        public static final float MAX_LOAD_FACTOR
        Maximum sane load factor (1 empty slot per 100).
        See Also:
        Constant Field Values

        public static final int MIN_HASH_ARRAY_LENGTH
        Minimum hash buffer size.
        See Also:
        Constant Field Values

        public static final int MAX_HASH_ARRAY_LENGTH
        Maximum array size for hash containers (power-of-two and still allocable in Java, not a negative int).
        See Also:
        Constant Field Values
      • keys

        public int[] keys
        The array holding keys.
      • values

        public int[] values
        The array holding values.
      • assigned

        protected int assigned
        The number of stored keys (assigned key slots), excluding the special "empty" key, if any (use size() instead).
        See Also:
      • mask

        protected int mask
        Mask for slot scans in keys.
      • resizeAt

        protected int resizeAt
        Expand (rehash) keys when assigned hits this value.
      • hasEmptyKey

        protected boolean hasEmptyKey
        Special treatment for the "empty slot" key marker.
      • loadFactor

        protected double loadFactor
        The load factor for keys.
      • iterationSeed

        protected int iterationSeed
        Seed used to ensure the hash iteration order is different from an iteration to another.
    • Constructor Detail

      • IntIntHashMap

        public IntIntHashMap()
        New instance with sane defaults.
      • IntIntHashMap

        public IntIntHashMap​(int expectedElements)
        New instance with sane defaults.
        expectedElements - The expected number of elements guaranteed not to cause buffer expansion (inclusive).
      • IntIntHashMap

        public IntIntHashMap​(int expectedElements,
                             double loadFactor)
        New instance with the provided defaults.
        expectedElements - The expected number of elements guaranteed not to cause a rehash (inclusive).
        loadFactor - The load factor for internal buffers. Insane load factors (zero, full capacity) are rejected by verifyLoadFactor(double).
    • Method Detail

      • put

        public int put​(int key,
                       int value)
      • putIfAbsent

        public boolean putIfAbsent​(int key,
                                   int value)
        Trove-inspired API method. An equivalent of the following code:
         if (!map.containsKey(key)) map.put(value);
        key - The key of the value to check.
        value - The value to put if key does not exist.
        true if key did not exist and value was placed in the map.
      • putOrAdd

        public int putOrAdd​(int key,
                            int putValue,
                            int incrementValue)
        If key exists, putValue is inserted into the map, otherwise any existing value is incremented by additionValue.
        key - The key of the value to adjust.
        putValue - The value to put if key does not exist.
        incrementValue - The value to add to the existing value if key exists.
        Returns the current value associated with key (after changes).
      • addTo

        public int addTo​(int key,
                         int incrementValue)
        Adds incrementValue to any existing value for the given key or inserts incrementValue if key did not previously exist.
        key - The key of the value to adjust.
        incrementValue - The value to put or add to the existing value if key exists.
        Returns the current value associated with key (after changes).
      • remove

        public int remove​(int key)
      • get

        public int get​(int key)
      • getOrDefault

        public int getOrDefault​(int key,
                                int defaultValue)
      • containsKey

        public boolean containsKey​(int key)
      • indexOf

        public int indexOf​(int key)
      • indexExists

        public boolean indexExists​(int index)
      • indexGet

        public int indexGet​(int index)
      • indexReplace

        public int indexReplace​(int index,
                                int newValue)
      • indexInsert

        public void indexInsert​(int index,
                                int key,
                                int value)
      • indexRemove

        public int indexRemove​(int index)
      • clear

        public void clear()
      • release

        public void release()
      • size

        public int size()
      • isEmpty

        public boolean isEmpty()
      • hashCode

        public int hashCode()
        hashCode in class Object
      • equalElements

        protected boolean equalElements​(IntIntHashMap other)
        Return true if all keys of some other container exist in this container.
      • ensureCapacity

        public void ensureCapacity​(int expectedElements)
        Ensure this container can hold at least the given number of keys (entries) without resizing its buffers.
        expectedElements - The total number of keys, inclusive.
      • nextIterationSeed

        protected int nextIterationSeed()
        Provides the next iteration seed used to build the iteration starting slot and offset increment. This method does not need to be synchronized, what matters is that each thread gets a sequence of varying seeds.
      • toString

        public String toString()
        Convert the contents of this map to a human-friendly string.
        toString in class Object
      • from

        public static IntIntHashMap from​(int[] keys,
                                         int[] values)
        Creates a hash map from two index-aligned arrays of key-value pairs.
      • hashKey

        protected int hashKey​(int key)
        Returns a hash code for the given key.

        The output from this function should evenly distribute keys across the entire integer range.

      • verifyLoadFactor

        protected double verifyLoadFactor​(double loadFactor)
        Validate load factor range and return it. Override and suppress if you need insane load factors.
      • rehash

        protected void rehash​(int[] fromKeys,
                              int[] fromValues)
        Rehash from old buffers to new buffers.
      • allocateBuffers

        protected void allocateBuffers​(int arraySize)
        Allocate new internal buffers. This method attempts to allocate and assign internal buffers atomically (either allocations succeed or not).
      • allocateThenInsertThenRehash

        protected void allocateThenInsertThenRehash​(int slot,
                                                    int pendingKey,
                                                    int pendingValue)
        This method is invoked when there is a new key/ value pair to be inserted into the buffers but there is not enough empty slots to do so.

        New buffers are allocated. If this succeeds, we know we can proceed with rehashing so we assign the pending element to the previous buffer (possibly violating the invariant of having at least one empty slot) and rehash all keys, substituting new buffers at the end.

      • shiftConflictingKeys

        protected void shiftConflictingKeys​(int gapSlot)
        Shift all the slot-conflicting keys and values allocated to (and including) slot.