Build Fixes & Build Release Doc update

-Added: Tests for Lists and Sets.
-Fixed: SubLists are now stable (they weren't before)
-Fixed: All the bugs that the unit tests found so far.
-Updated: ReadMe/Changelog

Changelog.md

@@ -1,5 +1,47 @@
 # Changelog of versions
 
+### Version 0.5.0
+- Added: 2 Helper functions to find out how many bits are required to store a Number.
+- Added: pour function directly into Iterable which allows to collect all elements in the Iterable directly.
+- Added: The new ToArray method from Java9 and newer into the library. Using a functional interface. (Just a backport)
+- Changed: Reworked how the Map Builder functions are created. They are now in a SubClass that moves them out of the way. Less Clutter. (This might break things if that was used before)
+- Added: Map Builder that allows now to Build Maps like Guava ImmutableMaps can be build. Note: This has a slight performance overhead.
+- Added: Unmodifiable and Synchronize wrapper functions direclty into Collection Interfaces. This is mostly a quality of life thing.
+- Added: Unmodifiable and Synchronized Wrapper Collections can now be cloned. They clone the underlying map which doesn't break functionality. (Had a usecase for it)
+- Added: A boxed putAll array variant.
+- Fixed: EnumMaps didn't keep track of their size and now got proper care and implementations as needed. There might be more work required but at least the core functionality is now up to date.
+- Added: Tests for the new Stream replace functions to ensure no bugs are left.
+- Fixed: Custom HashSet reduce function with a default value was checking incorrectly for present keys.
+- Added: Guava TestSuit
+- Fixed: HashCode and toString method would crash if the Object Key/Value was null
+- Added: AbstractTypeCollection now delegates the contains check to type-specific Collections if it detects it.
+- Fixed: Map.Entry toString wasn't writing values not like it should do.
+- Fixed: Set.hashCode now is the sum of the elements instead of a Unique HashCode based on the elements.
+- Fixed: Added missing NonNull Checks.
+- Fixed: Custom/OpenHashMap.containsValue implementation was wrong.
+- Fixed: Custom/OpenHashMap.compute/present/absent now works how it is specified in the Java Documentation
+- Fixed: Custom/OpenHashMap.merge/BulkMerge now works how it is specified in the Java Documentation
+- Fixed: Custom/Linked/OpenHashMap.keySet.remove was causing a infinite loop.
+- Fixed: Custom/Linked/OpenHashMap.entrySet.contains was not correctly comparing the entry.
+- Fixed: Custom/OpenHashMap.mapIterator now no longer crashes in certain cases.
+- Added: Custom/LinkedOpenHashMap now takes use of the improved Iterator it has for containsValue
+- Fixed: CustomOpenHashMap.keySet.forEach was basically putting out keys even if they were present
+- Fixed: ImmutableMaps issues thanks to the tests. Roughly the same as the rest of the maps
+- Fixed: RB/AVLTreeMaps issues. Roughly the same as the rest of the maps
+- Fixed: SubLists are now properly implemented.
+- Fixed: HashSet Iterator bugs now fixed... That was Painful.
+- Added: Tests for Lists and Sets
+
+### Version 0.4.5
+- Added: removeAll/retainAll(Collection c, Consumer r) which receives all the elements that got deleted from the collection
+- Fixed: Supplier get function wasn't referencing original function.
+- Added: addIfPresent/Absent to lists
+- Added: distinct, limit and peek iterators
+- Added: Iterable's can now reduce its contents
+- Added: Better ForEach support for IterableWrappers so a Iterator chain is not created
+- Added: SwapRemove to Lists which moves the last element into the desired space to be deleted
+- Added: More Test cases
+
 ### Version 0.4.4
 - Fixed: ObjectArrayList.of was causing crashes because of a Poor implementation.
 - Added: Unsorted HashMaps/Sets now throw Concurrent exceptions if they were modified during a rehash.

README.md

@@ -11,7 +11,7 @@ But its focus is a different one.
 - EnumMap
 - Immutable Maps/Lists/Sets
 - Priority Queue
-- Streams
+- Streams & Functional Queries
 - SplitIterators
 - Iterators
 - Pairs
@@ -19,6 +19,21 @@ But its focus is a different one.
 - Suppliers
 - Bi/Consumers
 
+
+## Current Level of Stability
+Since this is a relatively new Library, stability was not perfect and some areas are not perfect yet.     
+Thanks to [ben-manes](https://github.com/ben-manes) we now have Roughly 16000 test covering Maps/Sets/Lists.     
+These tests cover Javas Collection API completely and ensuring a Stable implementation.     
+These freshly added tests allowed me to squash thousands of issues according to Googles Test Library (Guava-Tests).     
+These will be expanded on as time goes on.     
+
+One know aspect of Instability is SubSets and SubMaps. They require full rewrites to be fully stable.     
+So it is not advised to use them until these issues are addressed.     
+PriorityQueues are tested separately and ensure basic functionality though GuavaTests are planned.     
+They just require a custom test implementation.     
+
+As a summary: Stability is good/excellent, unless you need SubSets/SubMaps     
+
 ## Specialized Functions
 New Specialized functions that were added to increase performance or reduce allocations or Quality Of life.
 To highlight things that may be wanted.
@@ -29,15 +44,20 @@ To highlight things that may be wanted.
 	- matchAny/matchNone/matchAll: Allows to find elements in a collection.
 	- count: counts all valid elements in a collection.
 	- forEach: Allows to input a second element into a forEach move allowing for more flexibility for Method References
+	- reduce/limit/peek/distinct: Light Versions of the Stream variant, to reduce Stream usage.
+	- pour: a function that allows to collect all elements within the Collection
 - Collection:
 	- containsAny: Allows to test if another collection contains an of the elements of the tested collection.
 	- primitiveStream: Provides access to the closest Java Stream Type.
 	- copy: shallowCopies the collection, used instead of clone because this is better to use.
-		(subCollections/synchronized/unmodifiable not supported for obvious reasons)
+		(subCollections not supported for obvious reasons)
+	- toArray: the ToArray function from Java9 and newer that uses a Functional interface and can use a method reference
 - List:
 	- add/get/removeElements (From FastUtil): Allows to add/get/remove an Array into/from a list. Just with less overhead
 	- extractElements: Allows to remove a Range of elements from the List and get what was removed.
 	- Unstable Sort(From FastUtil): Uses a faster but not stable sort (Quick-Sort as example) to sort the list.
+	- addIfAbsent/Present: adds a element only if absent/present in the list
+	- swapRemove: deletes a desired element and inserts the last element in its place instead of leftshifting elements.
 - SortedSet:
 	- addAndMoveToFirst/Last (From FastUtil but moved to Interface): Allows to add a element to the first/last position of a sorted set.
 	- moveToFirst/Last: Moves the desired element at the first/last position of the SortedSet.
@@ -63,6 +83,9 @@ Any 0.x.0 version (Minor) can be reason for massive changes including API.
 To ensure that problems can be dealt with even if it is breaking the current API.     
 Any breaking changes will be Documented (once 1.0 is released)     
 
+Also to save space every 0.0.x (Patch) that is 2 Minor Versions behind will be removed. 
+So if 0.5.0 is released every 0.3.x patch will be deleted, except for the last patch for that minor version.
+
 # How to install
 Using Gradle:
 ```gradle
@@ -72,22 +95,21 @@ repositories {
     }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.4.4'
+	compile 'de.speiger:Primitive-Collections:0.5.0'
 }
 ```
 Direct:
 
 | Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
 |---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
+| 0.5.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.0/Primitive-Collections-0.5.0-javadoc.jar) 	|
+| 0.4.5   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.5/Primitive-Collections-0.4.5-javadoc.jar) 	|
 | 0.4.4   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.4/Primitive-Collections-0.4.4-javadoc.jar) 	|
 | 0.4.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.3/Primitive-Collections-0.4.3-javadoc.jar) 	|
 | 0.4.2   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.2/Primitive-Collections-0.4.2-javadoc.jar) 	|
 | 0.4.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.1/Primitive-Collections-0.4.1-javadoc.jar) 	|
 | 0.4.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-javadoc.jar) 	|
 | 0.3.6   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-javadoc.jar) 	|
-| 0.3.5   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.5/Primitive-Collections-0.3.5.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.5/Primitive-Collections-0.3.5-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.5/Primitive-Collections-0.3.5-javadoc.jar) 	|
-| 0.3.4   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.4/Primitive-Collections-0.3.4.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.4/Primitive-Collections-0.3.4-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.4/Primitive-Collections-0.3.4-javadoc.jar) 	|
-| 0.3.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.3/Primitive-Collections-0.3.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.3/Primitive-Collections-0.3.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.3/Primitive-Collections-0.3.3-javadoc.jar) 	|
 
 # Contributing
 If you want to contribute.      
@@ -112,5 +134,5 @@ to build the jar:
 do not combine the commands because they can not be executed at the same time.      
 
 ## Current Down Sides (Random order)
-- Testing for Sub Maps/Sets/Lists are only in a very basic way tested
+- SubMaps/Set implementation isn't perfect right now. This will be addressed slowly due to rewrites required.     
 - Documentation is only present at the lowest level for most cases and needs a typo fixing.

build.gradle

@@ -18,7 +18,7 @@ repositories {
 }
 
 archivesBaseName = 'Primitive Collections'
-version = '0.4.4';
+version = '0.5.0';
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8'
 
@@ -45,6 +45,8 @@ dependencies {
 	builderCompile 'de.speiger:Simple-Code-Generator:1.0.5'
 	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.5'
     testImplementation 'junit:junit:4.12'
+    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
+    
 }
 
 task generateSource(type: JavaExec) {

src/builder/java/speiger/src/builder/GlobalVariables.java

@@ -75,6 +75,7 @@ public class GlobalVariables
 		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
 		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", type.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
 		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
+		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", type.isObject() ? (valueType.isObject() ? " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">, "+valueType.getValueType()+">" : " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
 		
 		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", type.isObject() ? " <"+type.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
 		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
@@ -127,8 +128,8 @@ public class GlobalVariables
 		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
 		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
 		
-		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "%s.hashCode()" : type.getClassType(value)+".hashCode(%s)").removeBraces();
-		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "%s.toString()" : type.getClassType(value)+".toString(%s)").removeBraces();
+		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
+		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
 		
 		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
 		addSimpleMapper("EMPTY_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])ARRAYS.EMPTY_ARRAY" : "ARRAYS.EMPTY_ARRAY");
@@ -229,6 +230,7 @@ public class GlobalVariables
 		addClassMapper("STRATEGY", "Strategy");
 		addClassMapper("STACK", "Stack");
 		addClassMapper("SUPPLIER", "Supplier");
+		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
 		if(type.isObject())
 		{
@@ -254,6 +256,7 @@ public class GlobalVariables
 	
 	public GlobalVariables createFunctions()
 	{
+		addSimpleMapper("APPLY_KEY_VALUE", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
 		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
 		addSimpleMapper("APPLY_CAST", "applyAs"+type.getCustomJDKType().getNonFileType());
 		addSimpleMapper("APPLY", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
@@ -284,6 +287,7 @@ public class GlobalVariables
 		addFunctionValueMapper("MERGE", "merge");
 		addFunctionMapper("NEXT", "next");
 		addFunctionMapper("PREVIOUS", "previous");
+		addFunctionMapper("REMOVE_SWAP", "swapRemove");
 		if(type.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
 		else addSimpleMapper("REMOVE_VALUE", "remove");
 		addFunctionMapper("REMOVE_KEY", "rem");

src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template

@@ -3,9 +3,13 @@ package speiger.src.collections.PACKAGE.collections;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.AbstractCollection;
+#if TYPE_OBJECT
+import java.util.function.Consumer;
+#endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 #endif
 
@@ -79,12 +83,19 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	@Override
 	public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) {
 		Objects.requireNonNull(c);
+		if(c.isEmpty()) return true;
 		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
 			if(!contains(iter.NEXT()))
 				return false;
 		return true;
 	}
 	
+	@Override
+	public boolean containsAll(Collection<?> c) {
+		Objects.requireNonNull(c);
+		return c instanceof COLLECTION ? containsAll((COLLECTION KEY_GENERIC_TYPE)c) : super.containsAll(c);
+	}
+	
 	/**
 	 * This implementation iterates over the elements of the collection and checks if they are stored in this collection
 	 * @param c the elements that should be checked for
@@ -96,6 +107,7 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	@Primitive
 	public boolean containsAny(Collection<?> c) {
 		Objects.requireNonNull(c);
+		if(c.isEmpty()) return false;
 		for(Object e : c) 
 			if(contains(e))
 				return true;
@@ -111,6 +123,7 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	@Override
 	public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) {
 		Objects.requireNonNull(c);
+		if(c.isEmpty()) return false;
 		for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();) 
 			if(contains(iter.NEXT()))
 				return true;
@@ -153,6 +166,7 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	@Override
 	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
 		Objects.requireNonNull(c);
+		if(c.isEmpty()) return false;
 		boolean modified = false;
 		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
 			if(c.contains(iter.NEXT())) {
@@ -163,6 +177,23 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 		return modified;
 	}
 
+	@Override
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		Objects.requireNonNull(c);
+		if(c.isEmpty()) return false;
+		Objects.requireNonNull(r);
+		boolean modified = false;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			KEY_TYPE e = iter.NEXT();
+			if(c.contains(e)) {
+				r.accept(e);
+				iter.remove();
+				modified = true;
+			}
+		}
+		return modified;
+	}
+	
 	/**
 	 * A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
 	 * @param c the elements that should be kept
@@ -187,6 +218,27 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 		return modified;
 	}
 	
+	@Override
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		Objects.requireNonNull(c);
+		Objects.requireNonNull(r);
+		if(c.isEmpty()) {
+			boolean modified = !isEmpty();
+			forEach(r);
+			clear();
+			return modified;
+		}
+		boolean modified = false;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			KEY_TYPE e = iter.NEXT();
+			if(!c.contains(e)) {
+				iter.remove();
+				modified = true;
+			}
+		}
+		return modified;
+	}
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type-Specific implementation of toArray that links to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.

src/builder/resources/speiger/assets/collections/templates/collections/Collection.template

@@ -8,7 +8,14 @@ import java.util.function.Predicate;
 import java.util.stream.JAVA_STREAM;
 import java.util.stream.StreamSupport;
 #endif
+#if TYPE_OBJECT
+import java.util.function.Consumer;
+import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
+#else
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
+#endif
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
+import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
 import speiger.src.collections.utils.SanityChecks;
 
 /**
@@ -115,6 +122,16 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITE
 	 */
 	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c);
 	
+	/**
+	 * A Type-Specific removeAll function that reduces (un)boxing.
+	 * It also notifies the remover of which exact element is going to be removed.
+	 * @param c the collection of elements that should be removed
+	 * @param r elements that got removed
+	 * @return true if any element was removed
+	 * @see Collection#removeAll(Collection)
+	 */
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
+	
 	/**
  	 * A Type-Specific retainAll function that reduces (un)boxing.
 	 * @param c the collection of elements that should be kept
@@ -123,6 +140,27 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITE
  	 */
 	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
 	
+	/**
+ 	 * A Type-Specific retainAll function that reduces (un)boxing.
+	 * It also notifies the remover of which exact element is going to be removed.
+	 * @param c the collection of elements that should be kept
+	 * @param r elements that got removed
+ 	 * @return true if any element was removed
+ 	 * @see Collection#retainAll(Collection)
+ 	 */
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
+	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to collect all elements
+	 * @param collection that the elements should be inserted to
+	 * @param <E> the collection type
+	 * @return the input with the desired elements
+	 */
+	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
+		collection.addAll(this);
+		return collection;
+	}
+	
 	/**
 	 * A Function that does a shallow clone of the Collection itself.
 	 * This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted.
@@ -132,7 +170,18 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITE
 	 */
 	public COLLECTION KEY_GENERIC_TYPE copy();
 	
-#if !TYPE_OBJECT
+#if TYPE_OBJECT
+	/**
+	 * A Helper function that simplifies the process of creating a new Array.
+	 * @param action the array creation function
+	 * @return an array containing all of the elements in this collection
+	 * @see Collection#toArray(Object[])
+	 */
+	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+		return TO_ARRAY(action.get(size()));
+	}
+	
+#else
 	/**
 	 * A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
 	 * @return an array containing all of the elements in this collection
@@ -219,6 +268,28 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITE
 	@Override
 	public ITERATOR KEY_GENERIC_TYPE iterator();
 	
+	/**
+	 * Creates a Wrapped Collection that is Synchronized
+	 * @return a new Collection that is synchronized
+	 * @see COLLECTIONS#synchronize
+	 */
+	public default COLLECTION KEY_GENERIC_TYPE synchronize() { return COLLECTIONS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped Collection that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new Collection Wrapper that is synchronized
+	 * @see COLLECTIONS#synchronize
+	 */
+	public default COLLECTION KEY_GENERIC_TYPE synchronize(Object mutex) { return COLLECTIONS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped Collection that is unmodifiable
+	 * @return a new Collection Wrapper that is unmodifiable
+	 * @see COLLECTIONS#unmodifiable
+	 */
+	public default COLLECTION KEY_GENERIC_TYPE unmodifiable() { return COLLECTIONS.unmodifiable(this); }
+	
 #if PRIMITIVES
 	/**
 	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.

src/builder/resources/speiger/assets/collections/templates/collections/Iterable.template

@@ -1,18 +1,23 @@
 package speiger.src.collections.PACKAGE.collections;
 
 import java.util.Objects;
-#if !TYPE_OBJECT
 import java.util.function.Consumer;
+#if !TYPE_OBJECT
 
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.collections.ObjectIterable;
+#else
+import java.util.function.BiFunction;
+
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.PACKAGE.utils.ITERABLES;
+import speiger.src.collections.PACKAGE.utils.ITERATORS;
 
 /**
  * A Type-Specific {@link Iterable} that reduces (un)boxing
@@ -118,6 +123,43 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return ITERABLES.filter(this, filter);
 	}
 	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
+	 * @return a Iterable that filtered out all duplicated elements
+	 */
+	default ITERABLE KEY_GENERIC_TYPE distinct() {
+		return ITERABLES.distinct(this);
+	}
+	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to limit the amount of elements
+	 * @param limit the amount of elements it should be limited to
+	 * @return a Iterable that is limited in length
+	 */
+	default ITERABLE KEY_GENERIC_TYPE limit(long limit) {
+		return ITERABLES.limit(this, limit);
+	}
+	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
+	 * @param action the action that should be applied
+	 * @return a Peeked Iterable
+	 */
+	default ITERABLE KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
+		return ITERABLES.peek(this, action);
+	}
+	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to collect all elements
+	 * @param collection that the elements should be inserted to
+	 * @param <E> the collection type
+	 * @return the input with the desired elements
+	 */
+	default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
+		ITERATORS.pour(iterator(), collection);
+		return collection;
+	}
+	
 	/**
 	 * Helper function to reduce stream usage that allows to filter for any matches.
 	 * @param filter that should be applied
@@ -171,6 +213,63 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	/**
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+     * elements of this Iterable
+	 * @param operator the operation that should be applied
+	 * @param identity the start value
+	 * @return the reduction result, returns identity if nothing was found
+	 */
+	default KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			state = operator.APPLY_VALUE(state, iter.NEXT());
+		}
+		return state;
+	}
+	
+#else
+	/**
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+     * elements of this Iterable
+	 * @param operator the operation that should be applied
+	 * @param identity the start value
+	 * @Type(E)
+	 * @return the reduction result, returns identity if nothing was found
+	 */
+	default <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			state = operator.APPLY_VALUE(state, iter.NEXT());
+		}
+		return state;
+	}
+	
+#endif
+	/**
+	 * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
+	 * elements of this Iterable
+	 * @param operator the operation that should be applied
+	 * @return the reduction result, returns null value if nothing was found
+	 */
+	default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
+			if(empty) {
+				empty = false;
+				state = iter.NEXT();
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, iter.NEXT());
+		}
+		return state;
+	}	
+	
 	/**
 	 * Helper function to reduce stream usage that allows to count the valid elements.
 	 * @param filter that should be applied

src/builder/resources/speiger/assets/collections/templates/functions/Supplier.template

@@ -16,7 +16,7 @@ public interface SUPPLIER KEY_GENERIC_TYPE
 	 * @return the supplied value
 	 */
 	public KEY_TYPE GET_KEY();
