update 3rd party libs

Had to disable java.modularity.inferModulePath, because JUnit
was put on the module path and didn't want to start (class not
found). Probably because I didn't have a module-info.java.

build.gradle

@@ -4,32 +4,39 @@ buildscript {
     maven {
       url "https://plugins.gradle.org/m2/"
     }
-    jcenter()
   }
   dependencies {
     // run with Java 11 and ./gradlew --no-daemon clean jmh
-    classpath "me.champeau.gradle:jmh-gradle-plugin:0.5.2"
+    classpath "me.champeau.gradle:jmh-gradle-plugin:0.5.3"
   }
 }
 
 plugins {
   // usage: gradle dependencyUpdates -Drevision=release
-  id "com.github.ben-manes.versions" version "0.36.0"
+  id "com.github.ben-manes.versions" version "0.39.0"
 }
 
 apply plugin: 'java'
 apply plugin: 'eclipse'
 
+
+ext {
+  javaVersion=11
+  version_junit = '5.7.2'
+  version_junit_platform = '1.7.2'
+}
+
+
 // java compatibility version
-sourceCompatibility = 11
+sourceCompatibility = javaVersion
 
 /*
  * The shared configuration for all sub-projects:
  */
 subprojects {
-	apply plugin: 'java'
+	apply plugin: 'java-library'
 	apply plugin: 'eclipse'
-	apply plugin: 'maven'
+	//apply plugin: 'maven'
 	apply plugin: 'maven-publish'
 	apply plugin: 'me.champeau.gradle.jmh'
 
@@ -71,14 +78,20 @@ subprojects {
 	
 	java {
 		withSourcesJar()
+		
+		// Gradle 7.0 put half the dependencies on the module path. But without a module-info.java file 
+		// JUnit didn't want to run because of a class not found error. By disabling modules we ensure
+		// all jars are put on the classpath.
+		modularity.inferModulePath.set(false)
 	}
 
 		
 	// dependencies that all sub-projects have 
 	dependencies {
-		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
+		testImplementation "org.junit.jupiter:junit-jupiter-api:${version_junit}"
-    	testRuntime 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
+		testImplementation "org.junit.jupiter:junit-jupiter-params:${version_junit}"  // for @ParameterizedTest
-    	testRuntime 'org.junit.platform:junit-platform-launcher:1.7.0' // needed by eclipse
+    	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${version_junit}"
+    	testRuntimeOnly "org.junit.platform:junit-platform-launcher:${version_junit_platform}" // needed by eclipse
 	}
 	
 	test {
@@ -94,5 +107,5 @@ subprojects {
 }
 
 wrapper {
-	gradleVersion = '6.8.3'
+	gradleVersion = '7.1.1'
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -72,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )

primitiveCollections/build.gradle

@@ -1,6 +1,6 @@
 
 group='org.lucares'
-version = '0.2'
+version = '0.3'
 
 dependencies {
 	jmh 'org.eclipse.collections:eclipse-collections:10.2.0'

primitiveCollections/src/main/java/org/lucares/collections/BiLongFunction.java

@@ -0,0 +1,6 @@
+package org.lucares.collections;
+
+@FunctionalInterface
+public interface BiLongFunction {
+	long apply(long key, long value);
+}

primitiveCollections/src/main/java/org/lucares/collections/LongFunction.java

@@ -1,6 +0,0 @@
-package org.lucares.collections;
-
-@FunctionalInterface
-public interface LongFunction {
-	long apply(long value);
-}

primitiveCollections/src/main/java/org/lucares/collections/LongLongHashMap.java

@@ -1,5 +1,6 @@
 package org.lucares.collections;
 
+
 import java.util.Arrays;
 
 /**
@@ -12,7 +13,13 @@ public class LongLongHashMap {
 	// There is no equivalent to null for primitive values. Therefore we have to add
 	// special handling for one long value. Otherwise we couldn't tell if a key is
 	// in the map or not. We chose 0L, because LongList is initially all 0L.
-	private static final long NULL_KEY = 0L;
+	static final long NULL_KEY = 0L;
+	
+	// Needed when checking for the existence of a key. Without it we would be forced to
+	// iterate over all keys. This is caused by the fact that we search for the next free
+	// slot when adding new keys. 
+	// We rely on the fact that the value is -1!
+	static final long REMOVED_KEY = -1L;
 
 	private static final long EMPTY_SLOT = 0L;
 
@@ -27,14 +34,26 @@ public class LongLongHashMap {
 	private long[] values;
 	private int size = 0;
 
+	/**
+	 *  sentinel for the key {@value #NULL_KEY} ({@link #NULL_KEY}). 
+	 *  If this field is not null, then the map contains the key {@value #NULL_KEY} 
+	 */
 	private Long zeroValue = null;
 	
+	/**
+	 *  sentinel for the key {@value #REMOVED_KEY} ({@link #REMOVED_KEY}). 
+	 *  If this field is not null, then the map contains the key {@value #REMOVED_KEY} 
+	 */
+	private Long removedKeyValue = null;
+
+	private int maxCapacity = MAX_ARRAY_SIZE;
+
 	/**
 	 * Create a new {@link LongLongHashMap} with the given initial capacity and load
 	 * factor.
 	 *
 	 * @param initialCapacity the initial capacity
-	 * @param loadFactor      the load factor
+	 * @param loadFactor      the load factor between 0 and 1
 	 */
 	public LongLongHashMap(final int initialCapacity, final double loadFactor) {
 
@@ -44,8 +63,9 @@ public class LongLongHashMap {
 		if (initialCapacity > MAX_ARRAY_SIZE) {
 			throw new IllegalArgumentException("initial capacity must be smaller or equal to " + MAX_ARRAY_SIZE);
 		}
-		if (loadFactor <= 0 || Double.isNaN(loadFactor))
+		if (loadFactor <= 0 || Double.isNaN(loadFactor) || loadFactor >= 1.0) {
-			throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
+			throw new IllegalArgumentException("Illegal load factor, must be between 0 and 1: " + loadFactor);
+		}
 
 		this.fillFactor = loadFactor;
 		keys = new long[initialCapacity];
@@ -60,6 +80,30 @@ public class LongLongHashMap {
 		this(8, 0.75);
 	}
 
+
+	/**
+	 * Sets the maximum capacity.<p>
+	 * This restricts the maximum memory used by this map. The memory consumption can be twice as much during grow or shrink phases.
+	 * <p>
+	 * Note that the performance can suffer if the map contains more keys than capacity time loadFactor.
+	 * <p>
+	 * Note an automatic {@link #rehash()} is triggered if the new maxCapacity is smaller than the current capacity. 
+	 * But there is not automatic rehash when the new maxCapacity is greater than the current capacity. 
+	 * 
+	 * @param maxCapacity new maximum capacity
+	 * @throws IllegalArgumentException if {@code maxCapacity} is smaller than {@link #size()}
+	 */
+	public void setMaxCapacity(int maxCapacity) {
+		if (maxCapacity < size) {
+			throw new IllegalArgumentException("maxCapacity must equal or larger than current size of the map");
+		}
+		this.maxCapacity = maxCapacity;
+		
+		if (maxCapacity < keys.length) {			
+			rehash(maxCapacity);
+		}
+	}
+
 	/**
 	 * The number of entries in this map.
 	 *
@@ -69,6 +113,49 @@ public class LongLongHashMap {
 		return size;
 	}
 	
+	@Override
+	public String toString() {
+		
+		StringBuilder s = new StringBuilder();
+		
+		if (zeroValue != null) {
+			s.append(NULL_KEY);
+			s.append("=");
+			s.append(zeroValue);
+		}
+		if (removedKeyValue != null) {
+			if (s.length() > 0) {
+				s.append(", ");
+			}
+			s.append(REMOVED_KEY);
+			s.append("=");
+			s.append(removedKeyValue);
+		}
+
+		int values = 0;
+		
+		for (int i = 0; i < keys.length; i++) {
+			if (keys[i] != EMPTY_SLOT && keys[i] != REMOVED_KEY) {
+				if (s.length() > 0) {
+					s.append(", ");
+				}
+				s.append(keys[i]);
+				s.append("=");
+				s.append(this.values[i]);
+				
+				values++;
+				if (values > 10) {
+					s.append(", ...");
+					break;
+				}
+			}
+		}
+		
+		
+		
+		return s.toString();
+	}
+
 	/**
 	 * The capacity of this map.
 	 *
@@ -83,15 +170,26 @@ public class LongLongHashMap {
 	 *
 	 * @param key   the key
 	 * @param value the value
+	 * @throws IllegalStateException if the map is full, see {@link #setMaxCapacity(int)}
 	 */
 	public void put(final long key, final long value) {
 
+		if (size == maxCapacity) {
+			throw new IllegalStateException("map is full");
+		}
+		
 		if (key == NULL_KEY) {
 			size += zeroValue == null ? 1 : 0;
 			zeroValue = value;
 			return;
 		}
 		
+		if (key == REMOVED_KEY) {
+			size += removedKeyValue == null ? 1 : 0;
+			removedKeyValue = value;
+			return;
+		}
+
 		if ((keys.length * fillFactor) < size) {
 			growAndRehash();
 		}
@@ -122,7 +220,13 @@ public class LongLongHashMap {
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
 
-		throw new IllegalStateException("map is full");
+		// Can happen when all slots where occupied at some time in the past.
+		// Easy to reproduce by adding and immediately removing all keys from 1 to n.
+		// All slots will be marked with REMOVED_KEY.
+		// We fix this by calling rehash(), which will effectively replace all REMOVED_KEY 
+		// with EMPTY_SLOT.
+		rehash();
+		return putInternal(key, value);
 	}
 
 	/**
@@ -140,16 +244,24 @@ public class LongLongHashMap {
 			}
 			return defaultValue;
 		}
+		if (key == REMOVED_KEY) {
+			if (removedKeyValue != null) {
+				return removedKeyValue;
+			}
+			return defaultValue;
+		}
 
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
 			if (keys[currentPosition] == key) {
 				return values[currentPosition];
+			} else if (keys[currentPosition] == EMPTY_SLOT) {
+				return defaultValue;
 			}
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
-		return defaultValue;
+		return defaultValue;// should never be reached unless the map is full at 100%, which should be impossible with loadFactor < 1.0
 	}
 
 	/**
@@ -163,16 +275,21 @@ public class LongLongHashMap {
 		if (key == NULL_KEY) {
 			return zeroValue != null;
 		}
+		if (key == REMOVED_KEY) {
+			return removedKeyValue != null;
+		}
 
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
 			if (keys[currentPosition] == key) {
 				return true;
+			} else if (keys[currentPosition] == EMPTY_SLOT) {
+				return false;
 			}
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart); 
-		return false;
+		return false;// should never be reached unless the map is full at 100%, which should be impossible with loadFactor < 1.0
 	}
 
 	/**
@@ -187,17 +304,25 @@ public class LongLongHashMap {
 			zeroValue = null;
 			return;
 		}
+		if (key == REMOVED_KEY) {
+			size -= removedKeyValue != null ? 1 : 0;
+			removedKeyValue = null;
+			return;
+		}
 
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
 			if (keys[currentPosition] == key) {
-				keys[currentPosition] = EMPTY_SLOT;
+				keys[currentPosition] = REMOVED_KEY;
 				size--;
 				return;
+			}else if (keys[currentPosition] == EMPTY_SLOT) {
+				// key didn't exists
+				return;
 			}
 			currentPosition = (currentPosition + 1) % keys.length;
-		} while (currentPosition != searchStart);
+		} while (currentPosition != searchStart); // run around should never happen unless the map is full at 100%
 	}
 
 	/**
@@ -213,13 +338,21 @@ public class LongLongHashMap {
 	 *                             key
 	 * @param function             called to update an existing value
 	 */
-	public void compute(final long key, final long initialValueIfAbsent, final LongFunction function) {
+	public void compute(final long key, final long initialValueIfAbsent, final BiLongFunction function) {
 		if (key == NULL_KEY) {
 			if (zeroValue != null) {
-				zeroValue = function.apply(zeroValue);
+				zeroValue = function.apply(NULL_KEY,zeroValue);
 				return;
 			}
-			zeroValue = function.apply(initialValueIfAbsent);
+			zeroValue = function.apply(NULL_KEY,initialValueIfAbsent);
+			return;
+		}
+		if (key == REMOVED_KEY) {
+			if (removedKeyValue != null) {
+				removedKeyValue = function.apply(REMOVED_KEY, removedKeyValue);
+				return;
+			}
+			removedKeyValue = function.apply(REMOVED_KEY, initialValueIfAbsent);
 			return;
 		}
 
@@ -227,15 +360,19 @@ public class LongLongHashMap {
 		int currentPosition = searchStart;
 		do {
 			if (keys[currentPosition] == key) {
-				final long updatedValue = function.apply(values[currentPosition]);
+				final long updatedValue = function.apply(key, values[currentPosition]);
 				values[currentPosition] = updatedValue;
 				return;
 			}
+			else if (keys[currentPosition] == EMPTY_SLOT) {
+				// key not found
+				break;
+			}
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
 
 		// key not found -> add it
-		final long newZeroValue = function.apply(initialValueIfAbsent);
+		final long newZeroValue = function.apply(key, initialValueIfAbsent);
 		put(key, newZeroValue);
 	}
 
@@ -249,11 +386,14 @@ public class LongLongHashMap {
 	public void forEach(final LongLongConsumer consumer) {
 
 		if (zeroValue != null) {
-			consumer.accept(0, zeroValue);
+			consumer.accept(NULL_KEY, zeroValue);
+		}
+		if (removedKeyValue != null) {
+			consumer.accept(REMOVED_KEY, removedKeyValue);
 		}
 
 		for (int i = 0; i < keys.length; i++) {
-			if (keys[i] != EMPTY_SLOT) {
+			if (keys[i] != EMPTY_SLOT && keys[i] != REMOVED_KEY) {
 				consumer.accept(keys[i], values[i]);
 			}
 		}
@@ -268,25 +408,35 @@ public class LongLongHashMap {
 	 * @param consumer the consumer
 	 */
 	public void forEachOrdered(final LongLongConsumer consumer) {
-
-		if (zeroValue != null) {
-			consumer.accept(0, zeroValue);
-		}
-
 		final long[] sortedKeys = Arrays.copyOf(keys, keys.length);
 		Arrays.parallelSort(sortedKeys);
 
+		// handle negative keys
 		for (int i = 0; i < sortedKeys.length; i++) {
 			final long key = sortedKeys[i];
-			if (key != EMPTY_SLOT) {
+			if (key < REMOVED_KEY) {
 				consumer.accept(key, get(key, 0)); // the default value of 'get' will not be used, because the key exists
-			} else if (key == EMPTY_SLOT) {
+			} else {
+				break;
+			}
+		}
+		
+		// handle the special keys
+		if (removedKeyValue != null) {
+			consumer.accept(REMOVED_KEY, removedKeyValue);
+		}
+		if (zeroValue != null) {
+			consumer.accept(NULL_KEY, zeroValue);
+		}
+		
+		// handle positive keys
 		final int posFirstKey = findPosOfFirstPositiveKey(sortedKeys);
 		if (posFirstKey < 0) {
 			return;
 		}
-				i = posFirstKey - 1;
+		for (int i = posFirstKey; i < sortedKeys.length; i++) {
-			}
+			final long key = sortedKeys[i];
+			consumer.accept(key, get(key, 0)); // the default value of 'get' will not be used, because the key exists
 		}
 	}
 
@@ -319,18 +469,31 @@ public class LongLongHashMap {
 		return low < sortedKeys.length && sortedKeys[low] > EMPTY_SLOT ? low : -1;
 	}
 	
+	/**
+	 * Rehashes all elements of this map.
+	 * <p>
+	 * This is a maintenance operation that should be executed periodically after removing elements.
+	 */
+	public void rehash() {
+		rehash(keys.length);
+	}
+
 	private void growAndRehash() {
+		final int newSize = Math.min(keys.length * 2, maxCapacity);
+		if(newSize != keys.length) {
+			rehash(newSize);
+		}
+	}
+
+	private void rehash(int newSize) {
 		final long[] oldKeys = keys;
 		final long[] oldValues = values;
-
-		final int newSize = Math.min(keys.length * 2, MAX_ARRAY_SIZE);
-
 		keys = new long[newSize];
 		values = new long[newSize];
 
 		for (int i = 0; i < oldKeys.length; i++) {
 			final long key = oldKeys[i];
-			if (key != EMPTY_SLOT) {
+			if (key != EMPTY_SLOT && key != REMOVED_KEY) {
 				final long value = oldValues[i];
 				putInternal(key, value);
 			}

primitiveCollections/src/main/java/org/lucares/collections/LongObjHashMap.java

@@ -14,7 +14,12 @@ public class LongObjHashMap<V> {
 	// There is no equivalent to null for primitive values. Therefore we have to add
 	// special handling for one long value. Otherwise we couldn't tell if a key is
 	// in the map or not. We chose 0L, because LongList is initially all 0L.
-	private static final long NULL_KEY = 0L;
+	static final long NULL_KEY = 0L;
+	
+	// Needed when checking for the existence of a key. Without it we would be forced to
+	// iterate over all keys. This is caused by the fact that we search for the next free
+	// slot when adding new keys. 
+	static final long REMOVED_KEY = -1L;
 
 	private static final long EMPTY_SLOT = 0L;
 
@@ -30,6 +35,7 @@ public class LongObjHashMap<V> {
 	private int size = 0;
 
 	private V zeroValue = null;
+	private V removedValue = null;
 
 	/**
 	 * Create a new {@link LongLongHashMap} with the given initial capacity and load
@@ -47,7 +53,7 @@ public class LongObjHashMap<V> {
 		if (initialCapacity > MAX_ARRAY_SIZE) {
 			throw new IllegalArgumentException("initial capacity must be smaller or equal to " + MAX_ARRAY_SIZE);
 		}
-		if (loadFactor <= 0 || Double.isNaN(loadFactor))
+		if (loadFactor <= 0 || Double.isNaN(loadFactor) || loadFactor >= 1.0)
 			throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
 
 		this.fillFactor = loadFactor;
@@ -94,6 +100,11 @@ public class LongObjHashMap<V> {
 			zeroValue = value;
 			return;
 		}
+		if (key == REMOVED_KEY) {
+			size += removedValue == null ? 1 : 0;
+			removedValue = value;
+			return;
+		}
 
 		if ((keys.length * fillFactor) < size) {
 			growAndRehash();
@@ -125,7 +136,13 @@ public class LongObjHashMap<V> {
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
 
-		throw new IllegalStateException("map is full");
+		// Can happen when all slots where occupied at some time in the past.
+		// Easy to reproduce by adding and immediately removing all keys from 1 to n.
+		// All slots will be marked with REMOVED_KEY.
+		// We fix this by calling rehash(), which will effectively replace all REMOVED_KEY 
+		// with EMPTY_SLOT.
+		rehash();
+		return putInternal(key, value);
 	}
 
 	/**
@@ -145,6 +162,13 @@ public class LongObjHashMap<V> {
 			return null;
 		}
 		
+		if (key == REMOVED_KEY) {
+			if (removedValue != null) {
+				return removedValue;
+			}
+			return null;
+		}
+
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
@@ -168,6 +192,10 @@ public class LongObjHashMap<V> {
 			return zeroValue != null;
 		}
 		
+		if (key == REMOVED_KEY) {
+			return zeroValue != null;
+		}
+
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
@@ -176,6 +204,14 @@ public class LongObjHashMap<V> {
 			}
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
+		
+		// Can happen when all slots where occupied at some time in the past.
+		// Easy to reproduce by adding and immediately removing all keys from 1 to n.
+		// All slots will be marked with REMOVED_KEY.
+		// We fix this by calling rehash(), which will effectively replace all REMOVED_KEY 
+		// with EMPTY_SLOT.
+		rehash();
+		
 		return false;
 	}
 
@@ -192,16 +228,35 @@ public class LongObjHashMap<V> {
 			return;
 		}
 		
+		if (key == REMOVED_KEY) {
+			size -= removedValue != null ? 1 : 0;
+			removedValue = null;
+			return;
+		}
+
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
 			if (keys[currentPosition] == key) {
-				keys[currentPosition] = EMPTY_SLOT;
+				keys[currentPosition] = REMOVED_KEY;
 				size--;
 				return;
 			}
+			
+			if (keys[currentPosition] == EMPTY_SLOT) {
+				// key does not exist
+				return;
+			}
+			
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
+
+		// Can happen when all slots where occupied at some time in the past.
+		// Easy to reproduce by adding and immediately removing all keys from 1 to n.
+		// All slots will be marked with REMOVED_KEY.
+		// We fix this by calling rehash(), which will effectively replace all REMOVED_KEY 
+		// with EMPTY_SLOT.
+		rehash();
 	}
 
 	/**
@@ -227,6 +282,15 @@ public class LongObjHashMap<V> {
 			return;
 		}
 		
+		if (key == REMOVED_KEY) {
+			if (removedValue != null) {
+				removedValue = function.apply(REMOVED_KEY, removedValue);
+				return;
+			}
+			removedValue = function.apply(REMOVED_KEY, initialValueIfAbsent.get());
+			return;
+		}
+
 		final int searchStart = spread(key);
 		int currentPosition = searchStart;
 		do {
@@ -235,6 +299,10 @@ public class LongObjHashMap<V> {
 				values[currentPosition] = updatedValue;
 				return;
 			}
+			if (keys[currentPosition] == EMPTY_SLOT) {
+				// key does not exist
+				break;
+			}
 			currentPosition = (currentPosition + 1) % keys.length;
 		} while (currentPosition != searchStart);
 
@@ -253,11 +321,15 @@ public class LongObjHashMap<V> {
 	public void forEach(final LongObjConsumer<V> consumer) {
 
 		if (zeroValue != null) {
-			consumer.accept(0, zeroValue);
+			consumer.accept(NULL_KEY, zeroValue);
+		}
+		
+		if (removedValue != null) {
+			consumer.accept(REMOVED_KEY, removedValue);
 		}
 
 		for (int i = 0; i < keys.length; i++) {
-			if (keys[i] != EMPTY_SLOT) {
+			if (keys[i] != EMPTY_SLOT && keys[i] != REMOVED_KEY) {
 				consumer.accept(keys[i], values[i]);
 			}
 		}
@@ -272,25 +344,35 @@ public class LongObjHashMap<V> {
 	 * @param consumer the consumer
 	 */
 	public void forEachOrdered(final LongObjConsumer<V> consumer) {
-
-		if (zeroValue != null) {
-			consumer.accept(0, zeroValue);
-		}
-
 		final long[] sortedKeys = Arrays.copyOf(keys, keys.length);
 		Arrays.parallelSort(sortedKeys);
 
+		// handle negative keys
 		for (int i = 0; i < sortedKeys.length; i++) {
 			final long key = sortedKeys[i];
-			if (key != EMPTY_SLOT) {
+			if (key < REMOVED_KEY) {
 				consumer.accept(key, get(key));
-			} else if (key == EMPTY_SLOT) {
+			} else {
+				break;
+			}
+		}
+		
+		// handle the special keys
+		if (removedValue != null) {
+			consumer.accept(REMOVED_KEY, removedValue);
+		}
+		if (zeroValue != null) {
+			consumer.accept(NULL_KEY, zeroValue);
+		}
+		
+		// handle positive keys
 		final int posFirstKey = findPosOfFirstPositiveKey(sortedKeys);
 		if (posFirstKey < 0) {
 			return;
 		}
-				i = posFirstKey - 1;
+		for (int i = posFirstKey; i < sortedKeys.length; i++) {
-			}
+			final long key = sortedKeys[i];
+			consumer.accept(key, get(key));
 		}
 	}
 
@@ -323,19 +405,31 @@ public class LongObjHashMap<V> {
 		return low < sortedKeys.length && sortedKeys[low] > EMPTY_SLOT ? low : -1;
 	}
 	
-	@SuppressWarnings("unchecked")
+	/**
+	 * Rehashes all elements of this map.
+	 * <p>
+	 * This is a maintenance operation that should be executed periodically after removing elements.
+	 */
+	public void rehash() {
+		rehash(keys.length);
+	} 
+
 	private void growAndRehash() {
+		final int newSize = Math.min(keys.length * 2, MAX_ARRAY_SIZE);
+		rehash(newSize);
+	}
+	
+	@SuppressWarnings("unchecked")
+	private void rehash(int newSize) {
 		final long[] oldKeys = keys;
 		final V[] oldValues = values;
 
-		final int newSize = Math.min(keys.length * 2, MAX_ARRAY_SIZE);
-
 		keys = new long[newSize];
 		values = (V[]) new Object[newSize];
 
 		for (int i = 0; i < oldKeys.length; i++) {
 			final long key = oldKeys[i];
-			if (key != EMPTY_SLOT) {
+			if (key != EMPTY_SLOT && key != REMOVED_KEY) {
 				final V value = oldValues[i];
 				putInternal(key, value);
 			}

primitiveCollections/src/test/java/org/lucares/collections/LongLongHashMapTest.java

@@ -1,5 +1,7 @@
 package org.lucares.collections;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import java.util.Random;
 import java.util.stream.LongStream;
 
@@ -17,6 +19,11 @@ public class LongLongHashMapTest {
 		putGetRemove(0);
 	}
 	
+	@Test
+	public void testRemovedValue() {
+		putGetRemove(-1);
+	}
+
 	private void putGetRemove(final long key) {
 		final LongLongHashMap map = new LongLongHashMap();
 
@@ -45,26 +52,121 @@ public class LongLongHashMapTest {
 	}
 
 	@Test
-	public void testComputeZeroKey() {
+	public void testRemoveNonExistingKey() {
 		final LongLongHashMap map = new LongLongHashMap();
+		final int values = 100;
 
-		final long key = 1;
+		 // fill with keys 0...99
-		map.compute(key, 6, l -> l + 1);
+		for (int i = 0; i < values; i++) {
-		Assertions.assertEquals(7, map.get(key, Long.MIN_VALUE), "initialValueIfAbsent is used when there is no mapping for the key");
+			map.put(i, i);
-
-		map.compute(key, 6, l -> l + 1);
-		Assertions.assertEquals(8, map.get(key, Long.MIN_VALUE), "update function is called when 'zeroKey' is set");
 		}
 
+		map.remove(values); // key does not exist
+		Assertions.assertEquals(values, map.size(), "size after removing non existing key 100");
+
+		// -1 is a sentinel key and has special handling
+		map.remove(-1); // key does not exist
+		Assertions.assertEquals(values, map.size(), "size after removing non existing key -1");
+		
+		map.put(-1, -1);
+		Assertions.assertEquals(values+1, map.size(), "size after adding key -1");
+		
+		map.remove(-1); // key exists
+		Assertions.assertEquals(values, map.size(), "size after removing key -1");
+
+		// 0 is a sentinel key and has special handling
+		map.remove(0); // key exists
+		Assertions.assertEquals(values - 1, map.size(), "size after removing existing key 0");
+
+		map.remove(0); // key does not exist
+		Assertions.assertEquals(values - 1, map.size(), "size after removing non existing key 0 (2nd removal of 0)");
+
+		for (int i = 1; i < 100; i++) {
+			map.remove(i);
+			Assertions.assertEquals(values-i-1, map.size(), "size after removing key "+i);
+		}
+		Assertions.assertEquals(0, map.size(), "size after removing all keys");
+	}
+
+	@Test
+	public void testRemoveAllValuesOneByOne() {
+		int values = 20;
+		final LongLongHashMap map = new LongLongHashMap();
+		Random r = new Random(123);
+
+		LongList keys = new LongList();
+
+		for (int round = 0; round < 5; round++) {
+			values *= 2;
+			keys.clear();
+			keys.addAll(r.longs(values).toArray());
+			keys.shuffle(r);
+			keys.stream().forEach(l -> map.put(l, 2));
+
+			for (int i = values - 1; i >= 0; i--) {
+				long key = keys.get(i);
+
+				map.compute(key, 2, (k,v) -> v * 2);
+				Assertions.assertEquals(4, map.get(key, -1), "value for key " + key + "=4 - map=" + map);
+
+				Assertions.assertTrue(map.containsKey(key), "map contains key " + key);
+				map.remove(key);
+				Assertions.assertEquals(i, map.size(), "size after removing key " + key);
+			}
+		}
+	}
+
+
 	@Test
 	public void testCompute() {		
 		final LongLongHashMap map = new LongLongHashMap();
-		final long key = 1;
-		map.compute(key, 6, l -> l + 1);
-		Assertions.assertEquals(7, map.get(key, Long.MIN_VALUE), "initialValueIfAbsent is used when there is no mapping for the key");
 		
-		map.compute(key, 6, l -> l + 1);
+		// initialize values
-		Assertions.assertEquals(8, map.get(key, Long.MIN_VALUE), "update function is called when key is set");
+		map.compute(LongLongHashMap.REMOVED_KEY, 11L, (k,v) -> {
+			Assertions.assertEquals(LongLongHashMap.REMOVED_KEY, k);
+			Assertions.assertEquals(11, v);
+			return 12L;
+		});
+		Assertions.assertEquals(12, map.get(LongLongHashMap.REMOVED_KEY, -111),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		map.compute(LongLongHashMap.NULL_KEY, 21L, (k,v) -> {
+			Assertions.assertEquals(LongLongHashMap.NULL_KEY, k);
+			Assertions.assertEquals(21, v);
+			return 22L;
+		});
+		Assertions.assertEquals(22, map.get(LongLongHashMap.NULL_KEY, -111),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		map.compute(1, 31L, (k,v) -> {
+			Assertions.assertEquals(1, k);
+			Assertions.assertEquals(31, v);
+			return 32L;
+		});
+		Assertions.assertEquals(32, map.get(1, -111),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		// update the value
+		map.compute(LongLongHashMap.REMOVED_KEY, -123L, (k,v) -> {
+			Assertions.assertEquals(LongLongHashMap.REMOVED_KEY, k);
+			Assertions.assertEquals(12, v);
+			return 13L;
+		});
+		Assertions.assertEquals(13, map.get(LongLongHashMap.REMOVED_KEY, -111), "update function is called when key is set");
+		
+		map.compute(LongLongHashMap.NULL_KEY, -123L, (k,v) -> {
+			Assertions.assertEquals(LongLongHashMap.NULL_KEY, k);
+			Assertions.assertEquals(22, v);
+			return 23L;
+		});
+		Assertions.assertEquals(23, map.get(LongLongHashMap.NULL_KEY, -111), "update function is called when key is set");
+		
+		map.compute(1, -123L, (k,v) -> {
+			Assertions.assertEquals(1, k);
+			Assertions.assertEquals(32, v);
+			return 33L;
+		});
+		Assertions.assertEquals(33, map.get(1, -111), "update function is called when key is set");
 	}
 
 	@Test
@@ -96,15 +198,49 @@ public class LongLongHashMapTest {
 		keysWithSameSpread.stream().forEach(l -> map.put(l, l));
 		Assertions.assertEquals(keysWithSameSpread.size(), map.size());
 		keysWithSameSpread.stream().forEach(l -> Assertions.assertEquals(l, map.get(l, Long.MIN_VALUE)));
+
+		// remove the keys
+		keysWithSameSpread.shuffle();
+		keysWithSameSpread.stream().forEach(k -> {
+			int sizeBefore = map.size();
+			Assertions.assertTrue(map.containsKey(k));
+			map.remove(k);
+			Assertions.assertFalse(map.containsKey(k));
+			Assertions.assertEquals(Long.MIN_VALUE, map.get(k, Long.MIN_VALUE));
+			Assertions.assertEquals(sizeBefore - 1, map.size());
+		});
 	}
 	
+	@Test
+	public void testMultipleValuesOnSamePosition2() {
+		final LongLongHashMap map = new LongLongHashMap();
+		// find to values that yield the same 'spread' (position in the table)
+		final LongList keys = findKeysWithSameSpread(map);
+		Assertions.assertTrue(keys.size() > 5);
+
+		map.put(keys.get(0), 1);
+		map.put(keys.get(1), 1);
+		map.put(keys.get(2), 1);
+		
+		// creates a section of the array that looks like this: k0,-1,k2, where -1 marks a previously occupied slot
+		map.remove(keys.get(1));
+		
+		// should overwrite the existing value which is after a slot that is marked as previously occupied
+		map.put(keys.get(2), 2); 
+		
+		final LongList values=new LongList();
+		map.forEach((k,v) -> values.add(v));
+		Assertions.assertEquals(LongList.of(1,2), values);
+	}
+	
+
 	@Test
 	public void testForEach() {
 		final LongLongHashMap map = new LongLongHashMap();
 		final Random rand = new Random(6789);
 		final LongList entries = LongList.of(LongStream.generate(rand::nextLong).limit(15).toArray());
 
-		entries.stream().forEachOrdered(l -> {
+		entries.stream().forEach(l -> {
 			map.put(l, 2 * l);
 		});
 
@@ -115,10 +251,29 @@ public class LongLongHashMapTest {
 	}
 
 	@Test
-	public void testForEachOrdered() {
+	public void testForEachWithSpecialValues() {
 		final LongLongHashMap map = new LongLongHashMap();
 		final Random rand = new Random(6789);
 		final LongList entries = LongList.of(LongStream.generate(rand::nextLong).limit(15).toArray());
+		entries.add(0); // special key that is internally used to mark unset slots
+		entries.add(-1);// special key that is internally used to mark slots with removed values
+		entries.add(123); // value that will be removed later
+
+		entries.stream().forEach(l -> {
+			map.put(l, 2 * l);
+		});
+		map.remove(123);
+
+		map.forEach((k, v) -> {
+			Assertions.assertEquals(k * 2, v, "value is key*2");
+			Assertions.assertTrue(entries.indexOf(k) >= 0, "value " + k + " in entries: " + entries);
+		});
+	}
+
+	@Test
+	public void testForEachOrdered() {
+		final LongLongHashMap map = new LongLongHashMap();
+		final LongList entries = LongList.of(-10, -9, -1, 0, 1, 2, 10);
 
 		entries.stream().forEachOrdered(l -> {
 			map.put(l, 2 * l);
@@ -213,6 +368,42 @@ public class LongLongHashMapTest {
 		Assertions.assertEquals(6, LongLongHashMap.findPosOfFirstPositiveKey(new long[] { -1, 0, 0, 0, 0, 0, 1 }));
 	}
 	
+	@Test
+	public void testMaxCapacity() {
+		LongLongHashMap map = new LongLongHashMap(6,0.75);
+		Assertions.assertEquals(6, map.getCapacity());
+		
+		// capacity is reduced to 5 - possible, because map is empty 
+		map.setMaxCapacity(5);
+		Assertions.assertEquals(5, map.getCapacity());
+		
+		map.put(1, 0); 
+		map.put(2, 0);
+		map.put(3, 0);
+		map.put(4, 0);
+		map.put(5, 0);
+		Assertions.assertEquals(5, map.getCapacity());
+		Assertions.assertEquals(5, map.size());
+		
+		// ensure we cannot add more values than the capacity allows
+		// 0 and -1 are sentinels, we have to check them separately
+		assertThrows(IllegalStateException.class, () -> map.put(0, 55));
+		assertThrows(IllegalStateException.class, () -> map.put(-1, 55));
+		assertThrows(IllegalStateException.class, () -> map.put(6, 55));// key is negative to ensure we actually could add it if the capacity restriction was not there
+		
+		Assertions.assertEquals(5, map.size()); // we still have only 5 keys in the map
+		
+		// check that we can increase the maxCapacity
+		map.setMaxCapacity(map.getCapacity()+1);
+		Assertions.assertEquals(5, map.getCapacity()); // capacity was not updated, because there was not need - you would have to manually call rehash()
+		Assertions.assertEquals(5, map.size());
+		map.put(6, 0); 
+		assertThrows(IllegalStateException.class, () -> map.put(7, 55));
+		
+		// check we cannot make the capacity smaller than the current size
+		assertThrows(IllegalArgumentException.class, ()->map.setMaxCapacity(map.size()-1));
+	}
+
 	private LongList findKeysWithSameSpread(final LongLongHashMap map) {
 		final LongList result = new LongList();
 		final int spread = map.spread(1);

primitiveCollections/src/test/java/org/lucares/collections/LongObjHashMapTest.java

@@ -1,7 +1,6 @@
 package org.lucares.collections;
 
 import java.util.Random;
-import java.util.function.Supplier;
 import java.util.stream.LongStream;
 
 import org.junit.jupiter.api.Assertions;
@@ -9,19 +8,6 @@ import org.junit.jupiter.api.Test;
 
 public class LongObjHashMapTest {
 	
-	private static final class LongSupplier implements Supplier<Long>{
-
-		private final Long value ;
-		
-		public LongSupplier(Long value) {
-			this.value = value;
-		}
-
-		@Override
-		public Long get() {
-			return value;
-		}
-	}
 	
 	@Test
 	public void testPutRemove() {
@@ -61,26 +47,84 @@ public class LongObjHashMapTest {
 	}
 	
 	@Test
-	public void testComputeZeroKey() {
+	public void testRemoveAllValuesOneByOne() {
+		int values = 20;
 		final LongObjHashMap<Long> map = new LongObjHashMap<>();
+		Random r = new Random(123);
 
-		final long key = 1;
+		LongList keys = new LongList();
-		map.compute(key, new LongSupplier(6L), (k,l) -> l + 1);
-		Assertions.assertEquals(7, map.get(key), "initialValueIfAbsent is used when there is no mapping for the key");
 
-		map.compute(key, new LongSupplier(6L), (k,l) -> l + 1);
+		for (int round = 0; round < 5; round++) {
-		Assertions.assertEquals(8, map.get(key), "update function is called when 'zeroKey' is set");
+			values *= 2;
+			keys.clear();
+			keys.addAll(r.longs(values).toArray());
+			keys.shuffle(r);
+			keys.stream().forEach(l -> map.put(l, 2L));
+
+			for (int i = values - 1; i >= 0; i--) {
+				long key = keys.get(i);
+
+				map.compute(key, () -> 2L, (k,l) -> l * 2);
+				Assertions.assertEquals(4, map.get(key), "value for key " + key + "=4 - map=" + map);
+
+				Assertions.assertTrue(map.containsKey(key), "map contains key " + key);
+				map.remove(key);
+				Assertions.assertEquals(i, map.size(), "size after removing key " + key);
 			}
+		}
+	}
+
 
 	@Test
 	public void testCompute() {		
 		final LongObjHashMap<Long> map = new LongObjHashMap<>();
-		final long key = 1;
-		map.compute(key, new LongSupplier(6L), (k,l) -> l + 1);
-		Assertions.assertEquals(7, map.get(key), "initialValueIfAbsent is used when there is no mapping for the key");
 		
-		map.compute(key, new LongSupplier(6L), (k,l) -> l + 1);
+		// initialize values
-		Assertions.assertEquals(8, map.get(key), "update function is called when key is set");
+		map.compute(LongObjHashMap.REMOVED_KEY, ()->11L, (k,v) -> {
+			Assertions.assertEquals(LongObjHashMap.REMOVED_KEY, k);
+			Assertions.assertEquals(11, v);
+			return 12L;
+		});
+		Assertions.assertEquals(12, map.get(LongObjHashMap.REMOVED_KEY),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		map.compute(LongObjHashMap.NULL_KEY, ()->21L, (k,v) -> {
+			Assertions.assertEquals(LongObjHashMap.NULL_KEY, k);
+			Assertions.assertEquals(21, v);
+			return 22L;
+		});
+		Assertions.assertEquals(22, map.get(LongObjHashMap.NULL_KEY),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		map.compute(1, ()->31L, (k,v) -> {
+			Assertions.assertEquals(1, k);
+			Assertions.assertEquals(31, v);
+			return 32L;
+		});
+		Assertions.assertEquals(32, map.get(1),
+				"initialValueIfAbsent is used when there is no mapping for the key");
+		
+		// update the value
+		map.compute(LongObjHashMap.REMOVED_KEY, ()->-123L, (k,v) -> {
+			Assertions.assertEquals(LongObjHashMap.REMOVED_KEY, k);
+			Assertions.assertEquals(12, v);
+			return 13L;
+		});
+		Assertions.assertEquals(13, map.get(LongObjHashMap.REMOVED_KEY), "update function is called when key is set");
+		
+		map.compute(LongObjHashMap.NULL_KEY, ()->-123L, (k,v) -> {
+			Assertions.assertEquals(LongObjHashMap.NULL_KEY, k);
+			Assertions.assertEquals(22, v);
+			return 23L;
+		});
+		Assertions.assertEquals(23, map.get(LongObjHashMap.NULL_KEY), "update function is called when key is set");
+		
+		map.compute(1, ()->-123L, (k,v) -> {
+			Assertions.assertEquals(1, k);
+			Assertions.assertEquals(32, v);
+			return 33L;
+		});
+		Assertions.assertEquals(33, map.get(1), "update function is called when key is set");
 	}
 
 	@Test
@@ -114,6 +158,28 @@ public class LongObjHashMapTest {
 		keysWithSameSpread.stream().forEach(l -> Assertions.assertEquals(l, map.get(l)));
 	}
 	
+	@Test
+	public void testMultipleValuesOnSamePosition2() {
+		final LongObjHashMap<Long> map = new LongObjHashMap<>();
+		// find to values that yield the same 'spread' (position in the table)
+		final LongList keys = findKeysWithSameSpread(map);
+		Assertions.assertTrue(keys.size() > 5);
+
+		map.put(keys.get(0), 1L);
+		map.put(keys.get(1), 1L);
+		map.put(keys.get(2), 1L);
+		
+		// creates a section of the array that looks like this: k0,-1,k2, where -1 marks a previously occupied slot
+		map.remove(keys.get(1));
+		
+		// should overwrite the existing value which is after a slot that is marked as previously occupied
+		map.put(keys.get(2), 2L); 
+		
+		final LongList values=new LongList();
+		map.forEach((k,v) -> values.add(v));
+		Assertions.assertEquals(LongList.of(1,2), values);
+	}
+
 	@Test
 	public void testForEach() {
 		final LongObjHashMap<Long> map = new LongObjHashMap<>();
@@ -133,8 +199,7 @@ public class LongObjHashMapTest {
 	@Test
 	public void testForEachOrdered() {
 		final LongObjHashMap<Long> map = new LongObjHashMap<>();
-		final Random rand = new Random(6789);
+		final LongList entries = LongList.of(-10, -9, -1, 0, 1, 2, 10);
-		final LongList entries = LongList.of(LongStream.generate(rand::nextLong).limit(15).toArray());
 
 		entries.stream().forEachOrdered(l -> {
 			map.put(l, 2 * l);
@@ -198,6 +263,26 @@ public class LongObjHashMapTest {
 		Assertions.assertTrue(actualOrderOfKeys.isSorted(), "keys are sorted");
 	}
 	
+	@Test
+	public void testForEachWithSpecialValues() {
+		final LongObjHashMap<Long> map = new LongObjHashMap<>();
+		final Random rand = new Random(6789);
+		final LongList entries = LongList.of(LongStream.generate(rand::nextLong).limit(15).toArray());
+		entries.add(0); // special key that is internally used to mark unset slots
+		entries.add(-1);// special key that is internally used to mark slots with removed values
+		entries.add(123); // value that will be removed later
+
+		entries.stream().forEach(l -> {
+			map.put(l, 2 * l);
+		});
+		map.remove(123);
+
+		map.forEach((k, v) -> {
+			Assertions.assertEquals(k * 2, v, "value is key*2");
+			Assertions.assertTrue(entries.indexOf(k) >= 0, "value " + k + " in entries: " + entries);
+		});
+	}
+
 	@Test
 	public void testFindPositionOfFirstPositiveKey() {