All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.esotericsoftware.kryo.util.ObjectIntMap Maven / Gradle / Ivy

Go to download

Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC

There is a newer version: 3.40.2
Show newest version
/* Copyright (c) 2008-2023, Nathan Sweet
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
 * conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided with the distribution.
 * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

package com.esotericsoftware.kryo.util;

import static com.esotericsoftware.kryo.util.ObjectMap.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

import com.esotericsoftware.kryo.KryoException;

/** An unordered map where the keys are objects and the values are unboxed ints. Null keys are not allowed. No allocation is done
 * except when growing the table size.
 * 

* This class performs fast contains and remove (typically O(1), worst case O(n) but that is rare in practice). Add may be * slightly slower, depending on hash collisions. Hashcodes are rehashed to reduce collisions and the need to resize. Load factors * greater than 0.91 greatly increase the chances to resize to the next higher POT size. *

* Unordered sets and maps are not designed to provide especially fast iteration. Iteration is faster with OrderedSet and * OrderedMap. *

* This implementation uses linear probing with the backward shift algorithm for removal. Hashcodes are rehashed using Fibonacci * hashing, instead of the more common power-of-two mask, to better distribute poor hashCodes (see Malte * Skarupke's blog post). Linear probing continues to work even when all hashCodes collide, just more slowly. * @author Nathan Sweet * @author Tommy Ettinger */ public class ObjectIntMap implements Iterable> { public int size; K[] keyTable; int[] valueTable; float loadFactor; int threshold; /** Used by {@link #place(Object)} to bit shift the upper bits of a {@code long} into a usable range (>= 0 and <= * {@link #mask}). The shift can be negative, which is convenient to match the number of bits in mask: if mask is a 7-bit * number, a shift of -7 shifts the upper 7 bits into the lowest 7 positions. This class sets the shift > 32 and < 64, * which if used with an int will still move the upper bits of an int to the lower bits due to Java's implicit modulus on * shifts. *

* {@link #mask} can also be used to mask the low bits of a number, which may be faster for some hashcodes, if * {@link #place(Object)} is overridden. */ protected int shift; /** A bitmask used to confine hashcodes to the size of the table. Must be all 1 bits in its low positions, ie a power of two * minus 1. If {@link #place(Object)} is overridden, this can be used instead of {@link #shift} to isolate usable bits of a * hash. */ protected int mask; /** Creates a new map with an initial capacity of 51 and a load factor of 0.8. */ public ObjectIntMap () { this(51, 0.8f); } /** Creates a new map with a load factor of 0.8. * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */ public ObjectIntMap (int initialCapacity) { this(initialCapacity, 0.8f); } /** Creates a new map with the specified initial capacity and load factor. This map will hold initialCapacity items before * growing the backing table. * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */ public ObjectIntMap (int initialCapacity, float loadFactor) { if (loadFactor <= 0f || loadFactor >= 1f) throw new IllegalArgumentException("loadFactor must be > 0 and < 1: " + loadFactor); this.loadFactor = loadFactor; int tableSize = tableSize(initialCapacity, loadFactor); threshold = (int)(tableSize * loadFactor); mask = tableSize - 1; shift = Long.numberOfLeadingZeros(mask); keyTable = (K[])new Object[tableSize]; valueTable = new int[tableSize]; } /** Creates a new map identical to the specified map. */ public ObjectIntMap (ObjectIntMap map) { this((int)(map.keyTable.length * map.loadFactor), map.loadFactor); System.arraycopy(map.keyTable, 0, keyTable, 0, map.keyTable.length); System.arraycopy(map.valueTable, 0, valueTable, 0, map.valueTable.length); size = map.size; } /** Returns an index >= 0 and <= {@link #mask} for the specified {@code item}. *

* The default implementation uses Fibonacci hashing on the item's {@link Object#hashCode()}: the hashcode is multiplied by a * long constant (2 to the 64th, divided by the golden ratio) then the uppermost bits are shifted into the lowest positions to * obtain an index in the desired range. Multiplication by a long may be slower than int (eg on GWT) but greatly improves * rehashing, allowing even very poor hashcodes, such as those that only differ in their upper bits, to be used without high * collision rates. Fibonacci hashing has increased collision rates when all or most hashcodes are multiples of larger * Fibonacci numbers (see Malte * Skarupke's blog post). *

* This method can be overriden to customizing hashing. This may be useful eg in the unlikely event that most hashcodes are * Fibonacci numbers, if keys provide poor or incorrect hashcodes, or to simplify hashing if keys provide high quality * hashcodes and don't need Fibonacci hashing: {@code return item.hashCode() & mask;} */ protected int place (K item) { return (int)(item.hashCode() * 0x9E3779B97F4A7C15L >>> shift); } /** Returns the index of the key if already present, else -(index + 1) for the next empty index. This can be overridden in this * package to compare for equality differently than {@link Object#equals(Object)}. */ int locateKey (K key) { if (key == null) throw new IllegalArgumentException("key cannot be null."); K[] keyTable = this.keyTable; for (int i = place(key);; i = i + 1 & mask) { K other = keyTable[i]; if (other == null) return -(i + 1); // Empty space is available. if (other.equals(key)) return i; // Same key was found. } } /** Doesn't return a value, unlike other maps. */ public void put (K key, int value) { int i = locateKey(key); if (i >= 0) { // Existing key was found. valueTable[i] = value; return; } i = -(i + 1); // Empty space was found. keyTable[i] = key; valueTable[i] = value; if (++size >= threshold) resize(keyTable.length << 1); } public void putAll (ObjectIntMap map) { ensureCapacity(map.size); K[] keyTable = map.keyTable; int[] valueTable = map.valueTable; K key; for (int i = 0, n = keyTable.length; i < n; i++) { key = keyTable[i]; if (key != null) put(key, valueTable[i]); } } /** Skips checks for existing keys, doesn't increment size. */ private void putResize (K key, int value) { K[] keyTable = this.keyTable; for (int i = place(key);; i = (i + 1) & mask) { if (keyTable[i] == null) { keyTable[i] = key; valueTable[i] = value; return; } } } /** Returns the value for the specified key, or the default value if the key is not in the map. */ public int get (K key, int defaultValue) { int i = locateKey(key); return i < 0 ? defaultValue : valueTable[i]; } /** Returns the key's current value and increments the stored value. If the key is not in the map, defaultValue + increment is * put into the map and defaultValue is returned. */ public int getAndIncrement (K key, int defaultValue, int increment) { int i = locateKey(key); if (i >= 0) { // Existing key was found. int oldValue = valueTable[i]; valueTable[i] += increment; return oldValue; } i = -(i + 1); // Empty space was found. keyTable[i] = key; valueTable[i] = defaultValue + increment; if (++size >= threshold) resize(keyTable.length << 1); return defaultValue; } public int remove (K key, int defaultValue) { int i = locateKey(key); if (i < 0) return defaultValue; K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; int oldValue = valueTable[i]; int mask = this.mask, next = i + 1 & mask; while ((key = keyTable[next]) != null) { int placement = place(key); if ((next - placement & mask) > (i - placement & mask)) { keyTable[i] = key; valueTable[i] = valueTable[next]; i = next; } next = next + 1 & mask; } keyTable[i] = null; size--; return oldValue; } /** Returns true if the map has one or more items. */ public boolean notEmpty () { return size > 0; } /** Returns true if the map is empty. */ public boolean isEmpty () { return size == 0; } /** Reduces the size of the backing arrays to be the specified capacity / loadFactor, or less. If the capacity is already less, * nothing is done. If the map contains more items than the specified capacity, the next highest power of two capacity is used * instead. */ public void shrink (int maximumCapacity) { if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity); int tableSize = tableSize(maximumCapacity, loadFactor); if (keyTable.length > tableSize) resize(tableSize); } /** Clears the map and reduces the size of the backing arrays to be the specified capacity / loadFactor, if they are larger. */ public void clear (int maximumCapacity) { int tableSize = tableSize(maximumCapacity, loadFactor); if (keyTable.length <= tableSize) { clear(); return; } size = 0; resize(tableSize); } public void clear () { if (size == 0) return; size = 0; Arrays.fill(keyTable, null); } /** Returns true if the specified value is in the map. Note this traverses the entire map and compares every value, which may * be an expensive operation. */ public boolean containsValue (int value) { K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; for (int i = valueTable.length - 1; i >= 0; i--) if (keyTable[i] != null && valueTable[i] == value) return true; return false; } public boolean containsKey (K key) { return locateKey(key) >= 0; } /** Returns the key for the specified value, or null if it is not in the map. Note this traverses the entire map and compares * every value, which may be an expensive operation. */ @Null public K findKey (int value) { K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; for (int i = valueTable.length - 1; i >= 0; i--) { K key = keyTable[i]; if (key != null && valueTable[i] == value) return key; } return null; } /** Increases the size of the backing array to accommodate the specified number of additional items / loadFactor. Useful before * adding many items to avoid multiple backing array resizes. */ public void ensureCapacity (int additionalCapacity) { int tableSize = tableSize(size + additionalCapacity, loadFactor); if (keyTable.length < tableSize) resize(tableSize); } final void resize (int newSize) { int oldCapacity = keyTable.length; threshold = (int)(newSize * loadFactor); mask = newSize - 1; shift = Long.numberOfLeadingZeros(mask); K[] oldKeyTable = keyTable; int[] oldValueTable = valueTable; keyTable = (K[])new Object[newSize]; valueTable = new int[newSize]; if (size > 0) { for (int i = 0; i < oldCapacity; i++) { K key = oldKeyTable[i]; if (key != null) putResize(key, oldValueTable[i]); } } } public int hashCode () { int h = size; K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; for (int i = 0, n = keyTable.length; i < n; i++) { K key = keyTable[i]; if (key != null) h += key.hashCode() + valueTable[i]; } return h; } public boolean equals (Object obj) { if (obj == this) return true; if (!(obj instanceof ObjectIntMap)) return false; ObjectIntMap other = (ObjectIntMap)obj; if (other.size != size) return false; K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; for (int i = 0, n = keyTable.length; i < n; i++) { K key = keyTable[i]; if (key != null) { int otherValue = other.get(key, 0); if (otherValue == 0 && !other.containsKey(key)) return false; if (otherValue != valueTable[i]) return false; } } return true; } public String toString (String separator) { return toString(separator, false); } public String toString () { return toString(", ", true); } private String toString (String separator, boolean braces) { if (size == 0) return braces ? "{}" : ""; java.lang.StringBuilder buffer = new java.lang.StringBuilder(32); if (braces) buffer.append('{'); K[] keyTable = this.keyTable; int[] valueTable = this.valueTable; int i = keyTable.length; while (i-- > 0) { K key = keyTable[i]; if (key == null) continue; buffer.append(key); buffer.append('='); buffer.append(valueTable[i]); break; } while (i-- > 0) { K key = keyTable[i]; if (key == null) continue; buffer.append(separator); buffer.append(key); buffer.append('='); buffer.append(valueTable[i]); } if (braces) buffer.append('}'); return buffer.toString(); } public Entries iterator () { return entries(); } /** Returns an iterator for the entries in the map. Remove is supported. */ public Entries entries () { return new Entries(this); } /** Returns an iterator for the values in the map. Remove is supported. */ public Values values () { return new Values(this); } /** Returns an iterator for the keys in the map. Remove is supported. */ public Keys keys () { return new Keys(this); } public static class Entry { public K key; public int value; public String toString () { return key + "=" + value; } } private static class MapIterator { public boolean hasNext; final ObjectIntMap map; int nextIndex, currentIndex; boolean valid = true; public MapIterator (ObjectIntMap map) { this.map = map; reset(); } public void reset () { currentIndex = -1; nextIndex = -1; findNextIndex(); } void findNextIndex () { K[] keyTable = map.keyTable; for (int n = keyTable.length; ++nextIndex < n;) { if (keyTable[nextIndex] != null) { hasNext = true; return; } } hasNext = false; } public void remove () { int i = currentIndex; if (i < 0) throw new IllegalStateException("next must be called before remove."); K[] keyTable = map.keyTable; int[] valueTable = map.valueTable; int mask = map.mask, next = i + 1 & mask; K key; while ((key = keyTable[next]) != null) { int placement = map.place(key); if ((next - placement & mask) > (i - placement & mask)) { keyTable[i] = key; valueTable[i] = valueTable[next]; i = next; } next = next + 1 & mask; } keyTable[i] = null; map.size--; if (i != currentIndex) --nextIndex; currentIndex = -1; } } public static class Entries extends MapIterator implements Iterable>, Iterator> { Entry entry = new Entry(); public Entries (ObjectIntMap map) { super(map); } /** Note the same entry instance is returned each time this method is called. */ public Entry next () { if (!hasNext) throw new NoSuchElementException(); if (!valid) throw new KryoException("#iterator() cannot be used nested."); K[] keyTable = map.keyTable; entry.key = keyTable[nextIndex]; entry.value = map.valueTable[nextIndex]; currentIndex = nextIndex; findNextIndex(); return entry; } public boolean hasNext () { if (!valid) throw new KryoException("#iterator() cannot be used nested."); return hasNext; } public Entries iterator () { return this; } } public static class Values extends MapIterator { public Values (ObjectIntMap map) { super((ObjectIntMap)map); } public boolean hasNext () { if (!valid) throw new KryoException("#iterator() cannot be used nested."); return hasNext; } public int next () { if (!hasNext) throw new NoSuchElementException(); if (!valid) throw new KryoException("#iterator() cannot be used nested."); int value = map.valueTable[nextIndex]; currentIndex = nextIndex; findNextIndex(); return value; } public Values iterator () { return this; } /** Returns a new array containing the remaining values. */ public IntArray toArray () { IntArray array = new IntArray(true, map.size); while (hasNext) array.add(next()); return array; } /** Adds the remaining values to the specified array. */ public IntArray toArray (IntArray array) { while (hasNext) array.add(next()); return array; } } public static class Keys extends MapIterator implements Iterable, Iterator { public Keys (ObjectIntMap map) { super(map); } public boolean hasNext () { if (!valid) throw new KryoException("#iterator() cannot be used nested."); return hasNext; } public K next () { if (!hasNext) throw new NoSuchElementException(); if (!valid) throw new KryoException("#iterator() cannot be used nested."); K key = map.keyTable[nextIndex]; currentIndex = nextIndex; findNextIndex(); return key; } public Keys iterator () { return this; } /** Returns a new list containing the remaining keys. */ public ArrayList toList () { return toList(new ArrayList(map.size)); } /** Adds the remaining keys to the list. */ public > T toList (T array) { while (hasNext) array.add(next()); return array; } } }