-#if JDK_TYPE && PRIMITIVE
+#if JDK_TYPE && PRIMITIVES
 	
 	@Override
 	public default KEY_TYPE GET_JAVA() {

src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template

@@ -3,11 +3,15 @@ package speiger.src.collections.PACKAGE.lists;
 import java.util.Collection;
 import java.util.List;
 import java.util.ListIterator;
+import java.util.NoSuchElementException;
 import java.util.Objects;
 
 import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
+import speiger.src.collections.utils.SanityChecks;
 
 /**
  * Abstract implementation of the {@link LIST} interface.
@@ -15,9 +19,8 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
  */
 public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements LIST KEY_GENERIC_TYPE 
 {
-#if !TYPE_OBJECT
 	/**
-	 * A Type-Specific implementation of add function that delegates to {@link #add(int, KEY_TYPE)}
+	 * A Type-Specific implementation of add function that delegates to {@link List#add(int, Object)}
 	 */
 	@Override
 	public boolean add(KEY_TYPE e) {
@@ -25,6 +28,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		return true;
 	}
 	
+#if !TYPE_OBJECT
 	/** {@inheritDoc}
 	 * <p>This default implementation delegates to the corresponding type-specific function.
 	 * @deprecated Please use the corresponding type-specific function instead. 
@@ -155,6 +159,14 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	}
 	
 #endif
+	@Override
+	public boolean REMOVE_SWAP(KEY_TYPE e) {
+		int index = indexOf(e);
+		if(index == -1) return false;
+		swapRemove(index);
+		return true;
+	}
+	
 	/**
 	 * Compares if the list are the same.
 	 */
@@ -205,7 +217,8 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	
 	@Override
 	public LIST KEY_GENERIC_TYPE subList(int fromIndex, int toIndex) {
-		return new SUB_LIST(this, fromIndex, toIndex);
+		SanityChecks.checkArrayCapacity(size(), fromIndex, toIndex-fromIndex);
+		return new SubList(this, 0, fromIndex, toIndex);
 	}
 	
 	@Override
@@ -220,6 +233,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
+		if(index < 0 || index > size()) throw new IndexOutOfBoundsException();
 		return new LIST_ITER(index);
 	}
 	
@@ -231,124 +245,128 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	
 	public ABSTRACT_LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	
-	private class SUB_LIST extends ABSTRACT_LIST KEY_GENERIC_TYPE {
-		ABSTRACT_LIST KEY_GENERIC_TYPE l;
-		int offset;
+	private class SubList extends ABSTRACT_LIST KEY_GENERIC_TYPE
+	{
+		final ABSTRACT_LIST KEY_GENERIC_TYPE list;
+		final int parentOffset;
+		final int offset;
 		int size;
 		
-		SUB_LIST(ABSTRACT_LIST KEY_GENERIC_TYPE l, int from, int to) {
-			if (from < 0) throw new IndexOutOfBoundsException("fromIndex = " + from);
-			else if (to > l.size()) throw new IndexOutOfBoundsException("toIndex = " + to);
-			else if (from > to)	throw new IllegalArgumentException("fromIndex(" + from + ") > toIndex(" + to + ")");
-			this.l = l;
-			offset = from;
-			size = to - from;
+		public SubList(ABSTRACT_LIST KEY_GENERIC_TYPE list, int offset, int from, int to) {
+			this.list = list;
+			this.parentOffset = from;
+			this.offset = offset + from;
+			this.size = to - from;
 		}
 		
 		@Override
-		public void add(int index, KEY_TYPE e) {
-			checkAddRange(index);
-			l.add(index+offset, e);
+		public void add(int index, KEY_TYPE element) {
+			checkAddSubRange(index);
+			list.add(parentOffset+index, element);
 			size++;
 		}
 		
 		@Override
 		public boolean addAll(int index, Collection<? extends CLASS_TYPE> c) {
-			checkAddRange(index);
-			int size = c.size();
-			if(size == 0) return false;
-			l.addAll(index + offset, l);
-			offset += size;
+			checkAddSubRange(index);
+			int add = c.size();
+			if(add <= 0) return false;
+			list.addAll(parentOffset+index, c);
+			this.size += add;
 			return true;
 		}
 		
 		@Override
 		public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c) {
-			checkAddRange(index);
-			int size = c.size();
-			if(size == 0) return false;
-			l.addAll(index + offset, l);
-			offset += size;
+			checkAddSubRange(index);
+			int add = c.size();
+			if(add <= 0) return false;
+			list.addAll(parentOffset+index, c);
+			this.size += add;
 			return true;
 		}
 
 		@Override
 		public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) {
-			checkAddRange(index);
-			int size = c.size();
-			if(size == 0) return false;
-			l.addAll(index + offset, l);
-			offset += size;
-			return true;
-		}
-		
-		@Override
-		public boolean addAll(KEY_TYPE[] e, int offset, int length) {
-			if(length <= 0) return false;
-			l.addElements(this.offset, e, offset, length);
-			offset += length;
+			checkAddSubRange(index);
+			int add = c.size();
+			if(add <= 0) return false;
+			list.addAll(parentOffset+index, c);
+			this.size += add;
 			return true;
 		}
 		
 		@Override
 		public void addElements(int from, KEY_TYPE[] a, int offset, int length) {
-			checkRange(from);
-			l.addElements(from + this.offset, a, offset, length);
-			size += length;
+			checkAddSubRange(from);
+			if(length <= 0) return;
+			list.addElements(parentOffset+from, a, offset, length);
+			this.size += length;
 		}
 		
 		@Override
 		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
-			checkRange(from);
-			return l.getElements(from + this.offset, a, offset, length);
+			SanityChecks.checkArrayCapacity(size, from, length);
+			SanityChecks.checkArrayCapacity(a.length, offset, length);
+			return list.getElements(from+this.offset, a, offset, length);
 		}
 		
 		@Override
 		public void removeElements(int from, int to) {
-			checkRange(from);
-			checkRange(to);
-			l.removeElements(from + offset, to + offset);
+			if(to-from <= 0) return;
+			checkSubRange(from);
+			checkSubRange(to);
+			list.removeElements(from+parentOffset, to+parentOffset);
 			size -= to - from;
 		}
 		
 #if TYPE_OBJECT
 		@Override
-		public <K> K[] extractElements(int from, int to, Class<K> clz) {
-			checkRange(from);
-			checkRange(to);
-			K[] a = l.extractElements(from + offset, to + offset, clz);
+		public <K> K[] extractElements(int from, int to, Class<K> type) {
+			checkSubRange(from);
+			checkSubRange(to);
+			K[] result = list.extractElements(from+parentOffset, to+parentOffset, type);
 			size -= to - from;
-			return a;
+			return result;
 		}
 
 #else
 		@Override
 		public KEY_TYPE[] extractElements(int from, int to) {
-			checkRange(from);
-			checkRange(to);
-			KEY_TYPE[] a = l.extractElements(from + offset, to + offset);
+			checkSubRange(from);
+			checkSubRange(to);
+			KEY_TYPE[] result = list.extractElements(from+parentOffset, to+parentOffset);
 			size -= to - from;
-			return a;
+			return result;
 		}
 		
 #endif
 		@Override
 		public KEY_TYPE GET_KEY(int index) {
-			checkRange(index);
-			return l.GET_KEY(index + offset);
+			checkSubRange(index);
+			return list.GET_KEY(offset+index);
 		}
 
 		@Override
-		public KEY_TYPE set(int index, KEY_TYPE e) {
-			checkRange(index);
-			return l.set(index + offset, e);
+		public KEY_TYPE set(int index, KEY_TYPE element) {
+			checkSubRange(index);
+			return list.set(offset+index, element);
+		}
+		
+		@Override
+		public KEY_TYPE swapRemove(int index) {
+			checkSubRange(index);
+			KEY_TYPE result = list.swapRemove(index+parentOffset);
+			size--;
+			return result;
 		}
 		
 		@Override
 		public KEY_TYPE REMOVE(int index) {
-			checkRange(index);
+			checkSubRange(index);
+			KEY_TYPE result = list.REMOVE(index+parentOffset);
 			size--;
-			return l.REMOVE(index + offset);
+			return result;
 		}
 		
 		@Override
@@ -356,15 +374,112 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			return size;
 		}
 		
-		private void checkRange(int index) {
+		@Override
+		public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 16464); }
+		
+		@Override
+		public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
+			if(index < 0 || index > size()) throw new IndexOutOfBoundsException();
+			return new SubListIterator(this, index);
+		}
+		
+		@Override
+		public LIST KEY_GENERIC_TYPE subList(int fromIndex, int toIndex) {
+			SanityChecks.checkArrayCapacity(size, fromIndex, toIndex-fromIndex);
+			return new SubList(list, offset, fromIndex, toIndex);
+		}
+		
+		protected void checkSubRange(int index) {
 			if (index < 0 || index >= size)
 				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
 		}
 		
-		private void checkAddRange(int index) {
+		protected void checkAddSubRange(int index) {
 			if (index < 0 || index > size)
 				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
 		}
+		
+		private class SubListIterator implements LIST_ITERATOR KEY_GENERIC_TYPE
+		{
+			ABSTRACT_LIST KEY_GENERIC_TYPE list;
+			int index;
+			int lastReturned = -1;
+			
+			SubListIterator(ABSTRACT_LIST KEY_GENERIC_TYPE list, int index) {
+				this.list = list;
+				this.index = index;
+			}
+			
+			@Override
+			public boolean hasNext() {
+				return index < list.size();
+			}
+			
+			@Override
+			public KEY_TYPE NEXT() {
+				if(!hasNext()) throw new NoSuchElementException();
+				int i = index++;
+				return list.GET_KEY((lastReturned = i));
+			}
+			
+			@Override
+			public boolean hasPrevious() {
+				return index > 0;
+			}
+			
+			@Override
+			public KEY_TYPE PREVIOUS() {
+				if(!hasPrevious()) throw new NoSuchElementException();
+				index--;
+				return list.GET_KEY((lastReturned = index));
+			}
+			
+			@Override
+			public int nextIndex() {
+				return index;
+			}
+			
+			@Override
+			public int previousIndex() {
+				return index-1;
+			}
+			
+			@Override
+			public void remove() {
+				if(lastReturned == -1) throw new IllegalStateException();
+				list.REMOVE(lastReturned);
+				index = lastReturned;
+				lastReturned = -1;
+			}
+			
+			@Override
+			public void set(KEY_TYPE e) {
+				if(lastReturned == -1) throw new IllegalStateException();
+				list.set(lastReturned, e);
+			}
+			
+			@Override
+			public void add(KEY_TYPE e) {
+				list.add(index++, e);
+				lastReturned = -1;
+			}
+			
+			@Override
+			public int skip(int amount) {
+				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+				int steps = Math.min(amount, (list.size() - 1) - index);
+				index += steps;
+				return steps;
+			}
+			
+			@Override
+			public int back(int amount) {
+				if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+				int steps = Math.min(amount, index);
+				index -= steps;
+				return steps;
+			}
+		}
 	}
 		
 	private class LIST_ITER implements LIST_ITERATOR KEY_GENERIC_TYPE {
@@ -382,8 +497,9 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			lastReturned = index;
-			return GET_KEY(index++);
+			if(!hasNext()) throw new NoSuchElementException();
+			int i = index++;
+			return GET_KEY((lastReturned = i));
 		}
 		
 		@Override
@@ -393,8 +509,9 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
-			lastReturned = index;
-			return GET_KEY(index--);
+			if(!hasPrevious()) throw new NoSuchElementException();
+			index--;
+			return GET_KEY((lastReturned = index));
 		}
 		
 		@Override
@@ -409,25 +526,20 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 		
 		@Override
 		public void remove() {
-			if(lastReturned == -1)
-				throw new IllegalStateException();
+			if(lastReturned == -1) throw new IllegalStateException();
 			ABSTRACT_LIST.this.REMOVE(lastReturned);
-			if(lastReturned < index)
-				index--;
+			index = lastReturned;
 			lastReturned = -1;
 		}
 		
 		@Override
 		public void set(KEY_TYPE e) {
-			if(lastReturned == -1)
-				throw new IllegalStateException();
+			if(lastReturned == -1) throw new IllegalStateException();
 			ABSTRACT_LIST.this.set(lastReturned, e);
 		}
 		
 		@Override
 		public void add(KEY_TYPE e) {
-			if(lastReturned == -1)
-				throw new IllegalStateException();
 			ABSTRACT_LIST.this.add(index++, e);
 			lastReturned = -1;
 		}

src/builder/resources/speiger/assets/collections/templates/lists/ArrayList.template

@@ -9,6 +9,7 @@ import java.util.Iterator;
 import java.util.Objects;
 #if TYPE_OBJECT
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
@@ -29,6 +30,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 #if TYPE_OBJECT
@@ -650,6 +652,45 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0;i<size;i++) {
+			if(empty) {
+				empty = false;
+				state = data[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -733,6 +774,17 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return old;
 	}
 	
+	public KEY_TYPE swapRemove(int index) {
+		checkRange(index);
+		KEY_TYPE old = data[index];
+		size--;
+		data[index] = data[size];
+#if TYPE_OBJECT
+		data[size] = null;
+#endif
+		return old;
+	}
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
@@ -864,6 +916,22 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return modified;
 	}
 	
+	@Override
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		if(c.isEmpty()) return false;
+		int j = 0;
+		for(int i = 0;i<size;i++) {
+			if(!c.contains(data[i])) data[j++] = data[i];
+			else r.accept(data[i]);
+		}
+		boolean modified = j != size;
+#if TYPE_OBJECT
+		Arrays.fill(data, j, size, null);
+#endif		
+		size = j;
+		return modified;
+	}
+	
 	/**
 	 * A function to retain all elements that were provided in the other collection
 	 * This function might delegate to a more appropriate function if necessary
@@ -891,6 +959,27 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return modified;
 	}
 	
+	@Override
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		if(c.isEmpty()) {
+			boolean modifed = size > 0;
+			forEach(r);
+			clear();
+			return modifed;
+		}
+		int j = 0;
+		for(int i = 0;i<size;i++) {
+			if(c.contains(data[i])) data[j++] = data[i];
+			else r.accept(data[i]);
+		}
+		boolean modified = j != size;
+#if TYPE_OBJECT
+		Arrays.fill(data, j, size, null);
+#endif
+		size = j;
+		return modified;
+	}
+	
 #if PRIMITIVES
 	/**
 	 * A optimized List#removeIf(Predicate) that more quickly removes elements from the list then the ArrayList implementation
@@ -934,8 +1023,13 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	public <E> E[] toArray(E[] a) {
 		if(a == null) a = (E[])new Object[size];
 		else if(a.length < size) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), size);
+#if TYPE_OBJECT
+        System.arraycopy(data, 0, a, 0, size);
+#else
 		for(int i = 0;i<size;i++)
 			a[i] = (E)KEY_TO_OBJ(data[i]);
+#endif
+		if (a.length > size) a[size] = null;
 		return a;
 	}
 	
@@ -944,6 +1038,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
 		if(a.length < size) a = new KEY_TYPE[size];
 		System.arraycopy(data, 0, a, 0, size);
+		if (a.length > size) a[size] = EMPTY_KEY_VALUE;
 		return a;
 	}
 	
@@ -1045,6 +1140,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
 	}
 	
+	
 #if PRIMITIVES
 	/**
 	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.

src/builder/resources/speiger/assets/collections/templates/lists/ImmutableList.template

@@ -5,8 +5,10 @@ import java.util.Arrays;
 import java.util.Comparator;
 #endif
 import java.util.Collection;
+import java.util.NoSuchElementException;
 import java.util.Objects;
 #if TYPE_OBJECT
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 #endif
 import java.util.function.Predicate;
@@ -24,6 +26,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.utils.ObjectArrays;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 #if PRIMITIVES
@@ -330,6 +333,45 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0,m=data.length;i<m;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0,m=data.length;i<m;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0,m=data.length;i<m;i++) {
+			if(empty) {
+				empty = false;
+				state = data[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -340,6 +382,12 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		return result;
 	}
 	
+	@Override
+	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
+		if(index < 0 || index > size()) throw new IndexOutOfBoundsException();
+		return new LIST_ITER(index);
+	}
+	
 	@Override
 	public KEY_TYPE set(int index, KEY_TYPE e) { throw new UnsupportedOperationException(); }
 	@Override
@@ -351,7 +399,8 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 #endif
 	@Override
 	public KEY_TYPE REMOVE(int index) { throw new UnsupportedOperationException(); }
-
+	@Override
+	public KEY_TYPE swapRemove(int index) { throw new UnsupportedOperationException(); }
 #if !TYPE_OBJECT
 	@Override
 	public boolean REMOVE_KEY(KEY_TYPE type) { throw new UnsupportedOperationException(); }
@@ -370,6 +419,10 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
 	@Override
 	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
+	@Override
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { throw new UnsupportedOperationException(); }
+	@Override
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { throw new UnsupportedOperationException(); }
 	
 #if PRIMITIVES
 	@Override
@@ -401,6 +454,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		else if(a.length < data.length) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), data.length);
 		for(int i = 0,m=data.length;i<m;i++)
 			a[i] = (E)KEY_TO_OBJ(data[i]);
+		if (a.length > data.length) a[data.length] = null;
 		return a;
 	}
 	
@@ -409,6 +463,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
 		if(a.length < data.length) a = new KEY_TYPE[data.length];
 		System.arraycopy(data, 0, a, 0, data.length);
+		if (a.length > data.length) a[data.length] = EMPTY_KEY_VALUE;
 		return a;
 	}
 	
@@ -449,4 +504,69 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	 */
 	@Override
 	public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createArraySplititerator(data, data.length, 16464); }
+	
+	private class LIST_ITER implements LIST_ITERATOR KEY_GENERIC_TYPE {
+		int index;
+		
+		LIST_ITER(int index) {
+			this.index = index;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return index < size();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			return GET_KEY(index++);
+		}
+		
+		@Override
+		public boolean hasPrevious() {
+			return index > 0;
+		}
+		
+		@Override
+		public KEY_TYPE PREVIOUS() {
+			if(!hasPrevious()) throw new NoSuchElementException();
+			return GET_KEY(--index);
+		}
+		
+		@Override
+		public int nextIndex() {
+			return index;
+		}
+		
+		@Override
+		public int previousIndex() {
+			return index-1;
+		}
+		
+		@Override
+		public void remove() { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void set(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public int skip(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+			int steps = Math.min(amount, (size() - 1) - index);
+			index += steps;
+			return steps;
+		}
+		
+		@Override
+		public int back(int amount) {
+			if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
+			int steps = Math.min(amount, index);
+			index -= steps;
+			return steps;
+		}
+	}
 }

src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template

@@ -2,12 +2,14 @@ package speiger.src.collections.PACKAGE.lists;
 
 #if TYPE_OBJECT
 import java.util.Comparator;
+import java.util.function.BiFunction;
 #else if PRIMITIVES
 import java.nio.JAVA_BUFFER;
 #endif
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
+import java.util.NoSuchElementException;
 import java.util.Spliterator;
 #if PRIMITIVES
 import java.util.Spliterator.JAVA_SPLIT_ITERATOR;
@@ -21,9 +23,12 @@ import java.util.function.JAVA_UNARY_OPERATOR;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.STACK;
+#else
+import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.queues.PRIORITY_DEQUEUE;
@@ -322,9 +327,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	@Primitive
 	public int indexOf(Object o) {
-		if(o == null) return -1;
 		Entry KEY_GENERIC_TYPE entry = first;
-		for(int i = 0;entry != null;entry = entry.next) {
+		for(int i = 0;entry != null;entry = entry.next,i++) {
 			if(Objects.equals(KEY_TO_OBJ(entry.value), o)) return i;
 		}
 		return -1;
@@ -333,9 +337,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	@Primitive
 	public int lastIndexOf(Object o) {
-		if(o == null) return -1;
 		Entry KEY_GENERIC_TYPE entry = last;
-		for(int i = size-1;entry != null;entry = entry.prev) {
+		for(int i = size-1;entry != null;entry = entry.prev,i--) {
 			if(Objects.equals(KEY_TO_OBJ(entry.value), o)) return i;
 		}
 		return -1;
@@ -350,7 +353,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	public int indexOf(KEY_TYPE e) {
 		Entry entry = first;
-		for(int i = 0;entry != null;entry = entry.next) {
+		for(int i = 0;entry != null;entry = entry.next,i++) {
 			if(KEY_EQUALS(entry.value, e)) return i;
 		}
 		return -1;
@@ -359,26 +362,17 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	public int lastIndexOf(KEY_TYPE e) {
 		Entry entry = last;
-		for(int i = size-1;entry != null;entry = entry.prev) {
+		for(int i = size-1;entry != null;entry = entry.prev,i--) {
 			if(KEY_EQUALS(entry.value, e)) return i;
 		}
 		return -1;
 	}
 	
 #endif
-	@Override
-	public ITERATOR KEY_GENERIC_TYPE iterator() {
-		return new ListIter(first, 0);
-	}
-	
-	@Override
-	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator() {
-		return new ListIter(first, 0);
-	}
-	
 	@Override
 	public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
-		if(index == size-1) return new ListIter(last, index);
+		if(index < 0 || index > size()) throw new IndexOutOfBoundsException();
+		if(index == size) return new ListIter(null, index);
 		if(index == 0) return new ListIter(first, index);
 		return new ListIter(getNode(index), index);
 	}
@@ -454,6 +448,45 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
+			state = operator.APPLY_VALUE(state, entry.value);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
+			state = operator.APPLY_VALUE(state, entry.value);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
+			if(empty) {
+				empty = false;
+				state = entry.value;
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, entry.value);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -521,7 +554,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	public boolean removeFirst(KEY_TYPE e) {
 		if(size == 0) return false;
-		for(Entry KEY_GENERIC_TYPE entry = first;entry.next != null;entry = entry.next) {
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
 			if(KEY_EQUALS(entry.value, e)) {
 				unlink(entry);
 				return true;
@@ -533,7 +566,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	public boolean removeLast(KEY_TYPE e) {
 		if(size == 0) return false;
-		for(Entry KEY_GENERIC_TYPE entry = last;entry.prev != null;entry = entry.prev) {
+		for(Entry KEY_GENERIC_TYPE entry = last;entry != null;entry = entry.prev) {
 			if(KEY_EQUALS(entry.value, e)) {
 				unlink(entry);
 				return true;
@@ -542,11 +575,71 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return false;
 	}
 	
+	@Override
+	public KEY_TYPE swapRemove(int index) {
+		checkRange(index);
+		Entry KEY_GENERIC_TYPE entry = getNode(index);
+		if(entry == null) return EMPTY_KEY_VALUE;
+		if(entry.next == null) return unlinkLast(entry);
+		Entry KEY_GENERIC_TYPE before = entry.prev;
+		KEY_TYPE result = unlink(entry);
+		if(before == null) {
+			Entry KEY_GENERIC_TYPE temp = last;
+			last = temp.prev;
+			last.next = null;
+			temp.next = first;
+			temp.prev = null;
+			first.prev = temp;
+			first = temp;
+			return result;
+		}
+		Entry KEY_GENERIC_TYPE temp = last;
+		last = temp.prev;
+		last.next = null;
+		temp.next = before.next;
+		temp.prev = before;
+		before.next = temp;
+		return result;
+	}
+	
+	@Override
+	public boolean REMOVE_SWAP(KEY_TYPE e) {
+		if(size == 0) return false;
+		for(Entry KEY_GENERIC_TYPE entry = last;entry != null;entry = entry.prev) {
+			if(KEY_EQUALS(entry.value, e)) {
+				if(entry.next == null) {
+					unlinkLast(entry);
+					return true;
+				}
+				Entry KEY_GENERIC_TYPE before = entry.prev;
+				unlink(entry);
+				if(before == null) {
+					Entry KEY_GENERIC_TYPE temp = last;
+					last = temp.prev;
+					last.next = null;
+					temp.next = first;
+					temp.prev = null;
+					first.prev = temp;
+					first = temp;
+					return true;
+				}
+				Entry KEY_GENERIC_TYPE temp = last;
+				last = temp.prev;
+				last.next = null;
+				temp.next = before.next;
+				temp.prev = before;
+				before.next = temp;
+				return true;
+			}
+		}
+		return false;
+	}
+	
 #if TYPE_OBJECT
 	@Override
 	public boolean remove(Object e) {
 		if(size <= 0) return false;
-		for(Entry KEY_GENERIC_TYPE entry = first;entry.next != null;entry = entry.next) {
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
 			if(KEY_EQUALS(entry.value, e)) {
 				unlink(entry);
 				return true;
@@ -565,7 +658,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	@Override
 	public KEY_TYPE REMOVE(int index) {
 		checkRange(index);
-		return unlink(getNode(index));
+		Entry KEY_GENERIC_TYPE entry = getNode(index);
+		return entry == null ? EMPTY_KEY_VALUE : unlink(entry);
 	}
 	
 	@Override
@@ -714,6 +808,27 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return modified;
 	}
 	
+	@Override
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		if(c.isEmpty()) return false;
+		boolean modified = false;
+		int j = 0;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;) {
+			if(c.contains(entry.value)) {
+				r.accept(entry.value);
+				Entry KEY_GENERIC_TYPE next = entry.next;
+				unlink(entry);
+				entry = next;
+				modified = true;
+				continue;
+			}
+			else j++;
+			entry = entry.next;
+		}
+		size = j;
+		return modified;
+	}
+	
 	@Override
 	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
 		if(c.isEmpty()) {
@@ -738,6 +853,32 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return modified;
 	}
 	
+	@Override
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		if(c.isEmpty()) {
+			boolean changed = size > 0;
+			forEach(r);
+			clear();
+			return changed;
+		}
+		boolean modified = false;
+		int j = 0;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;) {
+			if(!c.contains(entry.value)) {
+				r.accept(entry.value);
+				Entry KEY_GENERIC_TYPE next = entry.next;
+				unlink(entry);
+				entry = next;
+				modified = true;
+				continue;
+			}
+			else j++;
+			entry = entry.next;
+		}
+		size = j;
+		return modified;
+	}
+	
 	@Override
 	@Primitive
 	public boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
@@ -798,6 +939,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
 			a[i++] = (E)KEY_TO_OBJ(entry.value);
 		}
+		if (a.length > size) a[size] = null;
 		return a;
 	}
 	
@@ -807,11 +949,18 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		if(a.length < size) a = new KEY_TYPE[size];
 		int i = 0;
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
-			a[i++] = KEY_TO_OBJ(entry.value);
+			a[i++] = entry.value;
 		}
+		if (a.length > size) a[size] = EMPTY_KEY_VALUE;
 		return a;
 	}
 	
+#else
+	@Override
+	public T[] toArray(Int2ObjectFunction<T[]> action) {
+		return super.toArray(action);
+	}
+	
 #endif
 	@Override
 	public int size() {
@@ -961,23 +1110,23 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 	private class ListIter implements LIST_ITERATOR KEY_GENERIC_TYPE 
 	{
-		Entry KEY_GENERIC_TYPE node;
+		Entry KEY_GENERIC_TYPE next;
 		Entry KEY_GENERIC_TYPE lastReturned;
 		int index;
 		
-		ListIter(Entry KEY_GENERIC_TYPE node, int index) {
-			this.node = node;
+		ListIter(Entry KEY_GENERIC_TYPE next, int index) {
+			this.next = next;
 			this.index = index;
 		}
 		
 		@Override
 		public boolean hasNext() {
-			return node != null;
+			return index < size;
 		}
 		
 		@Override
 		public boolean hasPrevious() {
-			return node != null;
+			return index > 0;
 		}
 		
 		@Override
@@ -993,23 +1142,26 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		@Override
 		public void remove() {
 			if(lastReturned == null) throw new IllegalStateException();
-			if(lastReturned.next == node) index--;
+			Entry KEY_GENERIC_TYPE lastNext = lastReturned.next;
 			unlink(lastReturned);
+			if (next == lastReturned) next = lastNext;
+			else index--;
 			lastReturned = null;
 		}
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
-			lastReturned = node;
-			node = node.prev;
+			if(!hasPrevious()) throw new NoSuchElementException();
+            lastReturned = next = (next == null) ? last : next.prev;
 			index--;
 			return lastReturned.value;
 		}
 		
 		@Override
 		public KEY_TYPE NEXT() {
-			lastReturned = node;
-			node = node.next;
+			if(!hasNext()) throw new NoSuchElementException();
+			lastReturned = next;
+			next = next.next;
 			index++;
 			return lastReturned.value;
 		}
@@ -1022,11 +1174,10 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		
 		@Override
 		public void add(KEY_TYPE e) {
-			if(lastReturned == null) throw new IllegalStateException();
-			if(node.next == null) linkLast(e);
-			else linkBefore(e, node);
-			lastReturned = null;
-			index++;
+            lastReturned = null;
+            if (next == null) linkLast(e);
+            else linkBefore(e, next);
+            index++;
 		}
 	}
 	

src/builder/resources/speiger/assets/collections/templates/lists/List.template

@@ -20,6 +20,7 @@ import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
+import speiger.src.collections.PACKAGE.utils.LISTS;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 #if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
 import speiger.src.collections.utils.SanityChecks;
@@ -50,6 +51,26 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
 	public void add(int index, KEY_TYPE e);
 	
 #endif
+	/**
+	 * A Helper function that will only add elements if it is not present.
+	 * @param e the element to add
+	 * @return true if the list was modified
+	 */
+	public default boolean addIfAbsent(KEY_TYPE e) {
+		if(indexOf(e) == -1) return add(e);
+		return false;
+	}
+	
+	/**
+	 * A Helper function that will only add elements if it is present.
+	 * @param e the element to add
+	 * @return true if the list was modified
+	 */
+	public default boolean addIfPresent(KEY_TYPE e) {
+		if(indexOf(e) != -1) return add(e);
+		return false;
+	}
+	
 	/**
 	 * A Type-Specific addAll Function to reduce (un)boxing
 	 * @param c the elements that need to be added
@@ -206,6 +227,22 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
 	 */
 	public void removeElements(int from, int to);
 	
+	/**
+	 * A Highly Optimized remove function that removes the desired element.
+	 * But instead of shifting the elements to the left it moves the last element to the removed space.
+	 * @param index the index of the element to be removed
+	 * @return the element previously at the specified position
+	 */
+	public KEY_TYPE swapRemove(int index);
+	
+	/**
+	 * A Highly Optimized remove function that removes the desired element.
+	 * But instead of shifting the elements to the left it moves the last element to the removed space.
+	 * @param e the element that should be removed
+	 * @return true if the element was removed
+	 */
+	public boolean REMOVE_SWAP(KEY_TYPE e);
+	
 #if TYPE_OBJECT
 	/**
 	 * A function to fast extract elements out of the list, this removes the elements that were fetched.
@@ -342,6 +379,28 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
 	@Override
 	public LIST KEY_GENERIC_TYPE subList(int from, int to);
 	
+	/**
+	 * Creates a Wrapped List that is Synchronized
+	 * @return a new List that is synchronized
+	 * @see LISTS#synchronize
+	 */
+	public default LIST KEY_GENERIC_TYPE synchronize() { return LISTS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped List that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new List Wrapper that is synchronized
+	 * @see LISTS#synchronize
+	 */
+	public default LIST KEY_GENERIC_TYPE synchronize(Object mutex) { return LISTS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped List that is unmodifiable
+	 * @return a new List Wrapper that is unmodifiable
+	 * @see LISTS#unmodifiable
+	 */
+	public default LIST KEY_GENERIC_TYPE unmodifiable() { return LISTS.unmodifiable(this); }
+	
 	/**
 	 * A function to ensure the elements are within the requested size.
 	 * If smaller then the stored elements they get removed as needed.

src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template

@@ -49,7 +49,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 	
 	@Override
 	public MAP KEY_VALUE_GENERIC_TYPE copy() { 
-		 throw new UnsupportedOperationException();
+		throw new UnsupportedOperationException();
 	}
 	
 #if !TYPE_OBJECT || !VALUE_OBJECT
@@ -90,6 +90,15 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 		for(int i = 0;i<size;i++) put(keys[i], values[i]);
 	}
 	
+#if !TYPE_OBJECT || !VALUE_OBJECT
+	@Override
+	public void putAll(CLASS_TYPE[] keys, CLASS_VALUE_TYPE[] values, int offset, int size) {
+		SanityChecks.checkArrayCapacity(keys.length, offset, size);
+		SanityChecks.checkArrayCapacity(values.length, offset, size);
+		for(int i = 0;i<size;i++) put(keys[i], values[i]);		
+	}
+	
+#endif
 	@Override
 	public void putAllIfAbsent(MAP KEY_VALUE_GENERIC_TYPE m) {
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m))
@@ -495,7 +504,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(key) + "->" + VALUE_TO_STRING(value);
+			return KEY_TO_STRING(key) + "=" + VALUE_TO_STRING(value);
 		}
 	}
 }

src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template

@@ -5,6 +5,7 @@ import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 import java.util.Objects;
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -17,6 +18,7 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
@@ -27,6 +29,9 @@ import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
+#endif
 #if !VALUE_OBJECT && !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
 import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
@@ -47,6 +52,10 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
 #endif
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
@@ -747,6 +756,37 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[index], values[index]);
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -780,8 +820,19 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return LINKED_CUSTOM_HASH_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return LINKED_CUSTOM_HASH_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = LINKED_CUSTOM_HASH_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), LINKED_CUSTOM_HASH_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+#if !TYPE_OBJECT
+					if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+					int index = LINKED_CUSTOM_HASH_MAP.this.findIndex((CLASS_TYPE)entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(LINKED_CUSTOM_HASH_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -833,7 +884,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_CUSTOM_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -846,7 +897,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		@Override
 		public boolean remove(KEY_TYPE o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_CUSTOM_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -971,6 +1022,52 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = keys[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1100,6 +1197,52 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = values[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/OpenCustomHashMap.template

@@ -6,6 +6,7 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
@@ -15,6 +16,9 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 #if !TYPE_OBJECT && !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -33,10 +37,17 @@ import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
 #if !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
+
 #if !VALUE_OBJECT
+#if !TYPE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+#endif
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
 #endif
+#else if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT || !VALUE_OBJECT
 import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
@@ -296,8 +307,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
-		if(VALUE_EQUALS(value, values[nullIndex])) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
+		for(int i = nullIndex;i >= 0;i--)
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
 	}
@@ -306,9 +316,12 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		if((value == null && VALUE_EQUALS(values[nullIndex], getDefaultReturnValue())) || EQUALS_VALUE_TYPE(values[nullIndex], value)) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
+		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && EQUALS_VALUE_TYPE(values[i], value)) return true;
+#else
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && ((value == null && values[i] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[i], value))) return true;
+#endif
 		return false;
 	}
 	
@@ -327,7 +340,6 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	}
 	
 	@Override
-	@Deprecated
 	public CLASS_VALUE_TYPE remove(Object key) {
 #if !TYPE_OBJECT
 		if(!(key instanceof CLASS_TYPE)) return getDefaultReturnValue();
@@ -484,6 +496,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
@@ -502,6 +515,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
@@ -509,11 +523,18 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			insert(-index-1, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 	
 	@Override
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
@@ -521,13 +542,20 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			insert(-index-1, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 
 	@Override
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
-		if(index < 0) return getDefaultReturnValue();
+		if(index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue())) return getDefaultReturnValue();
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, values[index]);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			removeIndex(index);
@@ -539,8 +567,12 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if VALUE_OBJECT
+		Objects.requireNonNull(value);
+#endif
 		int index = findIndex(key);
-		VALUE_TYPE newValue = index < 0 ? value : mappingFunction.APPLY_VALUE(values[index], value);
+		VALUE_TYPE newValue = index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(values[index], value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			if(index >= 0)
 				removeIndex(index);
@@ -556,7 +588,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
 			KEY_TYPE key = entry.ENTRY_KEY();
 			int index = findIndex(key);
-			VALUE_TYPE newValue = index < 0 ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
+			VALUE_TYPE newValue = index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
 			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 				if(index >= 0)
 					removeIndex(index);
@@ -773,7 +805,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(keys[index]) + "->" + VALUE_TO_STRING(values[index]);
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 	
@@ -874,6 +906,39 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			if(containsNull) state = operator.apply(state, new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]));
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			if(containsNull) {
+				state = new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]);
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[i], values[i]);
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -924,8 +989,19 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		@Override
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return CUSTOM_HASH_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return CUSTOM_HASH_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = CUSTOM_HASH_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), CUSTOM_HASH_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+#if !TYPE_OBJECT
+					if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+					int index = CUSTOM_HASH_MAP.this.findIndex((CLASS_TYPE)entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(CUSTOM_HASH_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -954,7 +1030,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			CUSTOM_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -967,7 +1043,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		@Override
 		public boolean remove(KEY_TYPE o) {
 			int oldSize = size;
-			remove(o);
+			CUSTOM_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -997,9 +1073,10 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
+			Objects.requireNonNull(action);
 			if(containsNull) action.accept(keys[nullIndex]);
 			for(int i = nullIndex-1;i>=0;i--)
-				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(keys[i]);
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(keys[i]);
 		}
 		
 		@Override
@@ -1045,6 +1122,54 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_KEY_VALUE(state, keys[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			if(containsNull) state = operator.apply(state, keys[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				state = operator.apply(state, keys[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			if(containsNull) {
+				state = keys[nullIndex];
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				if(empty) {
+					empty = false;
+					state = keys[i];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1153,6 +1278,54 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_VALUE(state, values[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_VALUE(state, values[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			if(containsNull) {
+				state = values[nullIndex];
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+				if(empty) {
+					empty = false;
+					state = values[i];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1216,6 +1389,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	
 	private class MapIterator {
 		int pos = nullIndex;
+		int returnedPos = -1;
 		int lastReturned = -1;
 		int nextIndex = Integer.MIN_VALUE;
 		boolean returnNull = containsNull;
@@ -1247,6 +1421,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
+			returnedPos = pos;
 			if(nextIndex < 0){
 				lastReturned = Integer.MAX_VALUE;
 				int value = findIndex(wrapped.GET_KEY(nextIndex));
@@ -1266,9 +1441,10 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				keys[nullIndex] = EMPTY_KEY_VALUE;
 				values[nullIndex] = EMPTY_VALUE;
 			}
-			else if(pos >= 0) shiftKeys(pos);
+			else if(returnedPos >= 0) shiftKeys(returnedPos);
 			else {
-				CUSTOM_HASH_MAP.this.remove(wrapped.GET_KEY(-pos - 1));
+				CUSTOM_HASH_MAP.this.remove(wrapped.GET_KEY(-returnedPos - 1));
+				lastReturned = -1;
 				return;
 			}
 			size--;

src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template

@@ -5,6 +5,7 @@ import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 import java.util.Objects;
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -17,6 +18,7 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
@@ -26,6 +28,9 @@ import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
+#endif
 #if !VALUE_OBJECT && !SAME_TYPE
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
 import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
@@ -46,6 +51,10 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
 #endif
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
@@ -314,6 +323,33 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		return values[index];
 	}
 	
+#if !VALUE_OBJECT
+	@Override
+	public boolean containsValue(VALUE_TYPE value) {
+		int index = firstIndex;
+		while(index != -1) {
+			if(VALUE_EQUALS(values[index], value)) return true;
+			index = (int)links[index];
+		}
+		return false;
+	}
+	
+#endif
+	@Override
+	@ValuePrimitive
+	public boolean containsValue(Object value) {
+		int index = firstIndex;
+		while(index != -1) {
+#if VALUE_OBJECT
+			if(VALUE_EQUALS(values[index], value)) return true;
+#else
+			if((value == null && values[index] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[index], value)) return true;
+#endif
+			index = (int)links[index];
+		}
+		return false;
+	}
+	
 	@Override
 	public LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE copy() {
 		LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE map = new LINKED_HASH_MAPKV_BRACES(0, loadFactor);
@@ -724,6 +760,37 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[index], values[index]);
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -757,8 +824,16 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return LINKED_HASH_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return LINKED_HASH_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = LINKED_HASH_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), LINKED_HASH_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					int index = LINKED_HASH_MAP.this.findIndex(entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(LINKED_HASH_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -810,7 +885,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -823,7 +898,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		@Override
 		public boolean remove(KEY_TYPE o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -941,13 +1016,59 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			Objects.requireNonNull(filter);
 			if(size() <= 0) return true;
 			int index = firstIndex;
-			while(index != -1){
+			while(index != -1) {
 				if(!filter.TEST_VALUE(keys[index])) return false;
 				index = (int)links[index];
 			}
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = keys[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1059,7 +1180,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			Objects.requireNonNull(filter);
 			if(size() <= 0) return true;
 			int index = firstIndex;
-			while(index != -1){
+			while(index != -1) {
 				if(filter.VALUE_TEST_VALUE(values[index])) return false;
 				index = (int)links[index];
 			}
@@ -1071,13 +1192,59 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			Objects.requireNonNull(filter);
 			if(size() <= 0) return true;
 			int index = firstIndex;
-			while(index != -1){
+			while(index != -1) {
 				if(!filter.VALUE_TEST_VALUE(values[index])) return false;
 				index = (int)links[index];
 			}
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = values[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/OpenHashMap.template

@@ -6,6 +6,7 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
@@ -15,6 +16,9 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 #if !TYPE_OBJECT && !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -34,9 +38,15 @@ import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
 
 #if !VALUE_OBJECT
+#if !TYPE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+#endif
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
 #endif
+#else if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT || !VALUE_OBJECT
 import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
@@ -50,6 +60,7 @@ import speiger.src.collections.objects.functions.function.Object2BooleanFunction
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
 #endif
+
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
 #endif
 import speiger.src.collections.objects.collections.ObjectIterator;
@@ -267,8 +278,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
-		if(VALUE_EQUALS(value, values[nullIndex])) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
+		for(int i = nullIndex;i >= 0;i--)
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
 	}
@@ -277,9 +287,12 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		if((value == null && VALUE_EQUALS(values[nullIndex], getDefaultReturnValue())) || EQUALS_VALUE_TYPE(values[nullIndex], value)) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
+		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+			if(KEY_EQUALS_NOT_NULL(keys[i]) && EQUALS_VALUE_TYPE(values[i], value)) return true;
+#else
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && ((value == null && values[i] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[i], value))) return true;
+#endif
 		return false;
 	}
 	
@@ -298,7 +311,6 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	}
 	
 	@Override
-	@Deprecated
 	public CLASS_VALUE_TYPE remove(Object key) {
 		int slot = findIndex(key);
 		if(slot < 0) return VALUE_TO_OBJ(getDefaultReturnValue());
@@ -445,6 +457,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
@@ -463,6 +476,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
@@ -470,11 +484,18 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			insert(-index-1, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 	
 	@Override
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
 		int index = findIndex(key);
 		if(index < 0) {
 			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
@@ -482,13 +503,20 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			insert(-index-1, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
-		if(index < 0) return getDefaultReturnValue();
+		if(index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue())) return getDefaultReturnValue();
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, values[index]);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			removeIndex(index);
@@ -500,8 +528,12 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if VALUE_OBJECT
+		Objects.requireNonNull(value);
+#endif
 		int index = findIndex(key);
-		VALUE_TYPE newValue = index < 0 ? value : mappingFunction.APPLY_VALUE(values[index], value);
+		VALUE_TYPE newValue = index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(values[index], value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			if(index >= 0)
 				removeIndex(index);
@@ -517,7 +549,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
 			KEY_TYPE key = entry.ENTRY_KEY();
 			int index = findIndex(key);
-			VALUE_TYPE newValue = index < 0 ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
+			VALUE_TYPE newValue = index < 0 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
 			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 				if(index >= 0)
 					removeIndex(index);
@@ -733,7 +765,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(keys[index]) + "->" + VALUE_TO_STRING(values[index]);
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 	
@@ -834,6 +866,39 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			if(containsNull) state = operator.apply(state, new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]));
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			if(containsNull) {
+				state = new BasicEntryKV_BRACES(keys[nullIndex], values[nullIndex]);
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[i], values[i]);
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -884,8 +949,16 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		@Override
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return HASH_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return HASH_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = HASH_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), HASH_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					int index = HASH_MAP.this.findIndex(entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(HASH_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -914,7 +987,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -927,7 +1000,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		@Override
 		public boolean remove(KEY_TYPE o) {
 			int oldSize = size;
-			remove(o);
+			HASH_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -1005,6 +1078,54 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_KEY_VALUE(state, keys[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			if(containsNull) state = operator.apply(state, keys[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				state = operator.apply(state, keys[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			if(containsNull) {
+				state = keys[nullIndex];
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				if(empty) {
+					empty = false;
+					state = keys[i];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1113,6 +1234,54 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_VALUE(state, values[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			if(containsNull) state = operator.APPLY_VALUE(state, values[nullIndex]);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			if(containsNull) {
+				state = values[nullIndex];
+				empty = false;
+			}
+			for(int i = 0;i<size;i++) {
+				if(KEY_EQUALS_NULL(keys[i])) continue;
+				if(empty) {
+					empty = false;
+					state = values[i];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1176,6 +1345,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	
 	private class MapIterator {
 		int pos = nullIndex;
+		int returnedPos = -1;
 		int lastReturned = -1;
 		int nextIndex = Integer.MIN_VALUE;
 		boolean returnNull = containsNull;
@@ -1207,6 +1377,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
+			returnedPos = pos;
 			if(nextIndex < 0){
 				lastReturned = Integer.MAX_VALUE;
 				int value = findIndex(wrapped.GET_KEY(nextIndex));
@@ -1226,9 +1397,10 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				keys[nullIndex] = EMPTY_KEY_VALUE;
 				values[nullIndex] = EMPTY_VALUE;
 			}
-			else if(pos >= 0) shiftKeys(pos);
+			else if(returnedPos >= 0) shiftKeys(returnedPos);
 			else {
-				HASH_MAP.this.remove(wrapped.GET_KEY(-pos - 1));
+				HASH_MAP.this.remove(wrapped.GET_KEY(-returnedPos - 1));
+				lastReturned = -1;
 				return;
 			}
 			size--;

src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template

@@ -6,6 +6,7 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -19,6 +20,9 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
@@ -61,6 +65,10 @@ import speiger.src.collections.VALUE_PACKAGE.utils.VALUE_ARRAYS;
 #endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.ObjectSortedSet;
 #endif
@@ -229,18 +237,34 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		{
 			KEY_TYPE o = a[i];
 			if(KEY_EQUALS_NULL(o)) {
-				if(!containsNull) size++;
+				if(!containsNull) {
+					size++;
+					if(prev != -1) {
+						newLinks[prev] ^= ((newLinks[prev] ^ (newSize & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
+						newLinks[newSize] ^= ((newLinks[newSize] ^ ((prev & 0xFFFFFFFFL) << 32)) & 0xFFFFFFFF00000000L);
+						prev = newSize;
+					}
+					else {
+						prev = firstIndex = newSize;
+						newLinks[newSize] = -1L;
+					}
+				}
 				containsNull = true;
+				newValues[newSize] = b[i];
 				continue;
 			}
 			boolean found = true;
 			int pos = HashUtil.mix(KEY_TO_HASH(o)) & newMask;
 			KEY_TYPE current = newKeys[pos];
 			if(KEY_EQUALS_NOT_NULL(current)) {
-				if(KEY_EQUALS(current, o)) continue;
-				while(KEY_EQUALS_NOT_NULL((current = newKeys[pos = (++pos & mask)]))) {
+				if(KEY_EQUALS(current, o)) {
+					newValues[pos] = b[i];
+					continue;
+				}
+				while(KEY_EQUALS_NOT_NULL((current = newKeys[pos = (++pos & newMask)]))) {
 					if(KEY_EQUALS(current, o)) {
 						found = false;
+						newValues[pos] = b[i];
 						break;
 					}
 				}
@@ -248,7 +272,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			if(found) {
 				size++;
 				newKeys[pos] = o;
-				values[pos] = b[i];
+				newValues[pos] = b[i];
 				if(prev != -1) {
 					newLinks[prev] ^= ((newLinks[prev] ^ (pos & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
 					newLinks[pos] ^= ((newLinks[pos] ^ ((prev & 0xFFFFFFFFL) << 32)) & 0xFFFFFFFF00000000L);
@@ -260,7 +284,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				}
 			}
 		}
-		nullIndex = size;
+		nullIndex = newSize;
 		mask = newMask;
 		keys = newKeys;
 		values = newValues;
@@ -308,9 +332,11 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
-		if(VALUE_EQUALS(value, values[nullIndex])) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
-			if(KEY_EQUALS_NOT_NULL(keys[i]) && VALUE_EQUALS(values[i], value)) return true;
+		int index = firstIndex;
+		while(index != -1) {
+			if(VALUE_EQUALS(values[index], value)) return true;
+			index = (int)links[index];
+		}
 		return false;
 	}
 	
@@ -318,9 +344,15 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		if((value == null && VALUE_EQUALS(values[nullIndex], getDefaultReturnValue())) || EQUALS_VALUE_TYPE(values[nullIndex], value)) return true;
-		for(int i = nullIndex-1;i >= 0;i--)
-			if(KEY_EQUALS_NOT_NULL(keys[i]) && ((value == null && values[i] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[i], value))) return true;
+		int index = firstIndex;
+		while(index != -1) {
+#if VALUE_OBJECT
+			if(VALUE_EQUALS(values[index], value)) return true;
+#else
+			if((value == null && values[index] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[index], value)) return true;
+#endif
+			index = (int)links[index];
+		}
 		return false;
 	}
 	
@@ -536,6 +568,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				}
 				Map.Entry<?, ?> entry = (Map.Entry<?, ?>)obj;
 				Object key = entry.getKey();
+#if !TYPE_OBJECT
+				if(!(key instanceof CLASS_TYPE)) return false;
+#endif
 				Object value = entry.getValue();
 #if TYPE_OBJECT && VALUE_OBJECT
 				return KEY_EQUALS(keys[index], key) && VALUE_EQUALS(values[index], value);
@@ -557,7 +592,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(keys[index]) + "->" + VALUE_TO_STRING(values[index]);
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 	
@@ -685,6 +720,37 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[index], values[index]);
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -718,8 +784,16 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return IMMUTABLE_HASH_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return IMMUTABLE_HASH_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = IMMUTABLE_HASH_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), IMMUTABLE_HASH_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					int index = IMMUTABLE_HASH_MAP.this.findIndex(entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(IMMUTABLE_HASH_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -879,6 +953,52 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = keys[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1006,6 +1126,52 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			int index = firstIndex;
+			while(index != -1) {
+				state = operator.apply(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			int index = firstIndex;
+			while(index != -1) {
+				if(empty) {
+					empty = false;
+					state = values[index];
+					index = (int)links[index];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[index]);
+				index = (int)links[index];
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template

@@ -6,6 +6,7 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
@@ -19,6 +20,9 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
@@ -57,6 +61,10 @@ import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
 import speiger.src.collections.objects.collections.ObjectIterator;
 #endif
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
@@ -130,11 +138,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	public ARRAY_MAP(CLASS_TYPE[] keys, CLASS_VALUE_TYPE[] values, int length) {
 		this(length);
 		if(keys.length != values.length) throw new IllegalStateException("Input Arrays are not equal size");
-		size = length;
-		for(int i = 0,m=length;i<m;i++) {
-			this.keys[i] = OBJ_TO_KEY(keys[i]);
-			this.values[i] = OBJ_TO_VALUE(values[i]);
-		}
+		putAll(keys, values, 0, length);
 	}
 	
 #endif
@@ -156,10 +160,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	 * @throws IllegalStateException if the keys and values do not match in lenght
 	 */
 	public ARRAY_MAP(KEY_TYPE[] keys, VALUE_TYPE[] values, int length) {
+		this(length);
 		if(keys.length != values.length) throw new IllegalStateException("Input Arrays are not equal size");
-		this.keys = Arrays.copyOf(keys, length);
-		this.values = Arrays.copyOf(values, length);
-		this.size = length;
+		putAll(keys, values, 0, length);
 	}
 	
 	/**
@@ -199,8 +202,11 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	@Override
 	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) {
 		int index = findIndex(key);
-		if(index >= 0) insertIndex(size++, key, value);
-		return getDefaultReturnValue();
+		if(index < 0) {
+			insertIndex(size++, key, value);
+			return getDefaultReturnValue();
+		}
+		return values[index];
 	}
 	
 #if VALUE_PRIMITIVES
@@ -460,6 +466,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index == -1) {
 			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
@@ -478,6 +485,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
 		if(index == -1) {
 			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
@@ -485,11 +493,18 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			insertIndex(size++, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 	
 	@Override
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
 		int index = findIndex(key);
 		if(index == -1) {
 			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
@@ -497,13 +512,20 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			insertIndex(size++, key, newValue);
 			return newValue;
 		}
-		return values[index];
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
 	}
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
 		int index = findIndex(key);
-		if(index == -1) return getDefaultReturnValue();
+		if(index == -1 || VALUE_EQUALS(values[index], getDefaultReturnValue())) return getDefaultReturnValue();
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, values[index]);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			removeIndex(index);
@@ -515,8 +537,12 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if VALUE_OBJECT
+		Objects.requireNonNull(value);
+#endif
 		int index = findIndex(key);
-		VALUE_TYPE newValue = index == -1 ? value : mappingFunction.APPLY_VALUE(values[index], value);
+		VALUE_TYPE newValue = index == -1 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(values[index], value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			if(index >= 0)
 				removeIndex(index);
@@ -532,7 +558,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
 			KEY_TYPE key = entry.ENTRY_KEY();
 			int index = findIndex(key);
-			VALUE_TYPE newValue = index == -1 ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
+			VALUE_TYPE newValue = index == -1 || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
 			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 				if(index >= 0)
 					removeIndex(index);
@@ -680,21 +706,18 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	
 #endif
 	protected int findIndex(Object key, Object value) {
-		if(key == null || value == null) return -1;
 		for(int i = size-1;i>=0;i--)
 			if(EQUALS_KEY_TYPE(keys[i], key) && EQUALS_VALUE_TYPE(values[i], value)) return i;
 		return -1;		
 	}
 	
 	protected int findIndex(Object key) {
-		if(key == null) return -1;
 		for(int i = size-1;i>=0;i--)
 			if(EQUALS_KEY_TYPE(keys[i], key)) return i;
 		return -1;
 	}
 	
 	protected int findValue(Object value) {
-		if(value == null) return -1;
 		for(int i = size-1;i>=0;i--)
 			if(EQUALS_VALUE_TYPE(values[i], value)) return i;
 		return -1;
@@ -1066,21 +1089,18 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 #endif
 		protected int findIndex(Object key, Object value) {
-			if(key == null || value == null) return -1;
 			for(int i = length-1;i>=0;i--)
 				if(EQUALS_KEY_TYPE(keys[offset+i], key) && EQUALS_VALUE_TYPE(values[offset+i], value)) return i+offset;
 			return -1;		
 		}
 		
 		protected int findIndex(Object key) {
-			if(key == null) return -1;
 			for(int i = length-1;i>=0;i--)
 				if(EQUALS_KEY_TYPE(keys[offset+i], key)) return i+offset;
 			return -1;
 		}
 		
 		protected int findValue(Object value) {
-			if(value == null) return -1;
 			for(int i = length-1;i>=0;i--)
 				if(EQUALS_VALUE_TYPE(values[offset+i], value)) return i+offset;
 			return -1;
@@ -1210,6 +1230,32 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				return true;
 			}
 			
+			@Override
+			public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+				Objects.requireNonNull(operator);
+				E state = identity;
+				for(int i = 0;i<length;i++) {
+					state = operator.apply(state, new BasicEntryKV_BRACES(keys[offset+i], values[offset+i]));
+				}
+				return state;
+			}
+			
+			@Override
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+				boolean empty = true;
+				for(int i = 0;i<length;i++) {
+					if(empty) {
+						empty = false;
+						state = new BasicEntryKV_BRACES(keys[offset+i], values[offset+i]);
+						continue;
+					}
+					state = operator.apply(state, new BasicEntryKV_BRACES(keys[offset+i], values[offset+i]));
+				}
+				return state;
+			}
+			
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
@@ -1239,8 +1285,14 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			@Deprecated
 			public boolean contains(Object o) {
 				if(o instanceof Map.Entry) {
-					if(o instanceof MAP.Entry) return SubMap.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-					return SubMap.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+					if(o instanceof MAP.Entry) {
+						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+						return SubMap.this.findIndex(entry.ENTRY_KEY(), entry.ENTRY_VALUE()) >= 0;
+					}
+					else {
+						Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+						return ARRAY_MAP.this.findIndex(entry.getKey(), entry.getValue()) >= 0;
+					}
 				}
 				return false;
 			}
@@ -1289,7 +1341,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			@Override
 			public boolean remove(Object o) {
 				int oldSize = length;
-				remove(o);
+				SubMap.this.remove(o);
 				return length != oldSize;
 			}
 			
@@ -1300,7 +1352,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			@Override
 			public boolean remove(KEY_TYPE o) {
 				int oldSize = length;
-				remove(o);
+				SubMap.this.remove(o);
 				return length != oldSize;
 			}
 			
@@ -1379,6 +1431,45 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				return true;
 			}
 			
+#if !TYPE_OBJECT
+			@Override
+			public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				KEY_TYPE state = identity;
+				for(int i = 0;i<length;i++) {
+					state = operator.APPLY_KEY_VALUE(state, keys[i+offset]);
+				}
+				return state;
+			}
+			
+#else
+			@Override
+			public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				KEY_SPECIAL_TYPE state = identity;
+				for(int i = 0;i<length;i++) {
+					state = operator.apply(state, keys[i+offset]);
+				}
+				return state;
+			}
+			
+#endif
+			@Override
+			public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				KEY_TYPE state = EMPTY_KEY_VALUE;
+				boolean empty = true;
+				for(int i = 0;i<length;i++) {
+					if(empty) {
+						empty = false;
+						state = keys[i+offset];
+						continue;
+					}
+					state = operator.APPLY_KEY_VALUE(state, keys[i+offset]);
+				}
+				return state;
+			}
+			
 			@Override
 			public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -1484,6 +1575,45 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				return true;
 			}
 			
+#if !VALUE_OBJECT
+			@Override
+			public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = identity;
+				for(int i = 0;i<length;i++) {
+					state = operator.APPLY_VALUE(state, values[offset+i]);
+				}
+				return state;
+			}
+			
+#else
+			@Override
+			public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				VALUE_SPECIAL_TYPE state = identity;
+				for(int i = 0;i<length;i++) {
+					state = operator.apply(state, values[offset+i]);
+				}
+				return state;
+			}
+			
+#endif
+			@Override
+			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = EMPTY_VALUE;
+				boolean empty = true;
+				for(int i = 0;i<length;i++) {
+					if(empty) {
+						empty = false;
+						state = values[offset+i];
+						continue;
+					}
+					state = operator.APPLY_VALUE(state, values[offset+i]);
+				}
+				return state;
+			}
+			
 			@Override
 			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -1630,12 +1760,14 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			}
 			
 			public int previousEntry() {
+				if(!hasPrevious()) throw new NoSuchElementException();
 				int returnIndex = offset+index;
 				lastReturned = index--;
 				return returnIndex;
 			}
 			
 			public int nextEntry() {
+				if(!hasNext()) throw new NoSuchElementException();
 				int returnIndex = offset+index;
 				lastReturned = index++;
 				return returnIndex;
@@ -1782,6 +1914,32 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			for(int i = 0;i<size;i++) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			for(int i = 0;i<size;i++) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(keys[i], values[i]);
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(keys[i], values[i]));
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -1811,8 +1969,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return ARRAY_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return ARRAY_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					int index = ARRAY_MAP.this.findIndex(entry.ENTRY_KEY());
+					if(index >= 0) return VALUE_EQUALS(entry.ENTRY_VALUE(), ARRAY_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					int index = ARRAY_MAP.this.findIndex(entry.getKey());
+					if(index >= 0) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(ARRAY_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -1861,7 +2027,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			ARRAY_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -1872,7 +2038,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public boolean remove(KEY_TYPE o) {
 			int oldSize = size;
-			remove(o);
+			ARRAY_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -1948,6 +2114,45 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			for(int i = 0;i<size;i++) {
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			for(int i = 0;i<size;i++) {
+				state = operator.apply(state, keys[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			for(int i = 0;i<size;i++) {
+				if(empty) {
+					empty = false;
+					state = keys[i];
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, keys[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2044,6 +2249,45 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			for(int i = 0;i<size;i++) {
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			for(int i = 0;i<size;i++) {
+				state = operator.apply(state, values[i]);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			for(int i = 0;i<size;i++) {
+				if(empty) {
+					empty = false;
+					state = values[i];
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, values[i]);
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2190,11 +2434,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 		
 		public int previousEntry() {
+			if(!hasPrevious()) throw new NoSuchElementException();
 			lastReturned = index;
 			return index--;
 		}
 		
 		public int nextEntry() {
+			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = index;
 			return index++;
 		}
@@ -2269,7 +2515,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(keys[index]) + "->" + VALUE_TO_STRING(values[index]);
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 }

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/EnumMap.template

@@ -3,9 +3,7 @@ package speiger.src.collections.PACKAGE.maps.impl.misc;
 import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
-#if VALUE_OBJECT
 import java.util.Objects;
-#endif
 
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -13,6 +11,14 @@ import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
 #if !VALUE_OBJECT
 import speiger.src.collections.objects.collections.ObjectIterator;
 #endif
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
+import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
+import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#endif
+import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
+import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 import speiger.src.collections.objects.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.objects.maps.interfaces.MAP;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
@@ -28,13 +34,13 @@ import speiger.src.collections.objects.sets.ObjectSet;
 public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** Enum Type that is being used */
-	protected final Class<T> keyType;
+	protected Class<T> keyType;
 	/** The Backing keys array. */
-	protected transient final T[] keys;
+	protected transient T[] keys;
 	/** The Backing values array */
-	protected transient final VALUE_TYPE[] values;
+	protected transient VALUE_TYPE[] values;
 	/** The Backing array that indicates which index is present or not */
-	protected transient final long[] present;
+	protected transient long[] present;
 	/** Amount of Elements stored in the ArrayMap */
 	protected int size = 0;
 	/** EntrySet cache */
@@ -44,6 +50,9 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	/** Values cache */
 	protected transient VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
 	
+	protected ENUM_MAP() {
+		
+	}
 	/**
 	 * Default Constructor
 	 * @param keyType the type of Enum that should be used
@@ -55,6 +64,86 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		present = new long[((keys.length - 1) >> 6) + 1];
 	}
 	
+#if !VALUE_OBJECT
+	/**
+	 * Helper constructor that allow to create a EnumMap from boxed values (it will unbox them)
+	 * @param keys the keys that should be put into the EnumMap
+	 * @param values the values that should be put into the EnumMap.
+	 * @throws IllegalStateException if the keys and values do not match in lenght
+	 */
+	public ENUM_MAP(T[] keys, CLASS_VALUE_TYPE[] values) {
+		if(keys.length <= 0) throw new IllegalArgumentException("Empty Array are not allowed");
+		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
+		keyType = keys[0].getDeclaringClass();
+		this.keys = getKeyUniverse(keyType);
+		this.values = NEW_VALUE_ARRAY(keys.length);
+		present = new long[((keys.length - 1) >> 6) + 1];
+		putAll(keys, values);
+	}
+	
+#endif
+	/**
+	 * Helper constructor that allow to create a EnumMap from unboxed values
+	 * @param keys the keys that should be put into the map
+	 * @param values the values that should be put into the map.
+	 * @throws IllegalStateException if the keys and values do not match in lenght
+	 */
+	public ENUM_MAP(T[] keys, VALUE_TYPE[] values) {
+		if(keys.length <= 0) throw new IllegalArgumentException("Empty Array are not allowed");
+		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
+		keyType = keys[0].getDeclaringClass();
+		this.keys = getKeyUniverse(keyType);
+		this.values = NEW_VALUE_ARRAY(keys.length);
+		present = new long[((keys.length - 1) >> 6) + 1];
+		putAll(keys, values);		
+	}
+	
+	/**
+	 * A Helper constructor that allows to create a EnumMap with exactly the same values as the provided map.
+	 * @param map the values that should be present in the map
+	 */
+	public ENUM_MAP(Map<? extends CLASS_TYPE, ? extends CLASS_VALUE_TYPE> map) {
+		if(map instanceof ENUM_MAP) {
+			ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			size = enumMap.size;
+		}
+		else if(map.isEmpty()) throw new IllegalArgumentException("Empty Maps are not allowed");
+		else {
+			keyType = map.keySet().iterator().next().getDeclaringClass();
+			this.keys = getKeyUniverse(keyType);
+			this.values = NEW_VALUE_ARRAY(keys.length);
+			present = new long[((keys.length - 1) >> 6) + 1];
+			putAll(map);
+		}
+	}
+	
+	/**
+	 * A Type Specific Helper function that allows to create a new EnumMap with exactly the same values as the provided map.
+	 * @param map the values that should be present in the map
+ 	 */
+	public ENUM_MAP(MAP KEY_VALUE_GENERIC_TYPE map) {
+		if(map instanceof ENUM_MAP) {
+			ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			size = enumMap.size;
+		}
+		else if(map.isEmpty()) throw new IllegalArgumentException("Empty Maps are not allowed");
+		else {
+			keyType = map.keySet().iterator().next().getDeclaringClass();
+			this.keys = getKeyUniverse(keyType);
+			this.values = NEW_VALUE_ARRAY(keys.length);
+			present = new long[((keys.length - 1) >> 6) + 1];
+			putAll(map);
+		}
+	}
+	
 	@Override
 	public VALUE_TYPE put(T key, VALUE_TYPE value) {
 		int index = key.ordinal();
@@ -94,6 +183,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 #endif
 	@Override
 	public boolean containsKey(Object key) {
+		if(!keyType.isInstance(key)) return false;
 		return isSet(((T)key).ordinal());
 	}
 	
@@ -101,7 +191,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	@Override
 	public boolean containsValue(Object value) {
 		for(int i = 0;i<values.length;i++)
-			if(VALUE_EQUALS(value, values[i])) return true;
+			if(isSet(i) && VALUE_EQUALS(value, values[i])) return true;
 		return false;
 	}
 	
@@ -109,13 +199,25 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
 		for(int i = 0;i<values.length;i++)
-			if(VALUE_EQUALS(value, values[i])) return true;
+			if(isSet(i) && VALUE_EQUALS(value, values[i])) return true;
 		return false;
 	}
 	
 #endif
+	@Override
+	public CLASS_VALUE_TYPE remove(Object key) {
+		if(!keyType.isInstance(key)) return getDefaultReturnValue();
+		int index = ((T)key).ordinal();
+		if(!isSet(index)) return getDefaultReturnValue();
+		clear(index);
+		VALUE_TYPE result = values[index];
+		values[index] = EMPTY_VALUE;
+		return result;
+	}
+	
 	@Override
 	public VALUE_TYPE rem(T key) {
+		if(!keyType.isInstance(key)) return getDefaultReturnValue();
 		int index = key.ordinal();
 		if(!isSet(index)) return getDefaultReturnValue();
 		clear(index);
@@ -157,6 +259,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 #endif
 	@Override
 	public VALUE_TYPE GET_VALUE(T key) {
+		if(!keyType.isInstance(key)) return getDefaultReturnValue();
 		int index = key.ordinal();
 		return isSet(index) ? values[index] : getDefaultReturnValue();
 	}
@@ -164,6 +267,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 #if VALUE_OBJECT
 	@Override
 	public VALUE_TYPE getOrDefault(Object key, VALUE_TYPE defaultValue) {
+		if(!keyType.isInstance(key)) return defaultValue;
 		int index = ((T)key).ordinal();
 		return isSet(index) ? values[index] : defaultValue;
 	}
@@ -171,6 +275,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 #else
 	@Override
 	public VALUE_TYPE getOrDefault(T key, VALUE_TYPE defaultValue) {
+		if(!keyType.isInstance(key)) return defaultValue;
 		int index = key.ordinal();
 		return isSet(index) ? values[index] : defaultValue;
 	}
@@ -203,6 +308,145 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		return valuesC;
 	}
 	
+	@Override
+	public void forEach(BI_CONSUMER KEY_VALUE_GENERIC_TYPE action) {
+		if(size() <= 0) return;
+		for(int i = 0,m=keys.length;i<m;i++) {
+			if(isSet(i)) action.accept(keys[i], values[i]);
+		}
+	}
+	
+	@Override
+	public boolean replace(T key, VALUE_TYPE oldValue, VALUE_TYPE newValue) {
+		int index = key.ordinal();
+		if(!isSet(index) || values[index] != oldValue) return false;
+		values[index] = newValue;
+		return true;
+	}
+	
+	@Override
+	public VALUE_TYPE replace(T key, VALUE_TYPE value) {
+		int index = key.ordinal();
+		if(!isSet(index)) return getDefaultReturnValue();
+		VALUE_TYPE oldValue = values[index];
+		values[index] = value;
+		return oldValue;
+	}
+	
+	@Override
+	public VALUE_TYPE COMPUTE(T key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		int index = key.ordinal();
+		if(!isSet(index)) {
+			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			set(index);
+			values[index] = newValue;
+			return newValue;
+		}
+		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, values[index]);
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			clear(index);
+			values[index] = EMPTY_VALUE;
+			return newValue;
+		}
+		values[index] = newValue;
+		return newValue;
+	}
+	
+	@Override
+	public VALUE_TYPE COMPUTE_IF_ABSENT(T key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		int index = key.ordinal();
+		if(!isSet(index)) {
+			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			set(index);
+			values[index] = newValue;			
+			return newValue;
+		}
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
+	}
+	
+	@Override
+	public VALUE_TYPE SUPPLY_IF_ABSENT(T key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		int index = key.ordinal();
+		if(!isSet(index)) {
+			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			set(index);
+			values[index] = newValue;			
+			return newValue;
+		}
+		VALUE_TYPE newValue = values[index];
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			values[index] = newValue;
+		}
+		return newValue;
+	}
+	
+	@Override
+	public VALUE_TYPE COMPUTE_IF_PRESENT(T key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		int index = key.ordinal();
+		if(!isSet(index) || VALUE_EQUALS(values[index], getDefaultReturnValue())) return getDefaultReturnValue();
+		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, values[index]);
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			clear(index);
+			values[index] = EMPTY_VALUE;
+			return newValue;
+		}
+		values[index] = newValue;
+		return newValue;
+	}
+	
+	@Override
+	public VALUE_TYPE MERGE(T key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		int index = key.ordinal();
+#if VALUE_OBJECT
+		Objects.requireNonNull(value);
+#endif
+		VALUE_TYPE newValue = !isSet(index) || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(values[index], value);
+		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+			if(isSet(index)) {
+				clear(index);
+				values[index] = EMPTY_VALUE;
+			}
+		}
+		else if(!isSet(index)) {
+			set(index);
+			values[index] = newValue;
+		}
+		else values[index] = newValue;
+		return newValue;
+	}
+	
+	@Override
+	public void BULK_MERGE(MAP KEY_VALUE_GENERIC_TYPE m, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
+			T key = entry.ENTRY_KEY();
+			int index = key.ordinal();
+			VALUE_TYPE newValue = !isSet(index) || VALUE_EQUALS(values[index], getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(values[index], entry.ENTRY_VALUE());
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
+				if(isSet(index)) {
+					clear(index);
+					values[index] = EMPTY_VALUE;
+				}
+			}
+			else if(!isSet(index)) {
+				set(index);
+				values[index] = newValue;
+			}
+			else values[index] = newValue;
+		}
+	}
+	
 	@Override
 	public void clear() {
 		if(size == 0) return;
@@ -211,6 +455,11 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		Arrays.fill(values, EMPTY_VALUE);
 	}
 	
+	@Override
+	public int size() {
+		return size;
+	}
+	
 	protected void onNodeAdded(int index) {
 		
 	}
@@ -220,16 +469,18 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	}
 	
 	protected void set(int index) {
-		present[index >> 6] |= (1L << index); 
 		onNodeAdded(index);
+		present[index >> 6] |= (1L << index); 
+		size++;
 	}
 	protected void clear(int index) { 
+		size--;
 		present[index >> 6] &= ~(1L << index);
 		onNodeRemoved(index);
 	}
 	protected boolean isSet(int index) { return (present[index >> 6] & (1L << index)) != 0; }
 	
-	private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
+	protected static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
 		return keyType.getEnumConstants();
 	}
 	
@@ -237,7 +488,20 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		
 		@Override
 		public boolean contains(Object o) {
-			if(o instanceof Map.Entry) return containsKey(((Map.Entry<?, ?>)o).getKey());
+			if(o instanceof Map.Entry) {
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					if(!keyType.isInstance(entry.ENTRY_KEY())) return false;
+					int index = ((T)entry.ENTRY_KEY()).ordinal();
+					if(index >= 0 && ENUM_MAP.this.isSet(index)) return VALUE_EQUALS(entry.ENTRY_VALUE(), ENUM_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					if(!keyType.isInstance(entry.getKey())) return false;
+					int index = ((T)entry.getKey()).ordinal();
+					if(index >= 0 && ENUM_MAP.this.isSet(index)) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(ENUM_MAP.this.values[index]));
+				}
+			}
 			return false;
 		}
 		
@@ -333,8 +597,7 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	class EntryIterator extends MapIterator implements ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
-			int index = nextEntry();
-			return new BasicEntry<>(keys[index], values[index]);
+			return new MapEntry(nextEntry());
 		}
 	}
 	
@@ -369,13 +632,74 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 		public int nextEntry() {
 			if(!hasNext()) throw new NoSuchElementException();
 			lastReturnValue = nextIndex;
-			return nextIndex;
+			nextIndex = -1;
+			return lastReturnValue;
 		}
 		
 		public void remove() {
 			if(lastReturnValue == -1) throw new IllegalStateException();
 			clear(lastReturnValue);
 			values[lastReturnValue] = EMPTY_VALUE;
+			lastReturnValue = -1;
+		}
+	}
+	
+	protected class MapEntry implements MAP.Entry KEY_VALUE_GENERIC_TYPE, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> {
+		public int index = -1;
+		
+		public MapEntry() {}
+		public MapEntry(int index) {
+			this.index = index;
+		}
+
+		@Override
+		public KEY_TYPE ENTRY_KEY() {
+			return keys[index];
+		}
+
+		@Override
+		public VALUE_TYPE ENTRY_VALUE() {
+			return values[index];
+		}
+
+		@Override
+		public VALUE_TYPE setValue(VALUE_TYPE value) {
+			VALUE_TYPE oldValue = values[index];
+			values[index] = value;
+			return oldValue;
+		}
+		
+		@Override
+		public boolean equals(Object obj) {
+			if(obj instanceof Map.Entry) {
+				if(obj instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)obj;
+					return KEY_EQUALS(keys[index], entry.ENTRY_KEY()) && VALUE_EQUALS(values[index], entry.ENTRY_VALUE());
+				}
+				Map.Entry<?, ?> entry = (Map.Entry<?, ?>)obj;
+				Object key = entry.getKey();
+				Object value = entry.getValue();
+#if TYPE_OBJECT && VALUE_OBJECT
+				return KEY_EQUALS(keys[index], key) && VALUE_EQUALS(values[index], value);
+#else if TYPE_OBJECT
+				return value instanceof CLASS_VALUE_TYPE && KEY_EQUALS(keys[index], key) && VALUE_EQUALS(values[index], CLASS_TO_VALUE(value));
+#else if VALUE_OBJECT
+				return key instanceof CLASS_TYPE && KEY_EQUALS(keys[index], CLASS_TO_KEY(key)) && VALUE_EQUALS(values[index], value);
+#else
+				return key instanceof CLASS_TYPE && value instanceof CLASS_VALUE_TYPE && KEY_EQUALS(keys[index], CLASS_TO_KEY(key)) && VALUE_EQUALS(values[index], CLASS_TO_VALUE(value));
+#endif
+			}
+			return false;
+		}
+		
+		@Override
+		public int hashCode() {
+			return KEY_TO_HASH(keys[index]) ^ VALUE_TO_HASH(values[index]);
+		}
+		
+		@Override
+		public String toString() {
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 }

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template

@@ -59,6 +59,136 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		links = new long[keys.length];
 	}
 	
+#if !VALUE_OBJECT
+	/**
+	 * Helper constructor that allow to create a EnumMap from boxed values (it will unbox them)
+	 * @param keys the keys that should be put into the EnumMap
+	 * @param values the values that should be put into the EnumMap.
+	 * @throws IllegalStateException if the keys and values do not match in lenght
+	 */
+	public LINKED_ENUM_MAP(T[] keys, CLASS_VALUE_TYPE[] values) {
+		if(keys.length <= 0) throw new IllegalArgumentException("Empty Array are not allowed");
+		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
+		keyType = keys[0].getDeclaringClass();
+		this.keys = getKeyUniverse(keyType);
+		this.values = NEW_VALUE_ARRAY(keys.length);
+		present = new long[((keys.length - 1) >> 6) + 1];
+		links = new long[keys.length];
+		putAll(keys, values);
+	}
+	
+#endif
+	/**
+	 * Helper constructor that allow to create a EnumMap from unboxed values
+	 * @param keys the keys that should be put into the map
+	 * @param values the values that should be put into the map.
+	 * @throws IllegalStateException if the keys and values do not match in lenght
+	 */
+	public LINKED_ENUM_MAP(T[] keys, VALUE_TYPE[] values) {
+		if(keys.length <= 0) throw new IllegalArgumentException("Empty Array are not allowed");
+		if(keys.length != values.length) throw new IllegalArgumentException("Keys and Values have to be the same size");
+		keyType = keys[0].getDeclaringClass();
+		this.keys = getKeyUniverse(keyType);
+		this.values = NEW_VALUE_ARRAY(keys.length);
+		present = new long[((keys.length - 1) >> 6) + 1];
+		links = new long[keys.length];
+		putAll(keys, values);		
+	}
+	
+	/**
+	 * A Helper constructor that allows to create a EnumMap with exactly the same values as the provided map.
+	 * @param map the values that should be present in the map
+	 */
+	public LINKED_ENUM_MAP(Map<? extends CLASS_TYPE, ? extends CLASS_VALUE_TYPE> map) {
+		if(map instanceof LINKED_ENUM_MAP) {
+			LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			links = enumMap.links.clone();
+			size = enumMap.size;
+		}
+		else if(map instanceof ENUM_MAP) {
+			ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			links = new long[keys.length];
+			for(int i = 0,m=keys.length;i<m;i++) {
+				if(isSet(i)) {
+					if(size == 0) {
+						firstIndex = lastIndex = i;
+						links[i] = -1L;
+					}
+					else {
+						links[lastIndex] ^= ((links[lastIndex] ^ (i & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
+						links[i] = ((lastIndex & 0xFFFFFFFFL) << 32) | 0xFFFFFFFFL;
+						lastIndex = i;
+					}
+					size++;
+				}
+			}
+		}
+		else if(map.isEmpty()) throw new IllegalArgumentException("Empty Maps are not allowed");
+		else {
+			keyType = map.keySet().iterator().next().getDeclaringClass();
+			this.keys = getKeyUniverse(keyType);
+			this.values = NEW_VALUE_ARRAY(keys.length);
+			present = new long[((keys.length - 1) >> 6) + 1];
+			links = new long[keys.length];
+			putAll(map);
+		}
+	}
+	
+	/**
+	 * A Type Specific Helper function that allows to create a new EnumMap with exactly the same values as the provided map.
+	 * @param map the values that should be present in the map
+ 	 */
+	public LINKED_ENUM_MAP(MAP KEY_VALUE_GENERIC_TYPE map) {
+		if(map instanceof LINKED_ENUM_MAP) {
+			LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (LINKED_ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			links = enumMap.links.clone();
+			size = enumMap.size;
+		}
+		else if(map instanceof ENUM_MAP) {
+			ENUM_MAP KEY_VALUE_GENERIC_TYPE enumMap = (ENUM_MAP KEY_VALUE_GENERIC_TYPE)map;
+			keyType = enumMap.keyType;
+			keys = enumMap.keys;
+			values = enumMap.values.clone();
+			present = enumMap.present.clone();
+			links = new long[keys.length];
+			for(int i = 0,m=keys.length;i<m;i++) {
+				if(isSet(i)) {
+					if(size == 0) {
+						firstIndex = lastIndex = i;
+						links[i] = -1L;
+					}
+					else {
+						links[lastIndex] ^= ((links[lastIndex] ^ (i & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
+						links[i] = ((lastIndex & 0xFFFFFFFFL) << 32) | 0xFFFFFFFFL;
+						lastIndex = i;
+					}
+					size++;
+				}
+			}
+		}
+		else if(map.isEmpty()) throw new IllegalArgumentException("Empty Maps are not allowed");
+		else {
+			keyType = map.keySet().iterator().next().getDeclaringClass();
+			this.keys = getKeyUniverse(keyType);
+			this.values = NEW_VALUE_ARRAY(keys.length);
+			present = new long[((keys.length - 1) >> 6) + 1];
+			links = new long[keys.length];
+			putAll(map);
+		}
+	}
+	
 	@Override
 	public VALUE_TYPE putAndMoveToFirst(T key, VALUE_TYPE value) {
 		int index = key.ordinal();
@@ -389,8 +519,18 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return LINKED_ENUM_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return LINKED_ENUM_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					if(!keyType.isInstance(entry.ENTRY_KEY())) return false;
+					int index = ((T)entry.ENTRY_KEY()).ordinal();
+					if(index >= 0 && LINKED_ENUM_MAP.this.isSet(index)) return VALUE_EQUALS(entry.ENTRY_VALUE(), LINKED_ENUM_MAP.this.values[index]);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					if(!keyType.isInstance(entry.getKey())) return false;
+					int index = ((T)entry.getKey()).ordinal();
+					if(index >= 0 && LINKED_ENUM_MAP.this.isSet(index)) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(LINKED_ENUM_MAP.this.values[index]));
+				}
 			}
 			return false;
 		}
@@ -442,7 +582,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		@Override
 		public boolean remove(Object o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_ENUM_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -455,7 +595,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		@Override
 		public boolean remove(T o) {
 			int oldSize = size;
-			remove(o);
+			LINKED_ENUM_MAP.this.remove(o);
 			return size != oldSize;
 		}
 		
@@ -757,6 +897,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 				previous = (int)(links[current] >>> 32);
 			}
 			else next = (int)links[current];
+			
 			size--;
 			if(previous == -1) firstIndex = next;
 			else links[previous] ^= ((links[previous] ^ (next & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
@@ -764,6 +905,8 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 			if (next == -1) lastIndex = previous;
 			else links[next] ^= ((links[next] ^ ((previous & 0xFFFFFFFFL) << 32)) & 0xFFFFFFFF00000000L);
 			values[current] = EMPTY_VALUE;
+			present[current >> 6] &= ~(1L << current);
+			current = -1;
 		}
 		
 		public int previousEntry() {
@@ -855,7 +998,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		
 		@Override
 		public String toString() {
-			return KEY_TO_STRING(keys[index]) + "->" + VALUE_TO_STRING(values[index]);
+			return KEY_TO_STRING(keys[index]) + "=" + VALUE_TO_STRING(values[index]);
 		}
 	}
 }

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/AVLTreeMap.template

@@ -5,6 +5,7 @@ import java.util.Map;
 import java.util.Comparator;
 #endif
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 import java.util.Objects;
 import java.util.NoSuchElementException;
 
@@ -20,6 +21,9 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
@@ -65,6 +69,10 @@ import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.objects.collections.ObjectIterator;
 #endif
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.sets.AbstractObjectSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
@@ -225,6 +233,9 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 #endif
 	@Override
 	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -259,6 +270,9 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -294,6 +308,9 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 #if VALUE_PRIMITIVES
 	@Override
 	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -502,6 +519,10 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
@@ -520,6 +541,10 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
@@ -527,11 +552,20 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			put(key, newValue);
 			return newValue;
 		}
+		if(VALUE_EQUALS(entry.value, getDefaultReturnValue())) {
+			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			entry.value = newValue;
+		}
 		return entry.value;
 	}
 	
 	@Override
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
@@ -539,13 +573,22 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			put(key, newValue);
 			return newValue;
 		}
+		if(VALUE_EQUALS(entry.value, getDefaultReturnValue())) {
+			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			entry.value = newValue;
+		}
 		return entry.value;
 	}
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
-		if(entry == null) return getDefaultReturnValue();
+		if(entry == null || VALUE_EQUALS(entry.value, getDefaultReturnValue())) return getDefaultReturnValue();
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, entry.value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			removeNode(entry);
@@ -557,8 +600,12 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
-		VALUE_TYPE newValue = entry == null ? value : mappingFunction.APPLY_VALUE(entry.value, value);
+		VALUE_TYPE newValue = entry == null || VALUE_EQUALS(entry.value, getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(entry.value, value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			if(entry != null)
 				removeNode(entry);
@@ -574,7 +621,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
 			KEY_TYPE key = entry.ENTRY_KEY();
 			Entry KEY_VALUE_GENERIC_TYPE subEntry = findNode(key);
-			VALUE_TYPE newValue = subEntry == null ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(subEntry.value, entry.ENTRY_VALUE());
+			VALUE_TYPE newValue = subEntry == null || VALUE_EQUALS(subEntry.value, getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(subEntry.value, entry.ENTRY_VALUE());
 			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 				if(subEntry != null)
 					removeNode(subEntry);
@@ -852,6 +899,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 	}
 	
+	protected void validate(KEY_TYPE k) { compare(k, k); }
 	protected int compare(KEY_TYPE k, KEY_TYPE v) { return comparator != null ? comparator.compare(k, v) : COMPAREABLE_TO_KEY(k, v);}
 	
 	/** From CLR */
@@ -1483,8 +1531,21 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			@Deprecated
 			public boolean contains(Object o) {
 				if(o instanceof Map.Entry) {
-					if(o instanceof MAP.Entry) return NavigableSubMap.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-					return NavigableSubMap.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+					if(o instanceof MAP.Entry) {
+						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+						if(entry.getKey() == null && comparator() == null) return false;
+						AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = m.findNode(entry.ENTRY_KEY());
+						if(subEntry != null) return VALUE_EQUALS(entry.ENTRY_VALUE(), subEntry.value);
+					}
+					else {
+						Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+						if(entry.getKey() == null && comparator() == null) return false;
+#if !TYPE_OBJECT
+						if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+						AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = m.findNode((CLASS_TYPE)entry.getKey());
+						if(subEntry != null) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(subEntry.value));
+					}
 				}
 				return false;
 			}
@@ -1559,6 +1620,32 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				return true;
 			}
 			
+			@Override
+			public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+				Objects.requireNonNull(operator);
+				E state = identity;
+				for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+				}
+				return state;
+			}
+			
+			@Override
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+				boolean empty = true;
+				for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					if(empty) {
+						empty = false;
+						state = new BasicEntryKV_BRACES(entry.key, entry.value);
+						continue;
+					}
+					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+				}
+				return state;
+			}
+			
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
@@ -1653,6 +1740,43 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				return true;
 			}
 			
+#if !VALUE_OBJECT
+			@Override
+			public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = identity;
+				for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					state = operator.APPLY_VALUE(state, entry.value);
+				return state;
+			}
+			
+#else
+			@Override
+			public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				VALUE_SPECIAL_TYPE state = identity;
+				for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					state = operator.apply(state, entry.value);
+				return state;
+			}
+			
+#endif
+			@Override
+			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = EMPTY_VALUE;
+				boolean empty = true;
+				for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					if(empty) {
+						empty = false;
+						state = entry.value;
+						continue;
+					}
+					state = operator.APPLY_VALUE(state, entry.value);
+				}
+				return state;
+			}
+			
 			@Override
 			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -1813,8 +1937,21 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return AVL_TREE_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return AVL_TREE_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					if(entry.getKey() == null && comparator() == null) return false;
+					AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = AVL_TREE_MAP.this.findNode(entry.ENTRY_KEY());
+					if(subEntry != null) return VALUE_EQUALS(entry.ENTRY_VALUE(), subEntry.value);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					if(entry.getKey() == null && comparator() == null) return false;
+#if !TYPE_OBJECT
+					if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+					AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = AVL_TREE_MAP.this.findNode((CLASS_TYPE)entry.getKey());
+					if(subEntry != null) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(subEntry.value));
+				}
 			}
 			return false;
 		}
@@ -1893,6 +2030,32 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(entry.key, entry.value);
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -2077,6 +2240,43 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				state = operator.APPLY_KEY_VALUE(state, entry.key);
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				state = operator.apply(state, entry.key);
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry)) {
+				if(empty) {
+					empty = false;
+					state = entry.key;
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2164,6 +2364,43 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				state = operator.APPLY_VALUE(state, entry.value);
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				state = operator.apply(state, entry.value);
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			for(AVL_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				if(empty) {
+					empty = false;
+					state = entry.value;
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, entry.value);
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2380,6 +2617,43 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 		
 #endif
+		@Override
+		public boolean equals(Object obj) {
+			if(obj instanceof Map.Entry) {
+				if(obj instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)obj;
+#if TYPE_OBJECT
+					if(entry.ENTRY_KEY() == null) return false;
+#endif
+					return KEY_EQUALS(key, entry.ENTRY_KEY()) && VALUE_EQUALS(value, entry.ENTRY_VALUE());
+				}
+				Map.Entry<?, ?> entry = (Map.Entry<?, ?>)obj;
+				Object otherKey = entry.getKey();
+				if(otherKey == null) return false;
+				Object otherValue = entry.getValue();
+#if TYPE_OBJECT && VALUE_OBJECT
+				return KEY_EQUALS(key, otherKey) && VALUE_EQUALS(value, otherValue);
+#else if TYPE_OBJECT
+				return otherValue instanceof CLASS_VALUE_TYPE && KEY_EQUALS(key, otherKey) && VALUE_EQUALS(value, CLASS_TO_VALUE(otherValue));
+#else if VALUE_OBJECT
+				return otherKey instanceof CLASS_TYPE && KEY_EQUALS(key, CLASS_TO_KEY(otherKey)) && VALUE_EQUALS(value, otherValue);
+#else
+				return otherKey instanceof CLASS_TYPE && otherValue instanceof CLASS_VALUE_TYPE && KEY_EQUALS(key, CLASS_TO_KEY(otherKey)) && VALUE_EQUALS(value, CLASS_TO_VALUE(otherValue));
+#endif
+			}
+			return false;
+		}
+		
+		@Override
+		public int hashCode() {
+			return KEY_TO_HASH(key) ^ VALUE_TO_HASH(value);
+		}
+		
+		@Override
+		public String toString() {
+			return KEY_TO_STRING(key) + "=" + VALUE_TO_STRING(value);
+		}
+		
 		int getHeight() { return state; }
 		
 		void updateHeight() { state = (1 + Math.max(left == null ? -1 : left.getHeight(), right == null ? -1 : right.getHeight())); }

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/RBTreeMap.template

@@ -7,6 +7,7 @@ import java.util.Comparator;
 import java.util.Objects;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
@@ -20,6 +21,9 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
+#if !SAME_TYPE
+import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
+#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
@@ -65,6 +69,10 @@ import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.objects.collections.ObjectIterator;
 #endif
 #if !TYPE_OBJECT
+#if !VALUE_OBJECT
+import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator;
+
+#endif
 import speiger.src.collections.objects.sets.AbstractObjectSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
@@ -225,6 +233,9 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 #endif
 	@Override
 	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -259,6 +270,10 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
+
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -294,6 +309,9 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 #if VALUE_PRIMITIVES
 	@Override
 	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) {
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryKV_BRACES(key, value, null);
 			size++;
@@ -501,6 +519,10 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, getDefaultReturnValue());
@@ -519,6 +541,10 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
@@ -526,11 +552,20 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			put(key, newValue);
 			return newValue;
 		}
+		if(VALUE_EQUALS(entry.value, getDefaultReturnValue())) {
+			VALUE_TYPE newValue = mappingFunction.GET_VALUE(key);
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			entry.value = newValue;
+		}
 		return entry.value;
 	}
 	
 	@Override
 	public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) {
+		Objects.requireNonNull(valueProvider);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
 		if(entry == null) {
 			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
@@ -538,13 +573,22 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			put(key, newValue);
 			return newValue;
 		}
+		if(VALUE_EQUALS(entry.value, getDefaultReturnValue())) {
+			VALUE_TYPE newValue = valueProvider.VALUE_GET_KEY();
+			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) return newValue;
+			entry.value = newValue;
+		}
 		return entry.value;
 	}
 	
 	@Override
 	public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
-		if(entry == null) return getDefaultReturnValue();
+		if(entry == null || VALUE_EQUALS(entry.value, getDefaultReturnValue())) return getDefaultReturnValue();
 		VALUE_TYPE newValue = mappingFunction.APPLY_VALUE(key, entry.value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			removeNode(entry);
@@ -556,8 +600,12 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	
 	@Override
 	public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) {
+		Objects.requireNonNull(mappingFunction);
+#if TYPE_OBJECT
+		validate(key);
+#endif
 		Entry KEY_VALUE_GENERIC_TYPE entry = findNode(key);
-		VALUE_TYPE newValue = entry == null ? value : mappingFunction.APPLY_VALUE(entry.value, value);
+		VALUE_TYPE newValue = entry == null || VALUE_EQUALS(entry.value, getDefaultReturnValue()) ? value : mappingFunction.APPLY_VALUE(entry.value, value);
 		if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 			if(entry != null)
 				removeNode(entry);
@@ -573,7 +621,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		for(MAP.Entry KEY_VALUE_GENERIC_TYPE entry : MAPS.fastIterable(m)) {
 			KEY_TYPE key = entry.ENTRY_KEY();
 			Entry KEY_VALUE_GENERIC_TYPE subEntry = findNode(key);
-			VALUE_TYPE newValue = subEntry == null ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(subEntry.value, entry.ENTRY_VALUE());
+			VALUE_TYPE newValue = subEntry == null || VALUE_EQUALS(subEntry.value, getDefaultReturnValue()) ? entry.ENTRY_VALUE() : mappingFunction.APPLY_VALUE(subEntry.value, entry.ENTRY_VALUE());
 			if(VALUE_EQUALS(newValue, getDefaultReturnValue())) {
 				if(subEntry != null)
 					removeNode(subEntry);
@@ -857,6 +905,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 	}
 	
+	protected void validate(KEY_TYPE k) { compare(k, k); }
 	protected int compare(KEY_TYPE k, KEY_TYPE v) { return comparator != null ? comparator.compare(k, v) : COMPAREABLE_TO_KEY(k, v);}
 	protected static GENERIC_KEY_VALUE_BRACES boolean isBlack(Entry KEY_VALUE_GENERIC_TYPE p) { return p == null || p.isBlack(); }
 	protected static GENERIC_KEY_VALUE_BRACES Entry KEY_VALUE_GENERIC_TYPE parentOf(Entry KEY_VALUE_GENERIC_TYPE p) { return (p == null ? null : p.parent); }
@@ -1537,8 +1586,21 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			@Deprecated
 			public boolean contains(Object o) {
 				if(o instanceof Map.Entry) {
-					if(o instanceof MAP.Entry) return NavigableSubMap.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-					return NavigableSubMap.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+					if(o instanceof MAP.Entry) {
+						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+						if(entry.getKey() == null && comparator() == null) return false;
+						RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = m.findNode(entry.ENTRY_KEY());
+						if(subEntry != null) return VALUE_EQUALS(entry.ENTRY_VALUE(), subEntry.value);
+					}
+					else {
+						Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+						if(entry.getKey() == null && comparator() == null) return false;
+#if !TYPE_OBJECT
+						if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+						RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = m.findNode((CLASS_TYPE)entry.getKey());
+						if(subEntry != null) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(subEntry.value));
+					}
 				}
 				return false;
 			}
@@ -1613,6 +1675,32 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				return true;
 			}
 			
+			@Override
+			public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+				Objects.requireNonNull(operator);
+				E state = identity;
+				for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+				}
+				return state;
+			}
+			
+			@Override
+			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+				boolean empty = true;
+				for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					if(empty) {
+						empty = false;
+						state = new BasicEntryKV_BRACES(entry.key, entry.value);
+						continue;
+					}
+					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+				}
+				return state;
+			}
+			
 			@Override
 			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
@@ -1707,6 +1795,43 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				return true;
 			}
 			
+#if !VALUE_OBJECT
+			@Override
+			public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = identity;
+				for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					state = operator.APPLY_VALUE(state, entry.value);
+				return state;
+			}
+			
+#else
+			@Override
+			public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+				Objects.requireNonNull(operator);
+				VALUE_SPECIAL_TYPE state = identity;
+				for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					state = operator.apply(state, entry.value);
+				return state;
+			}
+			
+#endif
+			@Override
+			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+				Objects.requireNonNull(operator);
+				VALUE_TYPE state = EMPTY_VALUE;
+				boolean empty = true;
+				for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = findLowest(), last = findHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
+					if(empty) {
+						empty = false;
+						state = entry.value;
+						continue;
+					}
+					state = operator.APPLY_VALUE(state, entry.value);
+				}
+				return state;
+			}
+			
 			@Override
 			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -1867,8 +1992,21 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		@Deprecated
 		public boolean contains(Object o) {
 			if(o instanceof Map.Entry) {
-				if(o instanceof MAP.Entry) return RB_TREE_MAP.this.containsKey(((MAP.Entry KEY_VALUE_GENERIC_TYPE)o).ENTRY_KEY());
-				return RB_TREE_MAP.this.containsKey(((Map.Entry<?, ?>)o).getKey());
+				if(o instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)o;
+					if(entry.getKey() == null && comparator() == null) return false;
+					RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = RB_TREE_MAP.this.findNode(entry.ENTRY_KEY());
+					if(subEntry != null) return VALUE_EQUALS(entry.ENTRY_VALUE(), subEntry.value);
+				}
+				else {
+					Map.Entry<?, ?> entry = (Map.Entry<?, ?>)o;
+					if(entry.getKey() == null && comparator() == null) return false;
+#if !TYPE_OBJECT
+					if(!(entry.getKey() instanceof CLASS_TYPE)) return false;
+#endif
+					RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE subEntry = RB_TREE_MAP.this.findNode((CLASS_TYPE)entry.getKey());
+					if(subEntry != null) return Objects.equals(entry.getValue(), VALUE_TO_OBJ(subEntry.value));
+				}
 			}
 			return false;
 		}
@@ -1947,6 +2085,32 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			return true;
 		}
 		
+		@Override
+		public <E> E reduce(E identity, BiFunction<E, MAP.Entry KEY_VALUE_GENERIC_TYPE, E> operator) {
+			Objects.requireNonNull(operator);
+			E state = identity;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+			}
+			return state;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			MAP.Entry KEY_VALUE_GENERIC_TYPE state = null;
+			boolean empty = true;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				if(empty) {
+					empty = false;
+					state = new BasicEntryKV_BRACES(entry.key, entry.value);
+					continue;
+				}
+				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
+			}
+			return state;
+		}
+		
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Object2BooleanFunction<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -2144,6 +2308,43 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				state = operator.APPLY_KEY_VALUE(state, entry.key);
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				state = operator.apply(state, entry.key);
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_KEY_VALUE;
+			boolean empty = true;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry)) {
+				if(empty) {
+					empty = false;
+					state = entry.key;
+					continue;
+				}
+				state = operator.APPLY_KEY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2231,6 +2432,43 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			return true;
 		}
 		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_TYPE reduce(VALUE_TYPE identity, VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = identity;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				state = operator.APPLY_VALUE(state, entry.value);
+			return state;
+		}
+		
+#else
+		@Override
+		public <VALUE_SPECIAL_TYPE> VALUE_SPECIAL_TYPE reduce(VALUE_SPECIAL_TYPE identity, BiFunction<VALUE_SPECIAL_TYPE, VALUE_TYPE, VALUE_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			VALUE_SPECIAL_TYPE state = identity;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				state = operator.apply(state, entry.value);
+			return state;
+		}
+		
+#endif
+		@Override
+		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			VALUE_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			for(RB_TREE_MAP.Entry KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+				if(empty) {
+					empty = false;
+					state = entry.value;
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, entry.value);
+			}
+			return state;
+		}
+		
 		@Override
 		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2449,6 +2687,43 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 		
 #endif
+		@Override
+		public boolean equals(Object obj) {
+			if(obj instanceof Map.Entry) {
+				if(obj instanceof MAP.Entry) {
+					MAP.Entry KEY_VALUE_GENERIC_TYPE entry = (MAP.Entry KEY_VALUE_GENERIC_TYPE)obj;
+#if TYPE_OBJECT
+					if(entry.ENTRY_KEY() == null) return false;
+#endif
+					return KEY_EQUALS(key, entry.ENTRY_KEY()) && VALUE_EQUALS(value, entry.ENTRY_VALUE());
+				}
+				Map.Entry<?, ?> entry = (Map.Entry<?, ?>)obj;
+				Object otherKey = entry.getKey();
+				if(otherKey == null) return false;
+				Object otherValue = entry.getValue();
+#if TYPE_OBJECT && VALUE_OBJECT
+				return KEY_EQUALS(key, otherKey) && VALUE_EQUALS(value, otherValue);
+#else if TYPE_OBJECT
+				return otherValue instanceof CLASS_VALUE_TYPE && KEY_EQUALS(key, otherKey) && VALUE_EQUALS(value, CLASS_TO_VALUE(otherValue));
+#else if VALUE_OBJECT
+				return otherKey instanceof CLASS_TYPE && KEY_EQUALS(key, CLASS_TO_KEY(otherKey)) && VALUE_EQUALS(value, otherValue);
+#else
+				return otherKey instanceof CLASS_TYPE && otherValue instanceof CLASS_VALUE_TYPE && KEY_EQUALS(key, CLASS_TO_KEY(otherKey)) && VALUE_EQUALS(value, CLASS_TO_VALUE(otherValue));
+#endif
+			}
+			return false;
+		}
+		
+		@Override
+		public int hashCode() {
+			return KEY_TO_HASH(key) ^ VALUE_TO_HASH(value);
+		}
+		
+		@Override
+		public String toString() {
+			return KEY_TO_STRING(key) + "=" + VALUE_TO_STRING(value);
+		}
+		
 		boolean isBlack() {
 			return (state & BLACK) != 0;
 		}

src/builder/resources/speiger/assets/collections/templates/maps/interfaces/NavigableMap.template

@@ -2,6 +2,7 @@ package speiger.src.collections.PACKAGE.maps.interfaces;
 
 import java.util.NavigableMap;
 import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 
 /**
  * A Type Specific Navigable Map interface with a couple helper methods
@@ -34,6 +35,28 @@ public interface NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE extends SORTED_MAP KEY_VAL
 	@Override
 	public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry();
 	
+	/**
+	 * Creates a Wrapped NavigableMap that is Synchronized
+	 * @return a new NavigableMap that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE synchronize() { return MAPS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped NavigableMap that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new NavigableMap Wrapper that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE synchronize(Object mutex) { return MAPS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped NavigableMap that is unmodifiable
+	 * @return a new NavigableMap Wrapper that is unmodifiable
+	 * @see MAPS#unmodifiable
+	 */
+	public default NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type Specific SubMap method to reduce boxing/unboxing

src/builder/resources/speiger/assets/collections/templates/maps/interfaces/SortedMap.template

@@ -10,6 +10,7 @@ import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 
@@ -83,6 +84,28 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	@Override
 	public VALUE_COLLECTION VALUE_GENERIC_TYPE values();
 	
+	/**
+	 * Creates a Wrapped SortedMap that is Synchronized
+	 * @return a new SortedMap that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE synchronize() { return MAPS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped SortedMap that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new SortedMap Wrapper that is synchronized
+	 * @see MAPS#synchronize
+	 */
+	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE synchronize(Object mutex) { return MAPS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped SortedMap that is unmodifiable
+	 * @return a new SortedMap Wrapper that is unmodifiable
+	 * @see MAPS#unmodifiable
+	 */
+	public default SORTED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
+	
 #if !TYPE_OBJECT
 	/**
 	 * A Type Specific SubMap method to reduce boxing/unboxing

src/builder/resources/speiger/assets/collections/templates/queues/ArrayFIFOQueue.template

@@ -4,6 +4,7 @@ import java.util.Arrays;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
 import java.util.NoSuchElementException;
@@ -15,6 +16,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.utils.ITrimmable;
 
 /**
@@ -299,6 +301,45 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0,m=size();i<m;i++) {
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0,m=size();i<m;i++) {
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0,m=size();i<m;i++) {
+			if(empty) {
+				empty = false;
+				state = array[(first + i) % array.length];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/queues/ArrayPriorityQueue.template

@@ -5,6 +5,7 @@ import java.util.NoSuchElementException;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
 
@@ -16,6 +17,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 
 /**
@@ -294,6 +296,45 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0;i<size;i++) {
+			if(empty) {
+				empty = false;
+				state = array[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/queues/HeapPriorityQueue.template

@@ -5,6 +5,7 @@ import java.util.NoSuchElementException;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
 
@@ -16,6 +17,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 
 /**
@@ -281,6 +283,45 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0;i<size;i++) {
+			if(empty) {
+				empty = false;
+				state = array[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, array[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/queues/PriorityDequeue.template

@@ -6,6 +6,7 @@ import java.util.Iterator;
 #endif
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
 
 /**
  * A Type Speciifc PriorityDeque or Dequeue interface to allow implementations like FIFO queues.
@@ -80,6 +81,21 @@ public interface PRIORITY_DEQUEUE KEY_GENERIC_TYPE extends PRIORITY_QUEUE KEY_GE
 	 */
 	public default KEY_TYPE last() { return peek(size()-1); }
 	
+	/**
+	 * Creates a Wrapped PriorityDequeue that is Synchronized
+	 * @return a new PriorityDequeue that is synchronized
+	 * @see PRIORITY_QUEUES#synchronize
+	 */
+	public default PRIORITY_DEQUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped PriorityDequeue that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new PriorityDequeue Wrapper that is synchronized
+	 * @see PRIORITY_QUEUES#synchronize
+	 */
+	public default PRIORITY_DEQUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
+	
 	@Override
 	public PRIORITY_DEQUEUE KEY_GENERIC_TYPE copy();
 }

src/builder/resources/speiger/assets/collections/templates/queues/PriorityQueue.template

@@ -4,12 +4,16 @@ package speiger.src.collections.PACKAGE.queues;
 import java.util.Comparator;
 import java.util.Collection;
 import java.util.Iterator;
+
+import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
 #else
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERABLE;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
+
 
 /**
  * A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
@@ -144,6 +148,22 @@ public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TY
 	 */
 	public ITERATOR KEY_GENERIC_TYPE iterator();
 #endif
+	
+	/**
+	 * Creates a Wrapped PriorityQueue that is Synchronized
+	 * @return a new PriorityQueue that is synchronized
+	 * @see PRIORITY_QUEUES#synchronize
+	 */
+	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped PriorityQueue that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new PriorityQueue Wrapper that is synchronized
+	 * @see PRIORITY_QUEUES#synchronize
+	 */
+	public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
+	
 	/**
 	 * A method to drop the contents of the Queue without clearing the queue
 	 * @Type(E)
@@ -158,4 +178,15 @@ public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TY
 	 * @note if the Type is generic then a Object Array is created instead of a Type Array
 	 */
 	public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
+#if TYPE_OBJECT
+	/**
+	 * A Helper function that simplifies the process of creating a new Array.
+	 * @param action the array creation function
+	 * @return an array containing all of the elements in this collection
+	 * @see Collection#toArray(Object[])
+	 */
+	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+		return TO_ARRAY(action.get(size()));
+	}
+#endif
 }

src/builder/resources/speiger/assets/collections/templates/sets/AVLTreeSet.template

@@ -4,6 +4,7 @@ import java.util.Collection;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -15,6 +16,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
@@ -211,6 +213,9 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 #endif
 	@Override
 	public boolean add(KEY_TYPE o) {
+#if TYPE_OBJECT
+		validate(o);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryBRACES(o, null);
 			size++;
@@ -240,7 +245,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		}
 		fixAfterInsertion(adding);
 		size++;
-		return false;
+		return true;
 	}
 	
 	@Override
@@ -346,6 +351,45 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			if(empty) {
+				empty = false;
+				state = entry.key;
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -611,6 +655,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		}
 	}
 	
+	protected void validate(KEY_TYPE k) { compare(k, k); }
 	protected int compare(KEY_TYPE k, KEY_TYPE v) { return comparator != null ? comparator.compare(k, v) : COMPAREABLE_TO_KEY(k, v);}
 	
 	/** From CLR */
@@ -1069,6 +1114,45 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				if(empty) {
+					empty = false;
+					state = entry.key;
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template

@@ -1,7 +1,8 @@
 package speiger.src.collections.PACKAGE.sets;
 
-import java.util.Iterator;
+#if TYPE_OBJECT
 import java.util.Objects;
+#endif
 import java.util.Set;
 
 import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
@@ -20,10 +21,10 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	
 	@Override
 	public int hashCode() {
-		int hashCode = 1;
+		int hashCode = 0;
 		ITERATOR KEY_GENERIC_TYPE i = iterator();
 		while(i.hasNext())
-			hashCode = 31 * hashCode + KEY_TO_HASH(i.NEXT());
+			hashCode += KEY_TO_HASH(i.NEXT());
 		return hashCode;
 	}
 	
@@ -35,24 +36,10 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			return false;
 		Set<?> l = (Set<?>)o;
 		if(l.size() != size()) return false;
-#if !TYPE_OBJECT		
-		if(l instanceof SET)
-		{
-			ITERATOR e1 = iterator();
-			ITERATOR e2 = ((SET)l).iterator();
-			while (e1.hasNext() && e2.hasNext()) {
-				if(!(KEY_EQUALS(e1.NEXT(), e2.NEXT())))
-					return false;
-			}
-			return !(e1.hasNext() || e2.hasNext());
+		try {
+			return containsAll(l);
+		} catch (ClassCastException | NullPointerException unused) {
+			return false;
 		}
-#endif
-		Iterator<CLASS_TYPE> e1 = iterator();
-		Iterator<?> e2 = l.iterator();
-		while (e1.hasNext() && e2.hasNext()) {
-			if(!Objects.equals(e1.next(), e2.next()))
-				return false;
-		}
-		return !(e1.hasNext() || e2.hasNext());
 	}
 }

src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template

@@ -5,6 +5,7 @@ import java.util.Collection;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -18,6 +19,7 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -72,8 +74,8 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	 * @throws NegativeArraySizeException if the length is negative
 	 */
 	public ARRAY_SET(KEY_TYPE[] array, int length) {
-		data = Arrays.copyOf(array, length);
-		size = length;
+		this(length);
+		addAll(array, length);
 	}
 	
 	/**
@@ -227,6 +229,21 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return result;
 	}
 	
+	@Override
+	public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		int j = 0;
+		for(int i = 0;i<size;i++) {
+			if(!c.contains(data[i])) data[j++] = data[i];
+			else r.accept(data[i]);
+		}
+		boolean result = j != size;
+#if TYPE_OBJECT
+		Arrays.fill(data, j, size, null);
+#endif
+		size = j;
+		return result;
+	}
+	
 	@Override
 	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
 		int j = 0;
@@ -242,6 +259,21 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return result;
 	}
 	
+	@Override
+	public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
+		int j = 0;
+		for(int i = 0;i<size;i++) {
+			if(c.contains(data[i])) data[j++] = data[i];
+			else r.accept(data[i]);
+		}
+		boolean result = j != size;
+#if TYPE_OBJECT
+		Arrays.fill(data, j, size, null);
+#endif
+		size = j;
+		return result;
+	}
+	
 	@Override
 	@Primitive
 	public boolean removeAll(Collection<?> c) {
@@ -392,6 +424,45 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return EMPTY_VALUE;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(int i = 0;i<size;i++) {
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(int i = 0;i<size;i++) {
+			if(empty) {
+				empty = false;
+				state = data[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, data[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public int count(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -477,6 +548,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
 		if(a == null || a.length < size()) return Arrays.copyOf(data, size());
 		System.arraycopy(data, 0, a, 0, size());
+		if (a.length > size) a[size] = EMPTY_KEY_VALUE;
 		return a;
 	}
 	
@@ -497,6 +569,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		else if(a.length < size()) a = (E[])ObjectArrays.newArray(a.getClass().getComponentType(), size());
 		for(int i = 0;i<size();i++)
 			a[i] = (E)KEY_TO_OBJ(data[i]);
+		if (a.length > size) a[size] = null;
 		return a;
 	}
 	
@@ -770,6 +843,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			
 			@Override
 			public KEY_TYPE NEXT() {
+				if(!hasNext()) throw new NoSuchElementException();
 				lastReturned = index;
 				return data[index++];
 			}
@@ -781,6 +855,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			
 			@Override
 			public KEY_TYPE PREVIOUS() {
+				if(!hasPrevious()) throw new NoSuchElementException();
 				lastReturned = index;
 				return data[index--];
 			}
@@ -853,6 +928,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		
 		@Override
 		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
 			lastReturned = index;
 			return data[index++];
 		}
@@ -864,6 +940,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		
 		@Override
 		public KEY_TYPE PREVIOUS() {
+			if(!hasPrevious()) throw new NoSuchElementException();
 			lastReturned = index;
 			return data[index--];
 		}
@@ -880,11 +957,9 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		
 		@Override
 		public void remove() {
-			if(lastReturned == -1)
-				throw new IllegalStateException();
+			if(lastReturned == -1) throw new IllegalStateException();
 			ARRAY_SET.this.remove(data[lastReturned]);
-			if(lastReturned < index)
-				index--;
+			if(lastReturned < index) index--;
 			lastReturned = -1;
 		}
 		

src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template

@@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.sets;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Arrays;
 import java.util.Collection;
@@ -19,6 +20,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -188,7 +190,18 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		{
 			KEY_TYPE o = a[i];
 			if(KEY_EQUALS_NULL(o)) {
-				if(!containsNull) size++;
+				if(!containsNull) {
+					size++;
+					if(prev != -1) {
+						newLinks[prev] ^= ((newLinks[prev] ^ (newSize & 0xFFFFFFFFL)) & 0xFFFFFFFFL);
+						newLinks[newSize] ^= ((newLinks[newSize] ^ ((prev & 0xFFFFFFFFL) << 32)) & 0xFFFFFFFF00000000L);
+						prev = newSize;
+					}
+					else {
+						prev = firstIndex = newSize;
+						newLinks[newSize] = -1L;
+					}
+				}
 				containsNull = true;
 				continue;
 			}
@@ -197,7 +210,7 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 			KEY_TYPE current = newKeys[pos];
 			if(KEY_EQUALS_NOT_NULL(current)) {
 				if(KEY_EQUALS(current, o)) continue;
-				while(KEY_EQUALS_NOT_NULL((current = newKeys[pos = (++pos & mask)]))) {
+				while(KEY_EQUALS_NOT_NULL((current = newKeys[pos = (++pos & newMask)]))) {
 					if(KEY_EQUALS(current, o)) {
 						found = false;
 						break;
@@ -218,7 +231,7 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 				}
 			}
 		}
-		nullIndex = size;
+		nullIndex = newSize;
 		mask = newMask;
 		keys = newKeys;
 		links = newLinks;
@@ -346,6 +359,50 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		int index = firstIndex;
+		while(index != -1) {
+			if(empty) {
+				state = keys[index];
+				empty = false;
+			}
+			else state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template

@@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.sets;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Arrays;
 import java.util.Objects;
@@ -25,6 +26,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.utils.HashUtil;
 import speiger.src.collections.utils.SanityChecks;
@@ -577,6 +579,50 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		int index = firstIndex;
+		while(index != -1) {
+			if(empty) {
+				state = keys[index];
+				empty = false;
+			}
+			else state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template

@@ -10,6 +10,7 @@ import java.util.NoSuchElementException;
 import java.util.Objects;
 #if TYPE_OBJECT
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
@@ -23,6 +24,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -432,6 +434,50 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		int index = firstIndex;
+		while(index != -1) {
+			state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		int index = firstIndex;
+		while(index != -1) {
+			if(empty) {
+				state = keys[index];
+				empty = false;
+			}
+			else state = operator.APPLY_VALUE(state, keys[index]);
+			index = (int)links[index];
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template

@@ -4,6 +4,7 @@ import java.util.NavigableSet;
 
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+import speiger.src.collections.PACKAGE.utils.SETS;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 
 /**
@@ -118,6 +119,30 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet<CLASS_TYPE>
 	@Override
 	public NAVIGABLE_SET KEY_GENERIC_TYPE copy();
 	
+#if !TYPE_BOOLEAN
+	/**
+	 * Creates a Wrapped NavigableSet that is Synchronized
+	 * @return a new NavigableSet that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default NAVIGABLE_SET KEY_GENERIC_TYPE synchronize() { return SETS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped NavigableSet that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new NavigableSet Wrapper that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default NAVIGABLE_SET KEY_GENERIC_TYPE synchronize(Object mutex) { return SETS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped NavigableSet that is unmodifiable
+	 * @return a new NavigableSet Wrapper that is unmodifiable
+	 * @see SETS#unmodifiable
+	 */
+	public default NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
+	
+#endif
 	/**
 	 * A Type Specific Type Splititerator to reduce boxing/unboxing
 	 * @return type specific splititerator

src/builder/resources/speiger/assets/collections/templates/sets/OpenCustomHashSet.template

@@ -8,6 +8,7 @@ import java.util.NoSuchElementException;
 import java.util.Objects;
 #if TYPE_OBJECT
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
@@ -20,6 +21,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 
 import speiger.src.collections.utils.HashUtil;
@@ -527,6 +529,54 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		if(containsNull) state = operator.APPLY_VALUE(state, keys[nullIndex]);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		if(containsNull) state = operator.APPLY_VALUE(state, keys[nullIndex]);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		if(containsNull) {
+			state = keys[nullIndex];
+			empty = false;
+		}
+		for(int i = 0;i<size;i++) {
+			if(strategy.equals(keys[i], EMPTY_KEY_VALUE)) continue;
+			if(empty) {
+				empty = false;
+				state = keys[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -552,6 +602,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 	
 	private class SetIterator implements ITERATOR KEY_GENERIC_TYPE {
 		int pos = nullIndex;
+		int returnedPos = -1;
 		int lastReturned = -1;
 		int nextIndex = Integer.MIN_VALUE;
 		boolean returnNull = containsNull;
@@ -584,6 +635,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
+			returnedPos = pos;
 			if(nextIndex < 0){
 				lastReturned = Integer.MAX_VALUE;
 				KEY_TYPE value = wrapped.GET_KEY(nextIndex);
@@ -602,9 +654,10 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 				containsNull = false;
 				keys[nullIndex] = EMPTY_KEY_VALUE;
 			}
-			else if(pos >= 0) shiftKeys(pos);
+			else if(returnedPos >= 0) shiftKeys(returnedPos);
 			else {
-				CUSTOM_HASH_SET.this.remove(wrapped.GET_KEY(-pos - 1));
+				CUSTOM_HASH_SET.this.remove(wrapped.GET_KEY(-returnedPos - 1));
+				lastReturned = -1;
 				return;
 			}
 			size--;

src/builder/resources/speiger/assets/collections/templates/sets/OpenHashSet.template

@@ -8,6 +8,7 @@ import java.util.NoSuchElementException;
 import java.util.Objects;
 #if TYPE_OBJECT
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
@@ -20,6 +21,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.utils.HashUtil;
 import speiger.src.collections.utils.ITrimmable;
 import speiger.src.collections.utils.SanityChecks;
@@ -380,6 +382,54 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		if(containsNull) state = operator.APPLY_VALUE(state, keys[nullIndex]);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(KEY_EQUALS_NULL(keys[i])) continue;
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		if(containsNull) state = operator.APPLY_VALUE(state, keys[nullIndex]);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(KEY_EQUALS_NULL(keys[i])) continue;
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		if(containsNull) {
+			state = keys[nullIndex];
+			empty = false;
+		}
+		for(int i = 0;i<size;i++) {
+			if(KEY_EQUALS_NULL(keys[i])) continue;
+			if(empty) {
+				empty = false;
+				state = keys[i];
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, keys[i]);
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -509,6 +559,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 	
 	private class SetIterator implements ITERATOR KEY_GENERIC_TYPE {
 		int pos = nullIndex;
+		int returnedPos = -1;
 		int lastReturned = -1;
 		int nextIndex = Integer.MIN_VALUE;
 		boolean returnNull = containsNull;
@@ -542,6 +593,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		@Override
 		public KEY_TYPE NEXT() {
 			if(!hasNext()) throw new NoSuchElementException();
+			returnedPos = pos;
 			if(nextIndex < 0){
 				lastReturned = Integer.MAX_VALUE;
 				KEY_TYPE value = wrapped.GET_KEY(nextIndex);
@@ -560,9 +612,10 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 				containsNull = false;
 				keys[nullIndex] = EMPTY_KEY_VALUE;
 			}
-			else if(pos >= 0) shiftKeys(pos);
+			else if(returnedPos >= 0) shiftKeys(returnedPos);
 			else {
-				HASH_SET.this.remove(wrapped.GET_KEY(-pos - 1));
+				HASH_SET.this.remove(wrapped.GET_KEY(-returnedPos - 1));
+				lastReturned = -1;
 				return;
 			}
 			size--;

src/builder/resources/speiger/assets/collections/templates/sets/RBTreeSet.template

@@ -4,6 +4,7 @@ import java.util.Collection;
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -15,6 +16,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
@@ -211,6 +213,9 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 #endif
 	@Override
 	public boolean add(KEY_TYPE o) {
+#if TYPE_OBJECT
+		validate(o);
+#endif
 		if(tree == null) {
 			tree = first = last = new EntryBRACES(o, null);
 			size++;
@@ -240,7 +245,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		}
 		fixAfterInsertion(adding);
 		size++;
-		return false;
+		return true;
 	}
 	
 	@Override
@@ -337,6 +342,45 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		return true;
 	}
 	
+#if !TYPE_OBJECT
+	@Override
+	public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
+#else
+	@Override
+	public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+		Objects.requireNonNull(operator);
+		KEY_SPECIAL_TYPE state = identity;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
+#endif
+	@Override
+	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		Objects.requireNonNull(operator);
+		KEY_TYPE state = EMPTY_VALUE;
+		boolean empty = true;
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
+			if(empty) {
+				empty = false;
+				state = entry.key;
+				continue;
+			}
+			state = operator.APPLY_VALUE(state, entry.key);
+		}
+		return state;
+	}
+	
 	@Override
 	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -619,6 +663,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		}
 	}
 	
+	protected void validate(KEY_TYPE k) { compare(k, k); }
 	protected int compare(KEY_TYPE k, KEY_TYPE v) { return comparator != null ? comparator.compare(k, v) : COMPAREABLE_TO_KEY(k, v);}
 	protected static GENERIC_KEY_BRACES boolean isBlack(Entry KEY_GENERIC_TYPE p) { return p == null || p.isBlack(); }
 	protected static GENERIC_KEY_BRACES Entry KEY_GENERIC_TYPE parentOf(Entry KEY_GENERIC_TYPE p) { return (p == null ? null : p.parent); }
@@ -1130,6 +1175,45 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return true;
 		}
 		
+#if !TYPE_OBJECT
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = identity;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
+#else
+		@Override
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
+			Objects.requireNonNull(operator);
+			KEY_SPECIAL_TYPE state = identity;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
+#endif
+		@Override
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+			Objects.requireNonNull(operator);
+			KEY_TYPE state = EMPTY_VALUE;
+			boolean empty = true;
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
+				if(empty) {
+					empty = false;
+					state = entry.key;
+					continue;
+				}
+				state = operator.APPLY_VALUE(state, entry.key);
+			}
+			return state;
+		}
+		
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);

src/builder/resources/speiger/assets/collections/templates/sets/Set.template

@@ -5,8 +5,12 @@ import java.util.Set;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.utils.SETS;
+#endif
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 
+
 /**
  * A Type Specific Set class to reduce boxing/unboxing
  * @Type(T)
@@ -49,6 +53,31 @@ public interface SET KEY_GENERIC_TYPE extends Set<CLASS_TYPE>, COLLECTION KEY_GE
 	public default boolean remove(Object o) {
 		return COLLECTION.super.remove(o);
 	}
+	
+#endif
+#if !TYPE_BOOLEAN
+	/**
+	 * Creates a Wrapped Set that is Synchronized
+	 * @return a new Set that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default SET KEY_GENERIC_TYPE synchronize() { return SETS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped Set that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new Set Wrapper that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default SET KEY_GENERIC_TYPE synchronize(Object mutex) { return SETS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped Set that is unmodifiable
+	 * @return a new Set Wrapper that is unmodifiable
+	 * @see SETS#unmodifiable
+	 */
+	public default SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
+	
 #endif
 	/**
 	 * A Type Specific Type Splititerator to reduce boxing/unboxing

src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template

@@ -9,6 +9,7 @@ import java.util.Comparator;
 #else
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
+import speiger.src.collections.PACKAGE.utils.SETS;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 
 /**
@@ -73,6 +74,30 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
 	 */
 	public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement);
 	
+#if !TYPE_BOOLEAN
+	/**
+	 * Creates a Wrapped SortedSet that is Synchronized
+	 * @return a new SortedSet that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default SORTED_SET KEY_GENERIC_TYPE synchronize() { return SETS.synchronize(this); }
+	
+	/**
+	 * Creates a Wrapped SortedSet that is Synchronized
+	 * @param mutex is the controller of the synchronization block
+	 * @return a new SortedSet Wrapper that is synchronized
+	 * @see SETS#synchronize
+	 */
+	public default SORTED_SET KEY_GENERIC_TYPE synchronize(Object mutex) { return SETS.synchronize(this, mutex); }
+	
+	/**
+	 * Creates a Wrapped SortedSet that is unmodifiable
+	 * @return a new SortedSet Wrapper that is unmodifiable
+	 * @see SETS#unmodifiable
+	 */
+	public default SORTED_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
+	
+#endif
 	/**
 	 * A Type Specific Type Splititerator to reduce boxing/unboxing
 	 * @return type specific splititerator

src/builder/resources/speiger/assets/collections/templates/utils/Collections.template

@@ -1,6 +1,9 @@
 package speiger.src.collections.PACKAGE.utils;
 
 import java.util.Collection;
+#if TYPE_OBJECT
+import java.util.function.BiFunction;
+#endif
 import java.util.function.Predicate;
 #if PRIMITIVES
 import java.util.function.JAVA_PREDICATE;
@@ -16,6 +19,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 /**
  * A Helper class for Collections
@@ -130,7 +134,7 @@ public class COLLECTIONS
 		}
 		
 		@Override
-		public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public COLLECTION KEY_GENERIC_TYPE copy() { synchronized(mutex) { return c.copy(); } }
 		
 		@Override
 		@Primitive
@@ -148,7 +152,11 @@ public class COLLECTIONS
 		@Override
 		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) { synchronized(mutex) { return this.c.removeAll(c); } }
 		@Override
+		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { synchronized(mutex) { return this.c.removeAll(c, r); } }
+		@Override
 		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) { synchronized(mutex) { return this.c.retainAll(c); } }
+		@Override
+		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { synchronized(mutex) { return this.c.retainAll(c, r); } }
 #if PRIMITIVES
 		@Override
 		public boolean remIf(JAVA_PREDICATE filter){ synchronized(mutex) { return c.remIf(filter); } }
@@ -189,6 +197,14 @@ public class COLLECTIONS
 		public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.matchesNone(filter); } }
 		@Override
 		public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.matchesAll(filter); } }
+#if TYPE_OBJECT
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) { synchronized(mutex) { return c.reduce(identity, operator); } }
+#else
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return c.reduce(identity, operator); } }
+#endif
+		@Override
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return c.reduce(operator); } }
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.findFirst(filter); } }
 		@Override
@@ -238,7 +254,7 @@ public class COLLECTIONS
 		@Override
 		public ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(c.iterator()); }
 		@Override
-		public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public COLLECTION KEY_GENERIC_TYPE copy() { return c.copy(); }
 		@Override
 		@Deprecated
 		public boolean remove(Object o) { throw new UnsupportedOperationException(); }
@@ -258,7 +274,11 @@ public class COLLECTIONS
 		@Override
 		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
 		@Override
+		public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { throw new UnsupportedOperationException(); }
+		@Override
 		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
+		@Override
+		public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) { throw new UnsupportedOperationException(); }
 #if PRIMITIVES
 		@Override
 		public boolean remIf(JAVA_PREDICATE filter){ throw new UnsupportedOperationException(); }
@@ -299,6 +319,14 @@ public class COLLECTIONS
 		public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) { return c.matchesNone(filter); }
 		@Override
 		public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) { return c.matchesAll(filter); }
+#if TYPE_OBJECT
+		public <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) { return c.reduce(identity, operator); }
+#else
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { return c.reduce(identity, operator); }
+#endif
+		@Override
+		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { return c.reduce(operator); }
 		@Override
 		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { return c.findFirst(filter); }
 		@Override

src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template

@@ -1,13 +1,25 @@
 package speiger.src.collections.PACKAGE.utils;
 
+import java.util.Objects;
+#if TYPE_BOOLEAN
+import java.util.concurrent.atomic.AtomicInteger;
+#endif
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+
 import speiger.src.collections.PACKAGE.collections.ITERABLE;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.collections.ObjectIterable;
 import speiger.src.collections.objects.collections.ObjectIterator;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
+import speiger.src.collections.PACKAGE.sets.SET;
+#endif
 
 /**
  * A Helper class for Iterables
@@ -110,6 +122,70 @@ public class ITERABLES
 		return new FilteredIterableBRACES(iterable, filter);
 	}
 	
+	/**
+	 * A Helper function that filters out all duplicated elements.
+	 * @param iterable that should be distinct
+	 * @Type(T)
+	 * @return a distinct iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE distinct(ITERABLE KEY_GENERIC_TYPE iterable) {
+		return new DistinctIterableBRACES(iterable);
+	}
+	
+	/**
+	 * A Helper function that filters out all duplicated elements from a Java Iterable.
+	 * @param iterable that should be distinct
+	 * @Type(T)
+	 * @return a distinct iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE distinct(Iterable<? extends CLASS_TYPE> iterable) {
+		return new DistinctIterableBRACES(wrap(iterable));
+	}
+	
+	/**
+	 * A Helper function that hard limits the Iterable to a specific size
+	 * @param iterable that should be limited
+	 * @param limit the amount of elements it should be limited to
+	 * @Type(T)
+	 * @return a limited iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE limit(ITERABLE KEY_GENERIC_TYPE iterable, long limit) {
+		return new LimitedIterableBRACES(iterable, limit);
+	}
+	
+	/**
+	 * A Helper function that hard limits the Iterable to a specific size from a Java Iterable
+	 * @param iterable that should be limited
+	 * @param limit the amount of elements it should be limited to
+	 * @Type(T)
+	 * @return a limited iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE limit(Iterable<? extends CLASS_TYPE> iterable, long limit) {
+		return new LimitedIterableBRACES(wrap(iterable), limit);
+	}
+	
+	/**
+	 * A Helper function that allows to preview the result of a Iterable.
+	 * @param iterable that should be peeked at
+	 * @param action callback that receives the value before the iterable returns it
+	 * @Type(T)
+	 * @return a peeked iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE peek(ITERABLE KEY_GENERIC_TYPE iterable, CONSUMER KEY_GENERIC_TYPE action) {
+		return new PeekIterableBRACES(iterable, action);
+	}
+	
+	/**
+	 * A Helper function that allows to preview the result of a Iterable from a Java Iterable
+	 * @param iterable that should be peeked at
+	 * @param action callback that receives the value before the iterable returns it
+	 * @Type(T)
+	 * @return a peeked iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE peek(Iterable<? extends CLASS_TYPE> iterable, CONSUMER KEY_GENERIC_TYPE action) {
+		return new PeekIterableBRACES(wrap(iterable), action);
+	}
+	
 	/**
 	 * A Wrapper function that wraps a Java-Iterable into a Type Specific Iterable
 	 * @param iterable that should be wrapped
@@ -131,6 +207,19 @@ public class ITERABLES
 		public ITERATOR KEY_GENERIC_TYPE iterator() {
 			return ITERATORS.wrap(iterable.iterator());
 		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(action);
+		}
+#else
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(action);
+		}
+#endif
 	}
 	
 	private static class MappedIterable KSS_GENERIC_TYPE<E, T> implements ObjectIterable<T>
@@ -146,6 +235,12 @@ public class ITERABLES
 		public ObjectIterator<T> iterator() {
 			return ITERATORS.map(iterable.iterator(), mapper);
 		}
+		
+		@Override
+		public void forEach(Consumer<? super T> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(E -> action.accept(mapper.GET_VALUE(E)));
+		}
 	}
 	
 	private static class FlatMappedIterable KSS_GENERIC_TYPE<E, T,[SPACE]V extends Iterable<T>> implements ObjectIterable<T>
@@ -162,6 +257,13 @@ public class ITERABLES
 		public ObjectIterator<T> iterator() {
 			return ITERATORS.flatMap(iterable.iterator(), mapper);
 		}
+		
+		@Override
+		public void forEach(Consumer<? super T> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(E -> mapper.GET_VALUE(E).forEach(action));
+		}
+		
 	}
 	
 	private static class FlatMappedArrayIterable KSS_GENERIC_TYPE<E, T> implements ObjectIterable<T>
@@ -178,6 +280,15 @@ public class ITERABLES
 		public ObjectIterator<T> iterator() {
 			return ITERATORS.arrayFlatMap(iterable.iterator(), mapper);
 		}
+		
+		@Override
+		public void forEach(Consumer<? super T> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(E -> {
+				T[] array = mapper.GET_VALUE(E);
+				for(int i = 0,m=array.length;i<m;action.accept(array[i++]));
+			});
+		}
 	}
 	
 	private static class FilteredIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
@@ -194,5 +305,124 @@ public class ITERABLES
 		public ITERATOR KEY_GENERIC_TYPE iterator() {
 			return ITERATORS.filter(iterable.iterator(), filter);
 		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(T -> { if(!filter.TEST_VALUE(T)) action.accept(T); } );
+		}
+#else
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(T -> { if(!filter.TEST_VALUE(T)) action.accept(T); } );
+		}
+#endif
+	}
+	
+	private static class LimitedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		long limit;
+		
+		public LimitedIterable(ITERABLE KEY_GENERIC_TYPE iterable, long limit) {
+			this.iterable = iterable;
+			this.limit = limit;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.limit(iterable.iterator(), limit);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			AtomicLong counter = new AtomicLong();
+			iterable.forEach(T -> {
+				if(counter.get() >= limit) return;
+				counter.incrementAndGet();
+				action.accept(T);
+			});
+		}
+#else
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			AtomicLong counter = new AtomicLong();
+			iterable.forEach(T -> {
+				if(counter.get() >= limit) return;
+				counter.incrementAndGet();
+				action.accept(T);
+			});
+		}
+#endif
+	}
+	
+	private static class DistinctIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		
+		public DistinctIterable(ITERABLE KEY_GENERIC_TYPE iterable) {
+			this.iterable = iterable;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.distinct(iterable.iterator());
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+#if TYPE_BOOLEAN
+			AtomicInteger result = new AtomicInteger();
+			iterable.forEach(T -> {
+				if(((result.get() & (T ? 2 : 1)) != 0)) return;
+				result.getAndAdd(T ? 2 : 1);
+				action.accept(T);
+			});
+#else
+			SET KEY_GENERIC_TYPE filtered = new HASH_SETBRACES();
+			iterable.forEach(T -> { if(filtered.add(T)) action.accept(T); });
+#endif
+		}
+#else
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			SET KEY_GENERIC_TYPE filtered = new HASH_SETBRACES();
+			iterable.forEach(T -> { if(filtered.add(T)) action.accept(T); });
+		}
+#endif
+	}
+	
+	private static class PeekIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		CONSUMER KEY_GENERIC_TYPE action;
+		
+		public PeekIterable(ITERABLE KEY_GENERIC_TYPE iterable, CONSUMER KEY_GENERIC_TYPE action) {
+			this.iterable = iterable;
+			this.action = action;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.peek(iterable.iterator(), action);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(this.action.andThen(action));
+		}
+#else
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			iterable.forEach(this.action.andThen(action));
+		}
+#endif
 	}
 }

src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template

@@ -2,11 +2,15 @@ package speiger.src.collections.PACKAGE.utils;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+#if TYPE_OBJECT
+import java.util.function.CONSUMER;
+#endif
 
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.objects.utils.ObjectIterators;
+import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
@@ -15,6 +19,10 @@ import speiger.src.collections.PACKAGE.lists.LIST;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
+import speiger.src.collections.PACKAGE.sets.SET;
+#endif
 
 /**
  * A Helper class for Iterators
@@ -185,6 +193,70 @@ public class ITERATORS
 		return new FilteredIteratorBRACES(iterator, filter);
 	}
 	
+	/**
+	 * A Helper function that filters out all duplicated elements.
+	 * @param iterator that should be distinct
+	 * @Type(T)
+	 * @return a distinct iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE distinct(ITERATOR KEY_GENERIC_TYPE iterator) {
+		return new DistinctIteratorBRACES(iterator);
+	}
+	
+	/**
+	 * A Helper function that filters out all duplicated elements from a Java Iterator.
+	 * @param iterator that should be distinct
+	 * @Type(T)
+	 * @return a distinct iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE distinct(Iterator<? extends CLASS_TYPE> iterator) {
+		return new DistinctIteratorBRACES(wrap(iterator));
+	}
+	
+	/**
+	 * A Helper function that hard limits the Iterator to a specific size
+	 * @param iterator that should be limited
+	 * @param limit the amount of elements it should be limited to
+	 * @Type(T)
+	 * @return a limited iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE limit(ITERATOR KEY_GENERIC_TYPE iterator, long limit) {
+		return new LimitedIteratorBRACES(iterator, limit);
+	}
+	
+	/**
+	 * A Helper function that hard limits the Iterator to a specific size from a Java Iterator
+	 * @param iterator that should be limited
+	 * @param limit the amount of elements it should be limited to
+	 * @Type(T)
+	 * @return a limited iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE limit(Iterator<? extends CLASS_TYPE> iterator, long limit) {
+		return new LimitedIteratorBRACES(wrap(iterator), limit);
+	}
+	
+	/**
+	 * A Helper function that allows to preview the result of a Iterator.
+	 * @param iterator that should be peeked at
+	 * @param action callback that receives the value before the iterator returns it
+	 * @Type(T)
+	 * @return a peeked iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE peek(ITERATOR KEY_GENERIC_TYPE iterator, CONSUMER KEY_GENERIC_TYPE action) {
+		return new PeekIteratorBRACES(iterator, action);
+	}
+	
+	/**
+	 * A Helper function that allows to preview the result of a Iterator  from a Java Iterator
+	 * @param iterator that should be peeked at
+	 * @param action callback that receives the value before the iterator returns it
+	 * @Type(T)
+	 * @return a peeked iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE peek(Iterator<? extends CLASS_TYPE> iterator, CONSUMER KEY_GENERIC_TYPE action) {
+		return new PeekIteratorBRACES(wrap(iterator), action);
+	}
+	
 	/**
 	 * Helper function to convert a Object Iterator into a Primitive Iterator
 	 * @param iterator that should be converted to a unboxing iterator
@@ -799,6 +871,57 @@ public class ITERATORS
 		}
 	}
 	
+	private static class DistinctIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iterator;
+#if TYPE_BOOLEAN
+		int filtered;
+#else
+		SET KEY_GENERIC_TYPE filtered = new HASH_SETBRACES();
+#endif
+		KEY_TYPE lastFound;
+		boolean foundNext = false;
+		
+		public DistinctIterator(ITERATOR KEY_GENERIC_TYPE iterator) {
+			this.iterator = iterator;
+		}
+		
+		void compute() {
+			if(foundNext) return;
+#if TYPE_BOOLEAN
+			if(filtered == 3) return;
+#endif
+			while(iterator.hasNext()) {
+				lastFound = iterator.NEXT();
+#if TYPE_BOOLEAN
+				if((filtered & (lastFound ? 1 : 2)) == 0) {
+					filtered |= (lastFound ? 1 : 2);
+					foundNext = true;
+					break;
+				}
+#else
+				if(filtered.add(lastFound)) {
+					foundNext = true;
+					break;
+				}
+#endif
+			}
+		}
+		
+		@Override
+		public boolean hasNext() {
+			compute();
+			return foundNext;
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			foundNext = false;
+			return lastFound;
+		}
+	}
+	
 	private static class FilteredIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iterator;
@@ -835,4 +958,51 @@ public class ITERATORS
 			return lastFound;
 		}
 	}
+	
+	private static class LimitedIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iterator;
+		long limit;
+		
+		public LimitedIterator(ITERATOR KEY_GENERIC_TYPE iterator, long limit) {
+			this.iterator = iterator;
+			this.limit = limit;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return limit > 0 && iterator.hasNext();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			limit--;
+			return iterator.NEXT();
+		}
+	}
+	
+	private static class PeekIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iterator;
+		CONSUMER KEY_GENERIC_TYPE action;
+		
+		public PeekIterator(ITERATOR KEY_GENERIC_TYPE iterator, CONSUMER KEY_GENERIC_TYPE action) {
+			this.iterator = iterator;
+			this.action = action;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return iterator.hasNext();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			KEY_TYPE result = iterator.NEXT();
+			action.accept(result);
+			return result;
+		}
+	}
 }

src/builder/resources/speiger/assets/collections/templates/utils/Lists.template

@@ -200,6 +200,8 @@ public class LISTS
 		@Override
 		public KEY_TYPE REMOVE(int index) { throw new UnsupportedOperationException(); }
 		@Override
+		public KEY_TYPE swapRemove(int index) { throw new UnsupportedOperationException(); }
+		@Override
 		public void addElements(int from, KEY_TYPE[] a, int offset, int length) { throw new UnsupportedOperationException(); }
 		@Override
 		public KEY_TYPE[] getElements(int from, KEY_TYPE[] a, int offset, int length) {
@@ -331,6 +333,12 @@ public class LISTS
 		@Override
 		public KEY_TYPE REMOVE(int index) { synchronized(mutex) { return l.REMOVE(index); } }
 		
+		@Override
+		public KEY_TYPE swapRemove(int index) { synchronized(mutex) { return l.swapRemove(index); } }
+		
+		@Override
+		public boolean REMOVE_SWAP(KEY_TYPE e) { synchronized(mutex) { return l.REMOVE_SWAP(e); } }
+		
 		@Override
 		@Primitive
 		public int indexOf(Object e) { synchronized(mutex) { return l.indexOf(e); } }
@@ -380,14 +388,14 @@ public class LISTS
 		
 		@Override
 		public LIST KEY_GENERIC_TYPE subList(int from, int to) {
-			return synchronize(l.subList(from, to));
+			return LISTS.synchronize(l.subList(from, to));
 		}
 		
 		@Override
 		public void size(int size) { synchronized(mutex) { l.size(size); } }
 		
 		@Override
-		public LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public LIST KEY_GENERIC_TYPE copy() { synchronized(mutex) { return l.copy(); } }
 	}
 	
 	private static class UnmodifiableRandomList KEY_GENERIC_TYPE extends UnmodifiableList KEY_GENERIC_TYPE implements RandomAccess 
@@ -444,6 +452,12 @@ public class LISTS
 		@Override
 		public KEY_TYPE REMOVE(int index) { throw new UnsupportedOperationException(); }
 		
+		@Override
+		public KEY_TYPE swapRemove(int index) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public boolean REMOVE_SWAP(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
 		@Override
 		@Primitive
 		public int indexOf(Object e) { return l.indexOf(e); }
@@ -496,14 +510,14 @@ public class LISTS
 		
 		@Override
 		public LIST KEY_GENERIC_TYPE subList(int from, int to) {
-			return unmodifiable(l.subList(from, to));
+			return LISTS.unmodifiable(l.subList(from, to));
 		}
 		
 		@Override
 		public void size(int size) { throw new UnsupportedOperationException(); }
 		
 		@Override
-		public LIST KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public LIST KEY_GENERIC_TYPE copy() { return l.copy(); }
 	}
 	
 	private static class EmptyList KEY_GENERIC_TYPE extends COLLECTIONS.EmptyCollection KEY_GENERIC_TYPE implements LIST KEY_GENERIC_TYPE
@@ -537,6 +551,12 @@ public class LISTS
 		@Override
 		public KEY_TYPE REMOVE(int index) { throw new UnsupportedOperationException(); }
 		
+		@Override
+		public KEY_TYPE swapRemove(int index) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public boolean REMOVE_SWAP(KEY_TYPE e) { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public int indexOf(Object e) { return -1; }
 		

src/builder/resources/speiger/assets/collections/templates/utils/PriorityQueues.template

@@ -117,7 +117,7 @@ public class PRIORITY_QUEUES
 		@Override
 		public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input) { synchronized(mutex) { return queue.TO_ARRAY(input); } }
 		@Override
-		public PRIORITY_QUEUE KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public PRIORITY_QUEUE KEY_GENERIC_TYPE copy() { synchronized(mutex) { return queue.copy(); } }
 		@Override
 		public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { synchronized(mutex) { queue.forEach(action); } }
 		@Override
@@ -164,6 +164,6 @@ public class PRIORITY_QUEUES
 		@Override
 		public KEY_TYPE dequeueLast() { synchronized(mutex) { return dequeue.dequeueLast(); } }
 		@Override
-		public PRIORITY_DEQUEUE KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public PRIORITY_DEQUEUE KEY_GENERIC_TYPE copy() { synchronized(mutex) { return dequeue.copy(); } }
 	}
 }

src/builder/resources/speiger/assets/collections/templates/utils/Sets.template

@@ -254,28 +254,28 @@ public class SETS
 		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { return unmodifiable(n.subSet(fromElement, fromInclusive, toElement, toInclusive)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { return SETS.unmodifiable(n.subSet(fromElement, fromInclusive, toElement, toInclusive)); }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { return unmodifiable(n.headSet(toElement, inclusive)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { return SETS.unmodifiable(n.headSet(toElement, inclusive)); }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { return unmodifiable(n.tailSet(fromElement, inclusive)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { return SETS.unmodifiable(n.tailSet(fromElement, inclusive)); }
 
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { return ITERATORS.unmodifiable(n.descendingIterator()); }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { return unmodifiable(n.descendingSet()); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { return SETS.unmodifiable(n.descendingSet()); }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return unmodifiable(n.subSet(fromElement, toElement)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return SETS.unmodifiable(n.subSet(fromElement, toElement)); }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return unmodifiable(n.headSet(toElement)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return SETS.unmodifiable(n.headSet(toElement)); }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return unmodifiable(n.tailSet(fromElement)); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return SETS.unmodifiable(n.tailSet(fromElement)); }
 	}
 	
 	private static class UnmodifiableSortedSet KEY_GENERIC_TYPE extends UnmodifiableSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
@@ -309,16 +309,16 @@ public class SETS
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SORTED_SET KEY_GENERIC_TYPE copy() { return s.copy(); }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return unmodifiable(s.subSet(fromElement, toElement)); }
+		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return SETS.unmodifiable(s.subSet(fromElement, toElement)); }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return unmodifiable(s.headSet(toElement)); }
+		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return SETS.unmodifiable(s.headSet(toElement)); }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return unmodifiable(s.tailSet(fromElement)); }
+		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return SETS.unmodifiable(s.tailSet(fromElement)); }
 		
 		@Override
 		public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); }
@@ -348,7 +348,7 @@ public class SETS
 		}
 		
 		@Override
-		public SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SET KEY_GENERIC_TYPE copy() { return s.copy(); }
 		
 #if !TYPE_OBJECT
 		@Override
@@ -427,31 +427,31 @@ public class SETS
 		
 #endif
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return n.copy(); } }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { synchronized(mutex) { return synchronize(n.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { synchronized(mutex) { return SETS.synchronize(n.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex); } }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { synchronized(mutex) { return synchronize(n.headSet(toElement, inclusive), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { synchronized(mutex) { return SETS.synchronize(n.headSet(toElement, inclusive), mutex); } }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { synchronized(mutex) { return synchronize(n.tailSet(fromElement, inclusive), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { synchronized(mutex) { return SETS.synchronize(n.tailSet(fromElement, inclusive), mutex); } }
 
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { synchronized(mutex) { return n.descendingIterator(); } }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { synchronized(mutex) { return synchronize(n.descendingSet(), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { synchronized(mutex) { return SETS.synchronize(n.descendingSet(), mutex); } }
 		
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronize(n.subSet(fromElement, toElement), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(n.subSet(fromElement, toElement), mutex); } }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronize(n.headSet(toElement), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(n.headSet(toElement), mutex); } }
 
 		@Override
-		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronize(n.tailSet(fromElement), mutex); } }
+		public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return SETS.synchronize(n.tailSet(fromElement), mutex); } }
 	}
 	
 	private static class SynchronizedSortedTrimSet KEY_GENERIC_TYPE extends SynchronizedSortedSet KEY_GENERIC_TYPE implements ITrimmable
@@ -511,16 +511,16 @@ public class SETS
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SORTED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
 		
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronize(s.subSet(fromElement, toElement), mutex); } }
+		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(s.subSet(fromElement, toElement), mutex); } }
 
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronize(s.headSet(toElement), mutex); } }
+		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return SETS.synchronize(s.headSet(toElement), mutex); } }
 
 		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronize(s.tailSet(fromElement), mutex); } }
+		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return SETS.synchronize(s.tailSet(fromElement), mutex); } }
 
 		@Override
 		public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } }
@@ -558,26 +558,20 @@ public class SETS
 	
 	private static class SynchronizedSet KEY_GENERIC_TYPE extends SynchronizedCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
 	{
-#if !TYPE_OBJECT
 		SET KEY_GENERIC_TYPE s;
-#endif
 		
 		SynchronizedSet(SET KEY_GENERIC_TYPE c) {
 			super(c);
-#if !TYPE_OBJECT
 			s = c;
-#endif
 		}
 		
 		SynchronizedSet(SET KEY_GENERIC_TYPE c, Object mutex) {
 			super(c, mutex);
-#if !TYPE_OBJECT
 			s = c;
-#endif
 		}
 		
 		@Override
-		public SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
+		public SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
 		
 #if !TYPE_OBJECT
 		@Override

src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template

@@ -368,31 +368,31 @@ public class MAPS
 		}
 		
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { return synchronize(map.descendingMap()); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { return MAPS.synchronize(map.descendingMap()); }
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE navigableKeySet() { return SETS.unmodifiable(map.navigableKeySet()); }
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE descendingKeySet() { return SETS.unmodifiable(map.descendingKeySet()); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return unmodifiable(map.firstEntry()); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return MAPS.unmodifiable(map.firstEntry()); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return unmodifiable(map.lastEntry()); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return MAPS.unmodifiable(map.lastEntry()); }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { throw new UnsupportedOperationException(); }
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { throw new UnsupportedOperationException(); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) { return unmodifiable(map.subMap(fromKey, fromInclusive, toKey, toInclusive)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) { return MAPS.unmodifiable(map.subMap(fromKey, fromInclusive, toKey, toInclusive)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey, boolean inclusive) { return unmodifiable(map.headMap(toKey, inclusive)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey, boolean inclusive) { return MAPS.unmodifiable(map.headMap(toKey, inclusive)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey, boolean inclusive) { return unmodifiable(map.tailMap(fromKey, inclusive)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey, boolean inclusive) { return MAPS.unmodifiable(map.tailMap(fromKey, inclusive)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { return unmodifiable(map.subMap(fromKey, toKey)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { return MAPS.unmodifiable(map.subMap(fromKey, toKey)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { return unmodifiable(map.headMap(toKey)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { return MAPS.unmodifiable(map.headMap(toKey)); }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { return unmodifiable(map.tailMap(fromKey)); }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { return MAPS.unmodifiable(map.tailMap(fromKey)); }
 #if !TYPE_OBJECT
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE e) { throw new UnsupportedOperationException(); }
@@ -412,13 +412,13 @@ public class MAPS
 		@Override
 		public KEY_TYPE ceilingKey(KEY_TYPE key) { return map.ceilingKey(key); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE lowerEntry(KEY_TYPE key) { return unmodifiable(map.lowerEntry(key)); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE lowerEntry(KEY_TYPE key) { return MAPS.unmodifiable(map.lowerEntry(key)); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE higherEntry(KEY_TYPE key) { return unmodifiable(map.higherEntry(key)); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE higherEntry(KEY_TYPE key) { return MAPS.unmodifiable(map.higherEntry(key)); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(KEY_TYPE key) { return unmodifiable(map.floorEntry(key)); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE floorEntry(KEY_TYPE key) { return MAPS.unmodifiable(map.floorEntry(key)); }
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { return unmodifiable(map.ceilingEntry(key)); }
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE ceilingEntry(KEY_TYPE key) { return MAPS.unmodifiable(map.ceilingEntry(key)); }
 		@Override
 		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 	}
@@ -451,11 +451,11 @@ public class MAPS
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { return unmodifiable(map.subMap(fromKey, toKey)); }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { return MAPS.unmodifiable(map.subMap(fromKey, toKey)); }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { return unmodifiable(map.headMap(toKey)); }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { return MAPS.unmodifiable(map.headMap(toKey)); }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { return unmodifiable(map.tailMap(fromKey)); }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { return MAPS.unmodifiable(map.tailMap(fromKey)); }
 		@Override
 		public KEY_TYPE FIRST_ENTRY_KEY() { return map.FIRST_ENTRY_KEY(); }
 		@Override
@@ -548,7 +548,7 @@ public class MAPS
 		
 		@Override
 		public void forEach(Consumer<? super MAP.Entry KEY_VALUE_GENERIC_TYPE> action) {
-			s.forEach(T -> action.accept(unmodifiable(T)));
+			s.forEach(T -> action.accept(MAPS.unmodifiable(T)));
 		}
 		
 		@Override
@@ -558,7 +558,7 @@ public class MAPS
 				@Override
 				public boolean hasNext() { return iter.hasNext(); }
 				@Override
-				public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { return unmodifiable(iter.next()); }
+				public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { return MAPS.unmodifiable(iter.next()); }
 			};
 		}
 		
@@ -583,7 +583,7 @@ public class MAPS
 		}
 		
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { synchronized(mutex) { return synchronize(map.descendingMap(), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE descendingMap() { synchronized(mutex) { return MAPS.synchronize(map.descendingMap(), mutex); } }
 		@Override
 		public NAVIGABLE_SET KEY_GENERIC_TYPE navigableKeySet() { synchronized(mutex) { return SETS.synchronize(map.navigableKeySet(), mutex); } }
 		@Override
@@ -597,17 +597,17 @@ public class MAPS
 		@Override
 		public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, boolean fromInclusive, KEY_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey, boolean inclusive) { synchronized(mutex) { return synchronize(map.headMap(toKey, inclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey, boolean inclusive) { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey, inclusive), mutex); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey, boolean inclusive) { synchronized(mutex) { return synchronize(map.tailMap(fromKey, inclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey, boolean inclusive) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey, inclusive), mutex); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { synchronized(mutex) { return synchronize(map.subMap(fromKey, toKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, toKey), mutex); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { synchronized(mutex) { return synchronize(map.headMap(toKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey), mutex); } }
 		@Override
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { synchronized(mutex) { return synchronize(map.tailMap(fromKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey), mutex); } }
 		@Override
 		public KEY_TYPE lowerKey(KEY_TYPE key) { synchronized(mutex) { return map.lowerKey(key); } }
 		@Override
@@ -629,22 +629,22 @@ public class MAPS
 		#if !TYPE_OBJECT
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, boolean fromInclusive, CLASS_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, boolean fromInclusive, CLASS_TYPE toKey, boolean toInclusive) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex); } }
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey, boolean inclusive) { synchronized(mutex) { return synchronize(map.headMap(toKey, inclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey, boolean inclusive) { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey, inclusive), mutex); } }
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey, boolean inclusive) { synchronized(mutex) { return synchronize(map.tailMap(fromKey, inclusive), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey, boolean inclusive) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey, inclusive), mutex); } }
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey) { synchronized(mutex) { return synchronize(map.subMap(fromKey, toKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, toKey), mutex); } }
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey) { synchronized(mutex) { return synchronize(map.headMap(toKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey), mutex); } }
 		@Override
 		@Deprecated
-		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { synchronized(mutex) { return synchronize(map.tailMap(fromKey), mutex); } }
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey), mutex); } }
 		@Override
 		public void setDefaultMaxValue(KEY_TYPE e) { synchronized(mutex) { map.setDefaultMaxValue(e); } }
 		@Override
@@ -713,11 +713,11 @@ public class MAPS
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { synchronized(mutex) { return map.comparator(); } }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { synchronized(mutex) { return synchronize(map.subMap(fromKey, toKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, toKey), mutex); } }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey)  { synchronized(mutex) { return synchronize(map.headMap(toKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey)  { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey), mutex); } }
 		@Override
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { synchronized(mutex) { return synchronize(map.tailMap(fromKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey), mutex); } }
 		@Override
 		public KEY_TYPE FIRST_ENTRY_KEY() { synchronized(mutex) { return map.FIRST_ENTRY_KEY(); } }
 		@Override
@@ -741,13 +741,13 @@ public class MAPS
 		public CLASS_TYPE lastKey() { synchronized(mutex) { return map.lastKey(); } }
 		@Override
 		@Deprecated
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey) { synchronized(mutex) { return synchronize(map.subMap(fromKey, toKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(CLASS_TYPE fromKey, CLASS_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.subMap(fromKey, toKey), mutex); } }
 		@Override
 		@Deprecated
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey) { synchronized(mutex) { return synchronize(map.headMap(toKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(CLASS_TYPE toKey) { synchronized(mutex) { return MAPS.synchronize(map.headMap(toKey), mutex); } }
 		@Override
 		@Deprecated
-		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { synchronized(mutex) { return synchronize(map.tailMap(fromKey), mutex); } }
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(CLASS_TYPE fromKey) { synchronized(mutex) { return MAPS.synchronize(map.tailMap(fromKey), mutex); } }
 #endif
 	}
 	

src/main/java/speiger/src/collections/utils/HashUtil.java

@@ -79,6 +79,26 @@ public class HashUtil
 		return x + 1L;
 	}
 	
+	/**
+	 * Function that finds out how many bits are required to store the number Provided
+	 * @param value to get the required bits to store.
+	 * @return the required bits to store that number
+	 * @note Really useful for compression. Reducing data that is inserted into a GZIP algorithm.
+	 */
+	public static int getRequiredBits(int value) {
+		return Integer.bitCount(nextPowerOfTwo(value+1)-1);
+	}
+	
+	/**
+	 * Function that finds out how many bits are required to store the number Provided
+	 * @param value to get the required bits to store.
+	 * @return the required bits to store that number
+	 * @note Really useful for compression. Reducing data that is inserted into a GZIP algorithm.
+	 */
+	public static int getRequiredBits(long value) {
+		return Long.bitCount(nextPowerOfTwo(value+1L)-1L);
+	}
+	
 	/**
 	 * Helper function that creates the ideal array size for HashMap
 	 * @param size the original array size

src/main/java/speiger/src/collections/utils/SanityChecks.java

@@ -72,8 +72,8 @@ public class SanityChecks
 	 * @throws IllegalStateException if offset or accessSize is negative or the range goes out of the array-size
 	 */
 	public static void checkArrayCapacity(int arraySize, int offset, int accessSize) {
-		if(offset < 0) throw new IllegalStateException("Offset is negative ("+offset+")");
-		else if(accessSize < 0) throw new IllegalStateException("Size is negative ("+accessSize+")");
+		if(offset < 0) throw new IndexOutOfBoundsException("Offset is negative ("+offset+")");
+		else if(accessSize < 0) throw new IllegalArgumentException("Size is negative ("+accessSize+")");
 		else if(arraySize < offset + accessSize) throw new IndexOutOfBoundsException("Index (" + (offset + accessSize) + ") is not in size (" + arraySize + ")");
 	}
 	

src/test/java/speiger/src/collections/ints/base/BaseIntCollectionTest.java

@@ -118,6 +118,14 @@ public abstract class BaseIntCollectionTest extends BaseIntIterableTest
 		Assert.assertTrue(collection.removeAll(Arrays.asList(IntArrays.wrap(CONTAINS_ARRAY))));
 	}
 	
+	@Test
+	public void testRemoveAllListener() {
+		if(!getValidCollectionTests().contains(CollectionTest.REMOVE_ALL_LISTENER)) return;
+		IntCollection collection = create(TEST_ARRAY);
+		Assert.assertTrue(collection.removeAll(create(CONTAINS_ARRAY), T -> {}));
+		Assert.assertFalse(collection.removeAll(create(CONTAINS_ARRAY), T -> Assert.assertTrue(false)));
+	}
+	
 	@Test
 	public void testRetainAll() {
 		if(!getValidCollectionTests().contains(CollectionTest.RETAIN_ALL)) return;
@@ -135,6 +143,23 @@ public abstract class BaseIntCollectionTest extends BaseIntIterableTest
 		Assert.assertTrue(collection.isEmpty());
 	}
 	
+	@Test
+	public void testRetainAllListener() {
+		if(!getValidCollectionTests().contains(CollectionTest.RETAIN_ALL_LISTENER)) return;
+		IntCollection collection = create(TEST_ARRAY);
+		IntCollection retained = create(CONTAINS_ARRAY);
+		Assert.assertTrue(collection.retainAll(retained, T -> {}));
+		Assert.assertFalse(collection.retainAll(retained, T -> Assert.assertTrue(false)));
+		Assert.assertEquals(CONTAINS_ARRAY.length, collection.size());
+		int[] retainedArray = retained.toIntArray();
+		int[] collectionArray = collection.toIntArray();
+		IntArrays.stableSort(retainedArray);
+		IntArrays.stableSort(collectionArray);
+		Assert.assertArrayEquals(retainedArray, collectionArray);
+		collection.retainAll(IntCollections.EMPTY, T -> {});
+		Assert.assertTrue(collection.isEmpty());
+	}
+	
 	@Test
 	public void testToArray() {
 		if(!getValidCollectionTests().contains(CollectionTest.TO_ARRAY)) return;

src/test/java/speiger/src/collections/ints/base/BaseIntIterableTest.java

@@ -1,5 +1,6 @@
 package speiger.src.collections.ints.base;
 
+import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.stream.IntStream;
 
@@ -8,6 +9,11 @@ import org.junit.Test;
 
 import speiger.src.collections.ints.collections.IntIterable;
 import speiger.src.collections.ints.collections.IntIterator;
+import speiger.src.collections.ints.lists.IntArrayList;
+import speiger.src.collections.ints.utils.IntArrays;
+import speiger.src.collections.ints.utils.IntIterators;
+import speiger.src.collections.objects.utils.ObjectArrays;
+import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.tests.IterableTest;
 
 @SuppressWarnings("javadoc")
@@ -15,6 +21,7 @@ public abstract class BaseIntIterableTest
 {
 	protected static final int[] EMPTY_ARRAY = new int[0];
 	protected static final int[] TEST_ARRAY = IntStream.range(0, 100).toArray();
+	protected static final int[] DISTINCT_ARRAY = IntStream.range(0, 100).flatMap(T -> Arrays.stream(new int[]{T, T})).toArray();
 	
 	protected abstract IntIterable create(int[] data);
 	
@@ -65,4 +72,103 @@ public abstract class BaseIntIterableTest
 			}
 		}
 	}
+	
+	@Test
+	public void testStreamCount() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_COUNT)) {
+			long expected = IntStream.of(TEST_ARRAY).filter(T -> T % 2 == 0).count();
+			int size = create(TEST_ARRAY).count(T -> T % 2 == 0);
+			Assert.assertEquals(expected, size);
+		}
+	}
+	
+	@Test
+	public void testStreamFilter() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_FILTER)) {
+			int[] expected = IntStream.of(TEST_ARRAY).filter(T -> T % 2 == 0).toArray();
+			int[] actual = IntIterators.pour(create(TEST_ARRAY).filter(T -> T % 2 == 0).iterator()).toIntArray();
+			IntArrays.stableSort(actual);
+			Assert.assertArrayEquals(expected, actual);
+		}
+	}
+	
+	@Test
+	public void testStreamFindFirst() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_FIND_FIRST)) {
+			int expected = IntStream.of(TEST_ARRAY).filter(T -> T / 50 > 0).findFirst().getAsInt();
+			int actual = create(TEST_ARRAY).findFirst(T -> T / 50 > 0);
+			Assert.assertEquals(expected, actual);
+		}
+	}
+	
+	@Test
+	public void teastStreamDistinct() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_DISTINCT)) {
+			int[] expected = IntStream.of(DISTINCT_ARRAY).distinct().toArray();
+			int[] actual = IntIterators.pour(create(DISTINCT_ARRAY).distinct().iterator()).toIntArray();
+			IntArrays.stableSort(actual);
+			Assert.assertArrayEquals(expected, actual);
+		}
+	}
+	
+	@Test
+	public void testStreamLimit() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_LIMIT)) {
+			int[] expected = IntStream.of(TEST_ARRAY).limit(25).toArray();
+			int[] actual = IntIterators.pour(create(TEST_ARRAY).limit(25).iterator()).toIntArray();
+			Assert.assertEquals(expected.length, actual.length);
+		}
+	}
+	
+	@Test
+	public void testStreamMap() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_MAP)) {
+			Integer[] expected = IntStream.of(TEST_ARRAY).mapToObj(Integer::new).toArray(Integer[]::new);
+			Integer[] actual = ObjectIterators.pour(create(TEST_ARRAY).map(Integer::new).iterator()).toArray(Integer[]::new);
+			ObjectArrays.stableSort(actual);
+			Assert.assertArrayEquals(expected, actual);
+		}
+	}
+	
+	@Test
+	public void testStreamMatches() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_MATCHES)) {
+			IntIterable iterable = create(TEST_ARRAY);
+			Assert.assertTrue(iterable.matchesAll(T -> T >= 0));
+			Assert.assertFalse(iterable.matchesAll(T -> T < 0));
+			Assert.assertTrue(iterable.matchesAny(T -> T % 2 != 0));
+			Assert.assertFalse(iterable.matchesAny(T -> T % 2 >= 2));
+			Assert.assertTrue(iterable.matchesNone(T -> T % 2 >= 2));
+			Assert.assertFalse(iterable.matchesNone(T -> T % 2 != 0));
+		}
+	}
+	
+	@Test
+	public void testStreamPeek() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_PEEK)) {
+			int[] peekCount = new int[2];
+			create(TEST_ARRAY).peek(T -> peekCount[0]++).forEach(T -> peekCount[1]++);
+			Assert.assertEquals(TEST_ARRAY.length, peekCount[0]);
+			Assert.assertEquals(TEST_ARRAY.length, peekCount[1]);
+		}
+	}
+	
+	@Test
+	public void testStreamPour() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_POUR)) {
+			int[] expected = TEST_ARRAY;
+			int[] actual = create(TEST_ARRAY).pour(new IntArrayList()).toIntArray();
+			IntArrays.stableSort(actual);
+			Assert.assertArrayEquals(expected, actual);
+		}
+	}
+	
+	@Test
+	public void testStreamReduce() {
+		if(getValidIterableTests().contains(IterableTest.STREAM_REDUCE)) {
+			int expected = IntStream.of(TEST_ARRAY).reduce(0, Integer::sum);
+			int actual = create(TEST_ARRAY).reduce(0, Integer::sum);
+			Assert.assertEquals(expected, actual);
+		}
+	}
 }

src/test/java/speiger/src/collections/ints/base/BaseIntListTest.java

@@ -64,6 +64,16 @@ public abstract class BaseIntListTest extends BaseIntCollectionTest
 		for(int i = 0;i<ADD_ARRAY.length;i++) Assert.assertEquals(ADD_ARRAY[i], list.getInt(i));
 	}
 	
+	@Test
+	public void testSpecialAdd() {
+		if(getValidListTests().contains(ListTest.ADD_SPECIAL)) return;
+		IntList list = create(TEST_ARRAY);
+		Assert.assertFalse(list.addIfAbsent(50));
+		Assert.assertTrue(list.addIfPresent(50));
+		Assert.assertTrue(list.addIfAbsent(150));
+		Assert.assertFalse(list.addIfAbsent(150));
+	}
+	
 	@Test
 	@SuppressWarnings("deprecation")	
 	public void testIndex() {
@@ -173,6 +183,17 @@ public abstract class BaseIntListTest extends BaseIntCollectionTest
 		}
 	}
 	
+	@Test
+	public void testSwapRemove() {
+		if(getValidListTests().contains(ListTest.REMOVE_SWAP)) return;
+		IntList list = create(TEST_ARRAY);
+		Assert.assertEquals(TEST_ARRAY[50], list.swapRemove(50));
+		Assert.assertEquals(TEST_ARRAY[TEST_ARRAY.length-1], list.getInt(50));
+		list = create(TEST_ARRAY);
+		Assert.assertTrue(list.swapRemoveInt(50));
+		Assert.assertFalse(list.swapRemoveInt(50));
+	}
+	
 	@Test
 	public void testListIterator() {
 		if(getValidListTests().contains(ListTest.LIST_ITERATOR)) return;

src/test/java/speiger/src/collections/objects/list/ObjectListTests.java

@@ -0,0 +1,46 @@
+package speiger.src.collections.objects.list;
+
+import java.util.List;
+import java.util.function.Function;
+
+import com.google.common.collect.testing.ListTestSuiteBuilder;
+import com.google.common.collect.testing.TestStringListGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import speiger.src.collections.objects.lists.ImmutableObjectList;
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectLinkedList;
+
+@SuppressWarnings("javadoc")
+public class ObjectListTests extends TestCase
+{
+	public static Test suite()
+	{
+		TestSuite suite = new TestSuite("Lists");
+		suite.addTest(suite("ArrayList", T -> new ObjectArrayList<>(T)));
+		suite.addTest(suite("LinkedList", T -> new ObjectLinkedList<>(T)));
+		suite.addTest(immutableSuite("ImmutableList", T -> new ImmutableObjectList<>(T)));
+		return suite;
+	}
+	
+	public static Test suite(String name, Function<String[], List<String>> factory)
+	{
+		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
+			@Override
+			protected List<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
+	}
+	
+	public static Test immutableSuite(String name, Function<String[], List<String>> factory)
+	{
+		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
+			@Override
+			protected List<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
+	}
+}

src/test/java/speiger/src/collections/objects/map/ObjectMapTests.java

@@ -0,0 +1,115 @@
+package speiger.src.collections.objects.map;
+
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
+
+import com.google.common.collect.testing.AnEnum;
+import com.google.common.collect.testing.MapTestSuiteBuilder;
+import com.google.common.collect.testing.TestEnumMapGenerator;
+import com.google.common.collect.testing.TestStringMapGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.MapFeature;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectLinkedOpenCustomHashMap;
+import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectOpenCustomHashMap;
+import speiger.src.collections.objects.maps.impl.hash.Object2ObjectLinkedOpenHashMap;
+import speiger.src.collections.objects.maps.impl.hash.Object2ObjectOpenHashMap;
+import speiger.src.collections.objects.maps.impl.immutable.ImmutableObject2ObjectOpenHashMap;
+import speiger.src.collections.objects.maps.impl.misc.Enum2ObjectMap;
+import speiger.src.collections.objects.maps.impl.misc.LinkedEnum2ObjectMap;
+import speiger.src.collections.objects.maps.impl.misc.Object2ObjectArrayMap;
+import speiger.src.collections.objects.maps.impl.tree.Object2ObjectAVLTreeMap;
+import speiger.src.collections.objects.maps.impl.tree.Object2ObjectRBTreeMap;
+import speiger.src.collections.objects.utils.ObjectStrategy;
+
+@SuppressWarnings("javadoc")
+public class ObjectMapTests extends TestCase
+{
+	public static Test suite()
+	{
+		TestSuite suite = new TestSuite("Maps");
+		suite.addTest(suite("HashMap", Object2ObjectOpenHashMap::new, true));
+		suite.addTest(suite("LinkedHashMap", Object2ObjectLinkedOpenHashMap::new, true));
+		suite.addTest(suite("CustomHashMap", () -> new Object2ObjectOpenCustomHashMap<>(Strategy.INSTANCE), true));
+		suite.addTest(suite("LinkedCustomHashMap", () -> new Object2ObjectLinkedOpenCustomHashMap<>(Strategy.INSTANCE), true));
+		suite.addTest(suite("RBTreeMap_NonNull", Object2ObjectRBTreeMap::new, false));
+		suite.addTest(suite("AVLTreeMap_NonNull", Object2ObjectAVLTreeMap::new, false));
+		suite.addTest(suite("RBTreeMap_Null", () -> new Object2ObjectRBTreeMap<String, String>(Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(suite("AVLTreeMap_Null", () -> new Object2ObjectAVLTreeMap<String, String>(Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(immutableSuit("ImmutableMap", ImmutableObject2ObjectOpenHashMap::new));
+		suite.addTest(suite("ArrayMap", Object2ObjectArrayMap::new, true));
+		suite.addTest(enumSuite("EnumMap", () -> new Enum2ObjectMap<>(AnEnum.class)));
+		suite.addTest(enumSuite("LinkedEnumMap", () -> new LinkedEnum2ObjectMap<>(AnEnum.class)));
+		return suite;
+	}
+	
+	public static Test suite(String name, Supplier<Map<String, String>> factory, boolean allowNull)
+	{
+		MapTestSuiteBuilder<String, String> builder = MapTestSuiteBuilder.using(new TestStringMapGenerator() {
+			@Override
+			protected Map<String, String> create(Map.Entry<String, String>[] entries) {
+				Map<String, String> map = factory.get();
+				for(Map.Entry<String, String> entry : entries) {
+					map.put(entry.getKey(), entry.getValue());
+				}
+				return map;
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, MapFeature.GENERAL_PURPOSE, MapFeature.ALLOWS_NULL_VALUES, CollectionFeature.SUPPORTS_ITERATOR_REMOVE);
+		if(allowNull) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS, MapFeature.ALLOWS_ANY_NULL_QUERIES);
+		return builder.createTestSuite();
+	}
+	
+	public static Test immutableSuit(String name, BiFunction<String[], String[], Map<String, String>> factory)  {
+		MapTestSuiteBuilder<String, String> builder = MapTestSuiteBuilder.using(new TestStringMapGenerator() {
+			@Override
+			protected Map<String, String> create(Map.Entry<String, String>[] entries) {
+				String[] keys = new String[entries.length];
+				String[] values = new String[entries.length];
+				for(int i = 0;i<entries.length;i++) {
+					keys[i] = entries[i].getKey();
+					values[i] = entries[i].getValue();
+				}
+				return factory.apply(keys, values);
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, MapFeature.ALLOWS_NULL_KEYS, MapFeature.ALLOWS_NULL_VALUES, MapFeature.ALLOWS_ANY_NULL_QUERIES);
+		return builder.createTestSuite();
+	}
+	
+	public static Test enumSuite(String name, Supplier<Map<AnEnum, String>> factory)
+	{
+		MapTestSuiteBuilder<AnEnum, String> builder = MapTestSuiteBuilder.using(new TestEnumMapGenerator() {
+			@Override
+			protected Map<AnEnum, String> create(Map.Entry<AnEnum, String>[] entries) {
+				Map<AnEnum, String> map = factory.get();
+				for(Map.Entry<AnEnum, String> entry : entries) {
+					map.put(entry.getKey(), entry.getValue());
+				}
+				return map;
+			}
+		}).named(name).withFeatures(CollectionSize.ANY, MapFeature.GENERAL_PURPOSE, MapFeature.ALLOWS_NULL_VALUES, CollectionFeature.SUPPORTS_ITERATOR_REMOVE);
+		return builder.createTestSuite();
+	}
+	
+	private static class Strategy implements ObjectStrategy<String>
+	{
+		static final Strategy INSTANCE = new Strategy();
+		
+		@Override
+		public int hashCode(String o) {
+			return Objects.hashCode(o);
+		}
+
+		@Override
+		public boolean equals(String key, String value) {
+			return Objects.equals(key, value);
+		}
+		
+	}
+}

src/test/java/speiger/src/collections/objects/set/ObjectSetTests.java

@@ -0,0 +1,80 @@
+package speiger.src.collections.objects.set;
+
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+
+import com.google.common.collect.testing.SetTestSuiteBuilder;
+import com.google.common.collect.testing.TestStringSetGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.SetFeature;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import speiger.src.collections.objects.sets.ImmutableObjectOpenHashSet;
+import speiger.src.collections.objects.sets.ObjectAVLTreeSet;
+import speiger.src.collections.objects.sets.ObjectArraySet;
+import speiger.src.collections.objects.sets.ObjectLinkedOpenCustomHashSet;
+import speiger.src.collections.objects.sets.ObjectLinkedOpenHashSet;
+import speiger.src.collections.objects.sets.ObjectOpenCustomHashSet;
+import speiger.src.collections.objects.sets.ObjectOpenHashSet;
+import speiger.src.collections.objects.sets.ObjectRBTreeSet;
+import speiger.src.collections.objects.utils.ObjectStrategy;
+
+@SuppressWarnings("javadoc")
+public class ObjectSetTests extends TestCase
+{
+	public static Test suite()
+	{
+		TestSuite suite = new TestSuite("Sets");
+		suite.addTest(suite("HashSet", ObjectOpenHashSet::new, true));
+		suite.addTest(suite("LinkedHashSet", ObjectLinkedOpenHashSet::new, true));
+		suite.addTest(suite("CustomHashSet", T -> new ObjectOpenCustomHashSet<>(T, Strategy.INSTANCE), true));
+		suite.addTest(suite("LinkedCustomHashSet", T -> new ObjectLinkedOpenCustomHashSet<>(T, Strategy.INSTANCE), true));
+		suite.addTest(immutableSuite("ImmutableHashSet", ImmutableObjectOpenHashSet::new));
+		suite.addTest(suite("ArraySet", ObjectArraySet::new, true));
+		suite.addTest(suite("RBTreeSet_NonNull", ObjectRBTreeSet::new, false));
+		suite.addTest(suite("AVLTreeSet_NonNull", ObjectAVLTreeSet::new, false));
+		suite.addTest(suite("RBTreeSet_Null", T -> new ObjectRBTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		suite.addTest(suite("AVLTreeSet_Null", T -> new ObjectAVLTreeSet<>(T, Comparator.nullsFirst(Comparator.naturalOrder())), true));
+		return suite;
+	}
+	
+	public static Test suite(String name, Function<String[], Set<String>> factory, boolean allowNull)
+	{
+		SetTestSuiteBuilder<String> generator = SetTestSuiteBuilder.using(new TestStringSetGenerator() {
+			@Override
+			protected Set<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).withFeatures(CollectionSize.ANY, SetFeature.GENERAL_PURPOSE);
+		if(allowNull) generator.withFeatures(CollectionFeature.ALLOWS_NULL_VALUES);
+		return generator.createTestSuite();
+	}
+	
+	
+	public static Test immutableSuite(String name, Function<String[], Set<String>> factory)
+	{
+		return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
+			@Override
+			protected Set<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES).createTestSuite();
+	}
+	
+	private static class Strategy implements ObjectStrategy<String>
+	{
+		static final Strategy INSTANCE = new Strategy();
+		
+		@Override
+		public int hashCode(String o) {
+			return Objects.hashCode(o);
+		}
+
+		@Override
+		public boolean equals(String key, String value) {
+			return Objects.equals(key, value);
+		}
+		
+	}
+}

src/test/java/speiger/src/collections/tests/CollectionTest.java

@@ -11,7 +11,9 @@ public enum CollectionTest
 	REMOVE,
 	REMOVE_IF,
 	REMOVE_ALL,
+	REMOVE_ALL_LISTENER,
 	RETAIN_ALL,
+	RETAIN_ALL_LISTENER,
 	TO_ARRAY,
 	CLEAR,
 	WRAPPER,

src/test/java/speiger/src/collections/tests/IterableTest.java

@@ -7,5 +7,15 @@ public enum IterableTest
 	ITERATOR_FOR_EACH,
 	ITERATOR_LOOP,
 	ITERATOR_REMOVAL,
-	ITERATOR_SKIP;
+	ITERATOR_SKIP,
+	STREAM_COUNT,
+	STREAM_FILTER,
+	STREAM_FIND_FIRST,
+	STREAM_DISTINCT,
+	STREAM_LIMIT,
+	STREAM_MAP,
+	STREAM_MATCHES,
+	STREAM_PEEK,
+	STREAM_POUR,
+	STREAM_REDUCE;
 }

src/test/java/speiger/src/collections/tests/ListTest.java

@@ -8,6 +8,7 @@ public enum ListTest
 	ADD_INDEX_COLLECTION,
 	ADD_INDEX_LIST,
 	ADD_ELEMENTS,
+	ADD_SPECIAL,
 	INDEX,
 	LAST_INDEX,
 	GET,
@@ -17,6 +18,7 @@ public enum ListTest
 	SORT,
 	REPLACE,
 	REMOVE,
+	REMOVE_SWAP,
 	REMOVE_ELEMENTS,
 	EXTRACT_ELEMENTS,
 	LIST_ITERATOR,