Version Bump

Added CompletableFuture Support and fixed a small bug in a test
fixed unit test
2026-08-10 20:14:19 +02:00 · 2026-08-10 19:38:35 +02:00 · 2026-08-10 09:49:53 +02:00 · 2026-08-09 21:43:57 +02:00 · 2026-05-15 02:45:00 +02:00 · 2026-05-15 02:34:19 +02:00
2190 changed files with 7925 additions and 1711871 deletions
@@ -32,7 +32,7 @@
 			<attribute name="gradle_used_by_scope" value="builder"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21/"/>
 	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
 	<classpathentry kind="output" path="bin/default"/>
 </classpath>
@@ -11,20 +11,20 @@ jobs:
      strategy:
         fail-fast: false
         matrix:
-            jdk: [8, 11, 16, 17, 18, 19, 20]
+            jdk: [8, 11, 17, 20, 21]

      runs-on: ubuntu-latest
      steps:
-         - uses: actions/checkout@v3
+         - uses: actions/checkout@v6
         
         - name: Set up JDK ${{ matrix.jdk }}
-           uses: actions/setup-java@v3
+           uses: actions/setup-java@v5
           with:
               distribution: 'temurin'
               java-version: ${{ matrix.jdk }}

         - name: Validate Gradle wrapper
-           uses: gradle/wrapper-validation-action@v1
+           uses: gradle/actions/wrapper-validation@v6

         - name: Make gradlew executable
           run: chmod +x ./gradlew
@@ -9,12 +9,12 @@ jobs:
      name: Unit Tests
      runs-on: ubuntu-latest
      steps:
-      -  uses: actions/checkout@v3
+      -  uses: actions/checkout@v6
         with:
            fetch-depth: 0
            
      -  name: Set up JDK 11
-         uses: actions/setup-java@v3
+         uses: actions/setup-java@v5
         with:
            distribution: temurin
            java-version: 11
@@ -54,7 +54,7 @@ jobs:
            esac

      -  name: Create Test Badge
-         uses: emibcn/badge-action@v1.2.4
+         uses: emibcn/badge-action@v2
         with:
            label: Tests
            status: '${{ fromJSON( steps.test-results.outputs.json ).conclusion }}, Passed: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_succ }}, Skipped: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_skip }}, Failed: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_fail }}'
@@ -8,11 +8,11 @@ jobs:
    name: Code Quality Check
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
        with:
          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
      - name: Set up JDK 11
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v5
        with:
          distribution: 'temurin'
          java-version: 11
@@ -9,12 +9,12 @@ jobs:
      name: Unit Tests
      runs-on: ubuntu-latest
      steps:
-      -  uses: actions/checkout@v2
+      -  uses: actions/checkout@v6
         with:
            fetch-depth: 0
            
      -  name: Set up JDK 11
-         uses: actions/setup-java@v3
+         uses: actions/setup-java@v5
         with:
            distribution: temurin
            java-version: 11
@@ -20,7 +20,15 @@ gradle-app.setting
 /bin/
 /storage/
 #Generated Code
-
+/src/main/java/speiger/src/collections/booleans/*
+/src/main/java/speiger/src/collections/bytes/*
+/src/main/java/speiger/src/collections/shorts/*
+/src/main/java/speiger/src/collections/chars/*
+/src/main/java/speiger/src/collections/ints/*
+/src/main/java/speiger/src/collections/longs/*
+/src/main/java/speiger/src/collections/floats/*
+/src/main/java/speiger/src/collections/doubles/*
+/src/main/java/speiger/src/collections/objects/*

 #Generated Tests
 /src/test/java/speiger/src/testers/booleans/*
@@ -2,21 +2,22 @@
 <projectDescription>
 	<name>Primitive-Collections</name>
 	<comment></comment>
-	<projects/>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 	</natures>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments/>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
-			<arguments/>
-		</buildCommand>
-	</buildSpec>
-	<linkedResources/>
-	<filteredResources/>
 </projectDescription>
@@ -1,5 +1,39 @@
 # Changelog of versions

+### Version 1.0.1
+-Added: AsyncBuilder now supports CompletableFuture
+-Added: forEach(BiConsumer, Input)
+
+
+### Version 1.0.0
+-Added: Sequenced Collections support.
+-Added: ReferenceMaps
+-Added: IndirectSorting
+-Added: Missing Optionals
+-Added: Collectors for Lists and Sets
+-Added: ReverseCollections for Sequenced/OrderedCollections
+-Breaking Change: FindFirst & reduce without identity use now Optionals instead of defaultValues
+-Breaking Change: Lists and OrderedSets no longer use Poll prefix they use now the java Remove
+-Fixed: #33
+-Fixed: Add/PutAndMoveToFirst wouldn't work if the collection was only with 1 entry present.
+-Fixed: Various new bugs found with the expansion of the unit tests.
+
+### Version 0.9.0
+- Added: getFirst/getLast/removeFirst/removeLast to List.class.
+- Added: Dedicated Set toArray implementations.
+- Added: ToArray/pushTop functions to Stack.class.
+- Added: ComputeNonDefault functions which will contain the current behavior of the Compute function, while the Compute will be changed to be more java compliant!
+- Added: List.reversed, which returns a SubList that has all elements in reversed order and also inserts reversed.
+- Added: Iterators.infinite as an option that will create a Infinite Iterator based on the inputed one.
+- Added: List.indexedIterator which allows you to create a iterator with a customized iteration indecies. Useful if you want to transform lists output.
+- Added: PriorityQueue.contains is now a function
+- Added: Iterators/Async Builders now support MapToPrimitiveType function on the object variant. So more processing can be done. (Will be expanded upon later versions)
+- Fixed: SetValue wasn't working on forEach implementations.
+- Fixed: Compute functions now perform with primitives more java compliant. Meaning that getDefaultReturnValue function no longer is seen as null.
+- Fixed: Supplier was using the wrong dataType in their function name.
+- Updated: SimpleCodeGenerator 1.3.0 is now being used which allows for iterative code support.
+- Breaking Change: Map.compute/IfAbsent/Present and Map.supplyIfAbsent if the value is a primitive it will no longer accept the defaultReturnValue() as "null" if that functionality is desired then use: computeNonDefault which contains the functionality!
+
 ### Version 0.8.1
 - Added: getFirst/getLast/removeFirst/removeLast to List.class.
 - Added: Dedicated Set toArray implementations.
@@ -30,10 +30,13 @@ There is 3 layers of control inside of the ModuleSettings.

 Allowing for greater control without having to edit hundreds of lines of code.   
 On top of that:   
-Any Setting that isn't "Present" is counted as "Enabled".    
+Any Setting that isn't "Present" can be defined as "Enabled" or "Disabled" using the "Default" argument.     
+If "Default" is missing, then it will just default to "Enabled".    
 So if you want to disable just 1 thing you can keep that 1 thing and delete the rest of the Setting.    
 It will still work as the same.    
 The default settings just come with everything so you can see what is controllable.   
+Note: If a global Module setting is disabled but a dependency needs said Module, it will enable only the required classes.    
+If a Module type (Float-Collection as example) is specifically disabled, the Dependency Resolver will throw errors telling you whats wrong.    

 How to compile the Code with the ModuleSettings enabled:
 ```
@@ -1,4 +1,5 @@
 {
+	"Default": true,
 	"Async": true,
 	"Base": true,
 	"Collection": true,
@@ -1,11 +1,12 @@
 ![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_action.yml/badge.svg)
 [![Latest Release](https://jitpack.io/v/Speiger/Primitive-Collections.svg)](https://jitpack.io/#Speiger/Primitive-Collections)
+![Maven Central Version](https://img.shields.io/maven-central/v/io.github.speiger/Primitive-Collections)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-![GitHub commit activity](https://img.shields.io/github/commit-activity/m/Speiger/Primitive-Collections)      
+![GitHub commit activity](https://img.shields.io/github/commit-activity/y/Speiger/Primitive-Collections)      
 ![Unit Tests](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_tests_action.yml/badge.svg)
-![Coverage](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/405abd1d2f6c19ac70f20b8b1772176f42d5c5d3/jacoco.svg)
+![Coverage](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/jacoco.svg)
 [![codecov](https://codecov.io/gh/Speiger/Primitive-Collections/branch/debug/graph/badge.svg?token=WSTSNJM0EN)](https://codecov.io/gh/Speiger/Primitive-Collections)
-![Tests Done](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/405abd1d2f6c19ac70f20b8b1772176f42d5c5d3/tests.svg)
+![Tests Done](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/tests.svg)
 # Primitive-Collections
 This is a Simple Primitive Collections Library aimed to outperform Java's Collection Library and FastUtil.  
 Both in Performance and Quality of Life Features.  
@@ -26,6 +27,7 @@ Such as pruning classes that are not needed in your code.
 - HashSets/Maps (Linked & HashControl)
 - TreeSets/Maps (RB & AVL)
 - EnumMaps
+- ReferenceMaps (Weak Keys)
 - Immutable Maps/Lists/Sets
 - ConcurrentHashMaps
 - Priority Queues
@@ -43,14 +45,21 @@ To ensure that problems can be dealt with even if it is breaking the current API

 # How to install
 Using Jitpack Gradle
-```gradle
+```groovy
 repositories {
    maven {
        url = "https://jitpack.io"
    }
 }
 dependencies {
-	implementation 'com.github.Speiger:Primitive-Collections:0.9.0'
+	implementation 'com.github.Speiger:Primitive-Collections:1.0.0'
+}
+```
+
+Using Maven Central
+```groovy
+dependencies {
+	implementation 'io.github.speiger:Primitive-Collections:1.0.0'
 }
 ```

@@ -0,0 +1,15 @@
+# Security Policy
+
+## Supported Versions
+
+Due to how the releases work, only the latest versions will be supported.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately.     
+**Please refrain from posting in public issues.**     
+This gives me time to process issues that are being found, and reduces the possiblity of abuse while patches are being created.   
+Please disclose it [here](https://github.com/Speiger/Primitive-Collections/security/advisories/new).
+
+Please consider that this project is developed by a single person.    
+So please provide a reasonable timeframe when reporting.    
@@ -1,6 +1,7 @@
 plugins {
    id 'java-library'
    id "jacoco"
+//	id "com.vanniktech.maven.publish" version "0.28.0"
 }

 tasks.withType(JavaCompile) {
@@ -10,6 +11,7 @@ tasks.withType(JavaCompile) {
 apply plugin: 'java'
 apply plugin: 'eclipse'
 apply plugin: 'maven-publish'
+apply plugin: 'signing'

 repositories {
    mavenCentral()
@@ -19,16 +21,22 @@ repositories {
 }

 archivesBaseName = 'Primitive Collections'
-version = '0.9.0';
+version = RELEASE_VERSION;

 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();

 System.out.println("Java Version: "+compileJava.sourceCompatibility)

+java {
+	withJavadocJar()
+    withSourcesJar()
+}
+
 javadoc {
    options.tags = [ "implSpec", "note" ] 
 }

+
 eclipse {
 	classpath {
 		downloadJavadoc = true
@@ -40,6 +48,7 @@ sourceSets {
    builder
 }

+
 configurations {
 	builderCompile.extendsFrom compile
 }
@@ -48,7 +57,7 @@ dependencies {
 	builderImplementation 'com.google.code.gson:gson:2.10'
 	builderImplementation 'de.speiger:Simple-Code-Generator:1.3.0'
    testImplementation 'junit:junit:4.12'
-    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
+    testImplementation 'com.google.guava:guava-testlib:33.6.0-jre'
    
 }

@@ -99,26 +108,12 @@ task generateLimitSource(type: JavaExec) {
 	args = ['silent', 'load']
 }

-task javadocJar(type: Jar) {
-    from javadoc
-    archiveClassifier = 'javadoc'
-}
-
-task srcJar(type: Jar) {
-    from sourceSets.main.allSource
-    archiveClassifier = 'sources'
-}
-
 compileJava.dependsOn generateGithubSource

 javadoc.failOnError = false
 javadoc.options.memberLevel = JavadocMemberLevel.PUBLIC
 javadoc.options.quiet()

-artifacts {
-    archives javadocJar
-    archives srcJar
-}

 task testBooleans(type: Test) {
 	group 'tests'
@@ -268,13 +263,10 @@ jacocoTestReport {
    }
 }

+
 publishing {
-	Properties props = new Properties()
-	if(file("$buildDir/credentials.properties").exists()) {
-		props.load(new FileInputStream("$buildDir/credentials.properties"))
-	}
 	publications {
-		mavenJava(MavenPublication) {
+		personal(MavenPublication) {
 			pom {
 				name = 'Primitive Collections'
 				description = 'A Primitive Collection library that reduces memory usage and improves performance'
@@ -283,8 +275,6 @@ publishing {
 				artifactId = project.archivesBaseName.replace(" ", "-")
 				groupId = 'de.speiger'
 				from components.java
-				artifact tasks.srcJar
-				artifact tasks.javadocJar
 				licenses {
 					license {
 						name = 'The Apache License, Version 2.0'
@@ -309,11 +299,82 @@ publishing {
 	}
 	repositories {
 		maven {
+			name = "Speiger_Maven"
+			def auth = System.getenv("Speiger_Maven_Auth")?.split(';');
 			url version.endsWith('SNAPSHOT') ? "https://maven.speiger.com/repository/debug" : "https://maven.speiger.com/repository/main"
 			credentials(PasswordCredentials) {
-				username props.mavenUser
-				password props.mavenPassword
+				username auth?[0]
+				password auth?[1]
 			}
 		}
 	}
 }
+
+tasks.withType(PublishToMavenRepository) {
+    def predicate = provider {
+        (repository == publishing.repositories.mavenCentral && publication == publishing.publications.maven) ||
+        (repository != publishing.repositories.mavenCentral && publication != publishing.publications.maven)
+    }
+    onlyIf("publishing binary to the external repository, or binary and sources to the internal one") {
+        predicate.get()
+    }
+}
+
+tasks.withType(PublishToMavenLocal) {
+    def predicate = provider {
+        publication == publishing.publications.personal
+    }
+    onlyIf("publishing binary and sources") {
+        predicate.get()
+    }
+}
+
+//Maven central Start
+//Disabling due to java8 incompat, only needed to manually publishing anyways
+
+//signing.useGpgCmd()
+//
+//import com.vanniktech.maven.publish.SonatypeHost
+//import com.vanniktech.maven.publish.JavaLibrary
+//import com.vanniktech.maven.publish.JavadocJar
+//
+//mavenPublishing {
+//  configure(new JavaLibrary(new JavadocJar.None(), true))
+//}
+//
+//mavenPublishing {
+//    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
+//
+//    signAllPublications()
+//    pom {
+//		name = 'Primitive Collections'
+//		description = 'A Primitive Collection library that reduces memory usage and improves performance'
+//		url = 'https://github.com/Speiger/Primitive-Collections'
+//		version = project.version	
+//		group = 'io.github.speiger'
+//        licenses {
+//            license {
+//				name = 'The Apache License, Version 2.0'
+//				url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+//            }
+//        }
+//
+//        developers {
+//			developer {
+//				id = 'speiger'
+//				name = 'Speiger'
+//			}
+//        }
+//
+//        scm {
+//            connection = 'scm:git:git://github.com/Speiger/Primitive-Collections.git'
+//            developerConnection = 'scm:git:ssh://github.com:Speiger/Primitive-Collections.git'
+//            url = 'https://github.com/Speiger/Primitive-Collections'
+//        }
+//                
+//        issueManagement {
+//			system = 'github'
+//			url = 'https://github.com/Speiger/Primitive-Collections/issues'
+//		}
+//    }
+//}
@@ -2,3 +2,5 @@ org.gradle.jvmargs=-Xmx3G

 maxMemory = 2048m
 testThreads = 4
+
+RELEASE_VERSION = 1.0.1
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -1,5 +1,5 @@
 jdk:
-   - openjdk9
+   - openjdk21
 install:
   - chmod +x ./gradlew
   - ./gradlew build publishToMavenLocal
@@ -34,7 +34,8 @@ public class FunctionModule extends BaseModule
 	protected void loadBlockades()
 	{
 		if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator");
-		if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Function", "UnaryOperator");
+		if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Optional", "Function", "UnaryOperator");
+		if(!keyType.needsCustomJDKType()) addBlockedFiles("Optional");
 	}
 	
 	@Override
@@ -60,6 +61,7 @@ public class FunctionModule extends BaseModule
 		}
 		else addBiRequirement("Function");
 		addRemapper("BiConsumer", "%sConsumer");
+		addRemapper("Optional", "Optional%s");
 	}
 	
 	@Override
@@ -77,6 +79,7 @@ public class FunctionModule extends BaseModule
 		addBiClassMapper("BI_CONSUMER", "Consumer", "");
 		addClassMapper("BI_TO_OBJECT_CONSUMER", "ObjectConsumer");
 		addAbstractMapper("BI_FROM_OBJECT_CONSUMER", "Object%sConsumer");
+		addAbstractMapper("BI_TO_OBJECT_CONSUMER", "%sObjectConsumer");
 		addAbstractMapper("BI_FROM_INT_CONSUMER", "Int%sConsumer");
 		if(keyType.isObject()) {
 			addSimpleMapper("TO_OBJECT_FUNCTION", keyType.getNonFileType()+"UnaryOperator");
@@ -94,6 +97,8 @@ public class FunctionModule extends BaseModule
 		
 		addFunctionMappers("PREDICATE", "%sPredicate");
 		addClassMapper("SUPPLIER", "Supplier");
+		addSimpleMapper("OPTIONAL", keyType.isObject() ? "Optional" : String.format("Optional%s", keyType.getFileType()));
+		addSimpleMapper("VALUE_OPTIONAL", valueType.isObject() ? "Optional" : String.format("Optional%s", valueType.getFileType()));
 		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
 		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
 		if(keyType.isObject())
@@ -60,6 +60,8 @@ public class JavaModule extends BaseModule
 		addSimpleMapper("APPLY_KEY_VALUE", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
 		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
 		addSimpleMapper("APPLY_CAST", "applyAs"+keyType.getCustomJDKType().getNonFileType());
+		addSimpleMapper("GET_OPTIONAL", keyType.isObject() ? "ofNullable" : "of");
+		addSimpleMapper("GET_OPTIONAL_VALUE", valueType.isObject() ? "ofNullable" : "of");
 		
 		//Shared by Maps and Pairs so moved to java.
 		addFunctionMappers("ENTRY_KEY", "get%sKey");
@@ -36,6 +36,10 @@ public class MapModule extends BaseModule
 	public static final FunctionDependency ENUM_MAP = MODULE.createDependency("EnumMap").addEntryDependency(IMPLEMENTATION);
 	public static final FunctionDependency LINKED_ENUM_MAP = MODULE.createDependency("LinkedEnumMap").addEntryDependency(ENUM_MAP).addEntryDependency(ORDERED_MAP);
 	
+	public static final FunctionDependency REF_MAP = MODULE.createDependency("ReferenceHashMap").addEntryDependency(IMPLEMENTATION);
+	public static final FunctionDependency LINKED_REF_MAP = MODULE.createDependency("LinkedReferenceMap").addEntryDependency(REF_MAP).addEntryDependency(ORDERED_MAP);
+
+	
 	public static final FunctionDependency CONCURRENT_MAP = MODULE.createDependency("ConcurrentMap").addEntryDependency(IMPLEMENTATION);
 	public static final FunctionDependency AVL_TREE_MAP = MODULE.createDependency("AVLTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION);
 	public static final FunctionDependency RB_TREE_MAP = MODULE.createDependency("RBTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION);
@@ -51,7 +55,7 @@ public class MapModule extends BaseModule
 	@Override
 	public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) {
 		List<IDependency> dependencies = new ArrayList<>(Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP));
-		if(keyType == ClassType.OBJECT) dependencies.addAll(Arrays.asList(ENUM_MAP, LINKED_ENUM_MAP));
+		if(keyType == ClassType.OBJECT) dependencies.addAll(Arrays.asList(ENUM_MAP, LINKED_ENUM_MAP, REF_MAP, LINKED_REF_MAP));
 		return dependencies;
 	}
 	
@@ -70,6 +74,10 @@ public class MapModule extends BaseModule
 		if(AVL_TREE_MAP.isEnabled()) addFlag("AVL_TREE_MAP_FEATURE");
 		if(RB_TREE_MAP.isEnabled()) addFlag("RB_TREE_MAP_FEATURE");
 		
+		if(REF_MAP.isEnabled()) addFlag("REF_MAP_FEATURE");
+		if(LINKED_REF_MAP.isEnabled()) addFlag("LINKED_REF_MAP_FEATURE");
+		
+		
 		if(CONCURRENT_MAP.isEnabled()) addFlag("CONCURRENT_MAP_FEATURE");
 		if(IMMUTABLE_MAP.isEnabled()) addFlag("IMMUTABLE_MAP_FEATURE");
 		if(HASH_MAP.isEnabled()) addFlag("MAP_FEATURE");
@@ -85,6 +93,8 @@ public class MapModule extends BaseModule
 		if(!IMMUTABLE_MAP.isEnabled()) addBlockedFiles("ImmutableOpenHashMap");
 		if(!CONCURRENT_MAP.isEnabled()) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
 		if(!ORDERED_MAP.isEnabled()) addBlockedFiles("OrderedMap");
+		if(!REF_MAP.isEnabled()) addBlockedFiles("ReferenceHashMap");
+		if(!LINKED_REF_MAP.isEnabled()) addBlockedFiles("LinkedReferenceHashMap");
 		if(!HASH_MAP.isEnabled()) addBlockedFiles("OpenHashMap");
 		if(!LINKED_MAP.isEnabled()) addBlockedFiles("LinkedOpenHashMap");
 		if(!CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap");
@@ -127,6 +137,8 @@ public class MapModule extends BaseModule
 		addBiRequirement("AbstractMap");
 		addEnumRequirement("EnumMap");
 		addEnumRequirement("LinkedEnumMap");
+		addEnumRequirement("ReferenceHashMap");
+		addEnumRequirement("LinkedReferenceHashMap");
 		addBiRequirement("ConcurrentOpenHashMap");
 		addBiRequirement("ImmutableOpenHashMap");
 		addBiRequirement("OpenHashMap");
@@ -141,6 +153,8 @@ public class MapModule extends BaseModule
 		addRemapper("AbstractMap", "Abstract%sMap");
 		addRemapper("EnumMap", "Enum2%sMap");
 		addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
+		addRemapper("ReferenceHashMap", "Reference2%sHashMap");
+		addRemapper("LinkedReferenceHashMap", "Reference2%sLinkedHashMap");
 		addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
 		//Test Classes
@@ -198,6 +212,7 @@ public class MapModule extends BaseModule
 		addBiRequirement("SortedMapNavigationTester");
 		addBiRequirement("OrderedMapNavigationTester");
 		addBiRequirement("OrderedMapMoveTester");
+		addBiRequirement("OrderedMapPutTester");
 		addBiRequirement("MapConstructorTester");
 		
 		addRemapper("TestMapGenerator", "Test%sMapGenerator");
@@ -248,6 +263,8 @@ public class MapModule extends BaseModule
 		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
 		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
 		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
+		addFunctionValueMappers("REF_MAP", valueType.isObject() ? "Reference2ObjectHashMap" : "Reference2%sHashMap");
+		addFunctionValueMappers("LINKED_REF_MAP", valueType.isObject() ? "Reference2ObjectLinkedHashMap" : "Reference2%sLinkedHashMap");
 		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
 		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
 		
@@ -5,6 +5,9 @@ import java.util.function.Consumer;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
+#if JDK_TYPE 
+import java.util.OPTIONAL;
+#endif

 #if !TYPE_OBJECT

@@ -30,9 +33,15 @@ import speiger.src.collections.PACKAGE.collections.OUTPUT_ITERABLE;
 #endif
 #enditerate
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -147,6 +156,18 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		iterator().forEachRemaining(input, action);
 	}
 	
+	/**
+	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
+	 * @param action The action to be performed for each element
+	 * @param input the object that should be included
+	 * @param <E> the generic type of the Object
+	 * @throws java.lang.NullPointerException if the specified action is null
+	 */
+	default <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		iterator().forEachRemaining(action, input);
+	}
+	
 #if SPLIT_ITERATOR_FEATURE
 	/**
 	 * A Type Specific Type Splititerator to reduce boxing/unboxing
@@ -408,13 +429,13 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @param filter that should be applied
 	 * @return the found value or the null equivalent variant.
 	 */
-	default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	default OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
 			KEY_TYPE entry = iter.NEXT();
-			if(filter.test(entry)) return entry;
+			if(filter.test(entry)) return OPTIONAL.GET_OPTIONAL(entry);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -459,7 +480,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @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) {
+	default OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -471,7 +492,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 			}
 			state = operator.APPLY_VALUE(state, iter.NEXT());
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}	
 	
 	/**
@@ -9,6 +9,9 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;

 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif

 /**
 * A Type-Specific {@link Iterator} that reduces (un)boxing
@@ -79,6 +82,18 @@ public interface ITERATOR KEY_GENERIC_TYPE extends Iterator<CLASS_TYPE>
 		while(hasNext()) { action.accept(input, NEXT()); }
 	}

+	/**
+	* Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
+	* @param action The action to be performed for each element
+	* @param input the object that should be included
+	* @param <E> the generic type of the Object
+	* @throws java.lang.NullPointerException if the specified action is null
+	*/
+	default <E> void forEachRemaining(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		while(hasNext()) { action.accept(NEXT(), input); }
+	}
+
 	/**
 	 * Skips the Given amount of elements if possible. A Optimization function to skip elements faster if the implementation allows it.
 	 * @param amount the amount of elements that should be skipped
@@ -0,0 +1,89 @@
+package speiger.src.collections.PACKAGE.functions;
+
+import java.util.NoSuchElementException;
+import java.util.function.Supplier;
+
+public final class OPTIONAL KEY_GENERIC_TYPE {
+	private static final OPTIONAL NO_GENERIC_TYPE EMPTY = new OPTIONALBRACES();
+	
+	private final boolean isPresent;
+	private final KEY_TYPE value;
+	
+	private OPTIONAL() {
+		this.isPresent = false;
+		this.value = EMPTY_VALUE;
+	}
+	
+	private OPTIONAL(KEY_TYPE value) {
+		this.isPresent = true;
+		this.value = value;
+	}
+	
+	public static OPTIONAL KEY_GENERIC_TYPE empty() {
+		return EMPTY;
+	}
+	
+	public static OPTIONAL KEY_GENERIC_TYPE of(KEY_TYPE value) {
+		return new OPTIONALBRACES(value);
+	}
+	
+	public KEY_TYPE SUPPLY_GET() {
+		if(!isPresent) throw new NoSuchElementException("No value present");
+		return value;
+	}
+	
+	public boolean isPresent() {
+		return isPresent;
+	}
+	
+	public boolean isEmpty() {
+		return !isPresent;
+	}
+	
+	public void ifPresent(CONSUMER KEY_GENERIC_TYPE consumer) {
+		if(isPresent) consumer.accept(value);
+	}
+	
+    public void ifPresentOrElse(CONSUMER KEY_GENERIC_TYPE action, Runnable emptyAction) {
+        if (isPresent) action.accept(value);
+        else emptyAction.run();
+    }
+	
+	public KEY_TYPE orElse(KEY_TYPE other) {
+		return isPresent ? value : other;
+	}
+	
+	public KEY_TYPE orElseGet(SUPPLIER KEY_GENERIC_TYPE other) {
+		return isPresent ? value : other.SUPPLY_GET();
+	}
+	
+	public KEY_TYPE orElseThrow() {
+        if (!isPresent) throw new NoSuchElementException("No value present");
+		return value;
+	}
+	
+    public <X extends Throwable> KEY_TYPE orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+    	if(isPresent) return value;
+    	else throw exceptionSupplier.get();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+    	if(obj == this) return true;
+    	if(obj instanceof OPTIONAL) {
+    		OPTIONAL KEY_GENERIC_TYPE other = (OPTIONAL KEY_GENERIC_TYPE)obj;
+    		return (isPresent && other.isPresent ? KEY_EQUALS(value, other.value) : isPresent == other.isPresent);
+    	}
+    	return false;
+    }
+    
+    @Override
+    public int hashCode() {
+    	return isPresent ? KEY_TO_HASH(value) : 0;
+    }
+    
+    @Override
+    public String toString() {
+    	return isPresent ? "OPTIONAL["+value+"]" : "OPTIONAL.empty";
+    }
+}
@@ -7,6 +7,16 @@ import java.util.Comparator;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+
+#endif
 #if TYPE_OBJECT
 #if IARRAY_FEATURE || TYPE_OBJECT
 import java.util.function.Consumer;
@@ -33,11 +43,18 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.STACK;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -219,6 +236,42 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return list;
 	}
 	
+#endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ArrayList
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, ObjectArrayList<T>, ObjectArrayList<T>> toList() {
+		return Collector.of(ObjectArrayList::new, ObjectArrayList::add, ObjectArrayList::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a ArrayList
+	 * @Type(T)
+	 * @return a list with the contents of the Stream
+	 */
+	public static <T> ARRAY_LIST KEY_GENERIC_TYPE toList(Stream<T> stream) {
+		return stream.collect(ObjectArrayList::new, ObjectArrayList::add, ObjectArrayList::merge);
+	}
+	
+	private ObjectArrayList<T> merge(ObjectArrayList<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ArrayList
+	 * @return a list with the contents of the Stream
+	 */
+	public static ARRAY_LIST toList(JAVA_STREAM stream) {
+		return stream.collect(ARRAY_LIST::new, ARRAY_LIST::add, ARRAY_LIST::addAll);
+	}
+	
+#endif
 #endif
 	/**
 	 * Appends the specified element to the end of this list.
@@ -654,6 +707,20 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			action.accept(input, data[i]);
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(int i = 0;i<size;i++)
+			action.accept(data[i], input);
+	}
+	
+	@Override
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
+		Objects.requireNonNull(action);
+		for(int i = 0;i<size;i++)
+			action.accept(i, data[i]);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -682,12 +749,12 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
-			if(filter.test(data[i])) return data[i];
+			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -714,7 +781,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -726,7 +793,7 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -8,6 +8,15 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+#endif
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -33,11 +42,18 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.STACK;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -166,7 +182,42 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	}
 	
 #endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a CopyOnWriteArrayList
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, CopyOnWriteObjectArrayList<T>, CopyOnWriteObjectArrayList<T>> toList() {
+		return Collector.of(CopyOnWriteObjectArrayList::new, CopyOnWriteObjectArrayList::add, CopyOnWriteObjectArrayList::merge);
+	}
 	
+	/**
+	 * Collects a Stream to a CopyOnWriteArrayList
+	 * @Type(T)
+	 * @return a list with the contents of the Stream
+	 */
+	public static <T> CopyOnWriteObjectArrayList KEY_GENERIC_TYPE toList(Stream<T> stream) {
+		return stream.collect(CopyOnWriteObjectArrayList::new, CopyOnWriteObjectArrayList::add, CopyOnWriteObjectArrayList::merge);
+	}
+	
+	private CopyOnWriteObjectArrayList<T> merge(CopyOnWriteObjectArrayList<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a CopyOnWriteArrayList
+	 * @return a list with the contents of the Stream
+	 */
+	public static COPY_ON_WRITE_LIST toList(JAVA_STREAM stream) {
+		return stream.collect(COPY_ON_WRITE_LIST::new, COPY_ON_WRITE_LIST::add, COPY_ON_WRITE_LIST::addAll);
+	}
+	
+#endif
+#endif
 	private void setArray(KEY_TYPE[] data) {
 		this.data = data;
 	}
@@ -779,6 +830,22 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			action.accept(input, data[i]);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		KEY_TYPE[] data = this.data;
+		for(int i = 0,m=data.length;i<m;i++)
+			action.accept(data[i], input);
+	}
+	
+	@Override
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
+		Objects.requireNonNull(action);
+		KEY_TYPE[] data = this.data;
+		for(int i = 0,m=data.length;i<m;i++)
+			action.accept(i, data[i]);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -810,13 +877,13 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		KEY_TYPE[] data = this.data;
 		for(int i = 0,m=data.length;i<m;i++) {
-			if(filter.test(data[i])) return data[i];
+			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -845,7 +912,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE[] data = this.data;
 		KEY_TYPE state = EMPTY_VALUE;
@@ -858,7 +925,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -3,10 +3,26 @@ package speiger.src.collections.PACKAGE.lists;
 import java.util.Arrays;
 #if TYPE_OBJECT
 import java.util.Comparator;
+#else if !TYPE_BOOLEAN
+import java.util.stream.JAVA_STREAM;
+import java.util.stream.StreamSupport;
 #endif
 import java.util.Collection;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if PRIMITIVES
+import java.util.function.Supplier;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+
+import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
+#endif
+#endif
 #if TYPE_OBJECT
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -20,6 +36,7 @@ import java.util.function.PREDICATE;
 #if !JDK_FUNCTION
 import java.util.function.JAVA_PREDICATE;
 #endif
+
 import java.util.function.JAVA_UNARY_OPERATOR;
 #endif

@@ -27,19 +44,22 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
 #endif
+import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
 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 && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
-import java.util.stream.JAVA_STREAM;
-import java.util.stream.StreamSupport;
-#endif
 #if SPLIT_ITERATOR_FEATURE
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
@@ -120,6 +140,42 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 		data = Arrays.copyOfRange(a, offset, offset+length);
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ImmutableList
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, COLLECTION<T>, ImmutableObjectList<T>> toList() {
+		return Collector.of(COLLECTIONS::wrapper, COLLECTION::add, ImmutableObjectList::merge, E -> new IMMUTABLE_LIST<>(E.toArray((T[])new Object[E.size()])));
+	}
+
+	/**
+	 * Collects a Stream to a ImmutableList
+	 * @Type(T)
+	 * @return a list with the contents of the Stream
+	 */
+	public static <T> ImmutableObjectList KEY_GENERIC_TYPE toList(Stream<T> stream) {
+		return stream.collect(toList());
+	}
+	
+	private static <T> COLLECTION<T> merge(COLLECTION<T> a, COLLECTION<T> b) {
+		a.addAll(b);
+		return a;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ImmutableList
+	 * @return a list with the contents of the Stream
+	 */
+	public static IMMUTABLE_LIST toList(JAVA_STREAM stream) {
+		return new IMMUTABLE_LIST(stream.collect((Supplier<COLLECTION>)COLLECTIONS::wrapper, COLLECTION::add, COLLECTION::addAll).TO_ARRAY());
+	}
+	
+#endif
+#endif
 	@Override
 	public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
 	@Override
@@ -307,6 +363,20 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 			action.accept(input, data[i]);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(int i = 0,m=data.length;i<m;i++)
+			action.accept(data[i], input);
+	}
+	
+	@Override
+	public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
+		Objects.requireNonNull(action);
+		for(int i = 0,m=data.length;i<m;i++)
+			action.accept(i, data[i]);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -335,12 +405,12 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0,m=data.length;i<m;i++) {
-			if(filter.test(data[i])) return data[i];
+			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -367,7 +437,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T

 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -379,7 +449,7 @@ public class IMMUTABLE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_T
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -4,7 +4,6 @@ package speiger.src.collections.PACKAGE.lists;
 #if DEQUEUE_FEATURE
 import java.util.Comparator;
 #endif
-
 import java.util.function.BiFunction;
 #else if PRIMITIVES
 import java.nio.JAVA_BUFFER;
@@ -12,6 +11,15 @@ import java.nio.JAVA_BUFFER;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+#endif
 import java.util.NoSuchElementException;
 #if SPLIT_ITERATOR_FEATURE
 import java.util.Spliterator;
@@ -34,8 +42,14 @@ import java.util.function.JAVA_PREDICATE;
 #endif
 import java.util.function.JAVA_UNARY_OPERATOR;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -155,6 +169,42 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		for(int i = offset,m=offset+length;i<m;add(a[i++]));
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a LinkedList
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, ObjectLinkedList<T>, ObjectLinkedList<T>> toList() {
+		return Collector.of(ObjectLinkedList::new, ObjectLinkedList::add, ObjectLinkedList::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a LinkedList
+	 * @Type(T)
+	 * @return a list with the contents of the Stream
+	 */
+	public static <T> ObjectLinkedList KEY_GENERIC_TYPE toList(Stream<T> stream) {
+		return stream.collect(ObjectLinkedList::new, ObjectLinkedList::add, ObjectLinkedList::merge);
+	}
+	
+	private ObjectLinkedList<T> merge(ObjectLinkedList<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a LinkedList
+	 * @return a list with the contents of the Stream
+	 */
+	public static LINKED_LIST toList(JAVA_STREAM stream) {
+		return stream.collect(LINKED_LIST::new, LINKED_LIST::add, LINKED_LIST::addAll);
+	}
+	
+#endif
+#endif
 	@Override
 	public boolean add(KEY_TYPE e) {
 		add(size(), e);
@@ -465,6 +515,13 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			action.accept(input, entry.value);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next)
+			action.accept(entry.value, input);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -493,12 +550,12 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next) {
-			if(filter.test(entry.value)) return entry.value;
+			if(filter.test(entry.value)) return OPTIONAL.GET_OPTIONAL(entry.value);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -525,7 +582,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -537,7 +594,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.value);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -4,15 +4,18 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.locks.StampedLock;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.BiFunction;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 #if !TYPE_OBJECT
@@ -22,15 +25,20 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 #if !VALUE_BOOLEAN || !JDK_TYPE
@@ -40,9 +48,12 @@ 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 && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
@@ -76,8 +87,12 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
 #endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if VALUE_OBJECT
@@ -751,6 +766,25 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0,m=segments.length;i<m;i++) {
+				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
+				long stamp = seg.readLock();
+				try {
+					int index = seg.firstIndex;
+					while(index != -1) {
+						action.accept(new ValueMapEntry(index, i), input);
+						index = (int)seg.links[index];
+					}					
+				}
+				finally {
+					seg.unlockRead(stamp);
+				}
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -839,7 +873,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -863,11 +897,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
 			MapEntry entry = new MapEntry();
 			for(int i = 0,m=segments.length;i<m;i++) {
@@ -877,7 +911,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 				try {
 					while(index != -1) {
 						entry.set(index, i);
-						if(filter.test(entry)) return entry;
+						if(filter.test(entry)) return Optional.ofNullable(entry);
 						index = (int)seg.links[index];
 					}
 				}
@@ -885,7 +919,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -1080,6 +1114,25 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0,m=segments.length;i<m;i++) {
+				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
+				long stamp = seg.readLock();
+				try {
+					int index = seg.firstIndex;
+					while(index != -1){
+						action.accept(seg.keys[index], input);
+						index = (int)seg.links[index];
+					}
+				}
+				finally {
+					seg.unlockRead(stamp);
+				}
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1186,7 +1239,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1210,11 +1263,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0,m=segments.length;i<m;i++) {
 				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
@@ -1222,7 +1275,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 				try {
 					int index = seg.firstIndex;
 					while(index != -1){
-						if(filter.test(seg.keys[index])) return seg.keys[index];
+						if(filter.test(seg.keys[index])) return OPTIONAL.GET_OPTIONAL(seg.keys[index]);
 						index = (int)seg.links[index];
 					}
 				}
@@ -1230,7 +1283,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1348,6 +1401,25 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0,m=segments.length;i<m;i++) {
+				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
+				long stamp = seg.readLock();
+				try {
+					int index = seg.firstIndex;
+					while(index != -1){
+						action.accept(seg.values[index], input);
+						index = (int)seg.links[index];
+					}
+				}
+				finally {
+					seg.unlockRead(stamp);
+				}
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1454,7 +1526,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1478,20 +1550,20 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
 			for(int i = 0,m=segments.length;i<m;i++) {
 				Segment KEY_VALUE_GENERIC_TYPE seg = segments[i];
 				long stamp = seg.readLock();
 				try {
 					int index = seg.firstIndex;
 					while(index != -1){
-						if(filter.test(seg.values[index])) return seg.values[index];
+						if(filter.test(seg.values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(seg.values[index]);
 						index = (int)seg.links[index];
 					}
 				}
@@ -1499,7 +1571,7 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					seg.unlockRead(stamp);
 				}
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -4,32 +4,41 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -56,9 +65,13 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;

+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
@@ -233,13 +246,13 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToFirstIndex(nullIndex);
+				moveToFirstIndex(nullIndex, false);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
+			moveToFirstIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -247,7 +260,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				if(strategy.equals(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToFirstIndex(pos);
+					moveToFirstIndex(pos, false);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -255,7 +268,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos);
+			moveToFirstIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -267,13 +280,13 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToLastIndex(nullIndex);
+				moveToLastIndex(nullIndex, false);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex);
+			moveToLastIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -281,7 +294,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				if(strategy.equals(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToLastIndex(pos);
+					moveToLastIndex(pos, false);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -289,7 +302,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos);
+			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -302,7 +315,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
+			moveToFirstIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -313,7 +326,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos);
+			moveToFirstIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -326,7 +339,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex);
+			moveToLastIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
@@ -337,7 +350,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos);
+			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -348,7 +361,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
-				moveToFirstIndex(nullIndex);
+				moveToFirstIndex(nullIndex, false);
 				return true;
 			}
 		}
@@ -356,7 +369,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
 			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
 				if(strategy.equals(keys[pos], key)) {
-					moveToFirstIndex(pos);
+					moveToFirstIndex(pos, false);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -370,7 +383,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		if(isEmpty() || strategy.equals(LAST_ENTRY_KEY(), key)) return false;
 		if(strategy.equals(key, EMPTY_KEY_VALUE)) {
 			if(containsNull) {
-				moveToLastIndex(nullIndex);
+				moveToLastIndex(nullIndex, false);
 				return true;
 			}
 		}
@@ -378,7 +391,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
 			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
 				if(strategy.equals(keys[pos], key)) {
-					moveToLastIndex(pos);
+					moveToLastIndex(pos, false);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -391,7 +404,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToFirstIndex(index);
+		moveToFirstIndex(index, false);
 		return values[index];
 	}
 	
@@ -399,7 +412,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToLastIndex(index);
+		moveToLastIndex(index, false);
 		return values[index];
 	}
 	
@@ -575,8 +588,8 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		containsNull = false;
 	}
 	
-	protected void moveToFirstIndex(int startPos) {
-		if(size == 1 || firstIndex == startPos) return;
+	protected void moveToFirstIndex(int startPos, boolean adding) {
+		if(size == (adding ? 0 : 1) || firstIndex == startPos) return;
 		if(lastIndex == startPos) {
 			lastIndex = (int)(links[startPos] >>> 32);
 			links[lastIndex] |= 0xFFFFFFFFL;
@@ -593,8 +606,8 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		firstIndex = startPos;
 	}
 	
-	protected void moveToLastIndex(int startPos) {
-		if(size == 1 || lastIndex == startPos) return;
+	protected void moveToLastIndex(int startPos, boolean adding) {
+		if(size == (adding ? 0 : 1) || lastIndex == startPos) return;
 		if(firstIndex == startPos) {
 			firstIndex = (int)links[startPos];
 			links[lastIndex] |= 0xFFFFFFFF00000000L;
@@ -708,6 +721,10 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -818,6 +835,17 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1) {
+				action.accept(new ValueMapEntry(index), input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -873,7 +901,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -888,21 +916,21 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.apply(state, new ValueMapEntry(index));
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			MapEntry entry = new MapEntry();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(index);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 				index = (int)links[index];
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -1000,9 +1028,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			throw new UnsupportedOperationException();
 		}

+		@Override
+		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-
 		@Override
 		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }

@@ -1096,6 +1127,17 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(keys[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1160,7 +1202,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1175,19 +1217,19 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_KEY_VALUE;
+			if(size() <= 0) return OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return keys[index];
+				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1279,6 +1321,17 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(values[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1343,7 +1396,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1358,19 +1411,19 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return values[index];
+				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -5,29 +5,37 @@ import java.util.ConcurrentModificationException;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 #if !VALUE_BOOLEAN || !JDK_TYPE
@@ -37,9 +45,12 @@ 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 && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_OBJECT
@@ -71,10 +82,13 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !SAME_TYPE
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
-
+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 import speiger.src.collections.objects.collections.ObjectIterator;
@@ -1023,6 +1037,16 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(new ValueMapEntry(nullIndex), input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(new ValueMapEntry(i), input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -1090,7 +1114,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -1107,25 +1131,25 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			MapEntry entry = new MapEntry();
 			if(containsNull) {
 				entry.set(nullIndex);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 			}
 			for(int i = nullIndex-1;i>=0;i--) {
 				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) {
 					entry.set(i);
-					if(filter.test(entry)) return entry;
+					if(filter.test(entry)) return Optional.ofNullable(entry);
 				}
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -1270,6 +1294,16 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(keys[nullIndex], input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(keys[i], input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1331,7 +1365,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1348,18 +1382,18 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_KEY_VALUE;
-			if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
+			if(size() <= 0) return OPTIONAL.empty();
+			if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return keys[i];
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1436,6 +1470,16 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(values[nullIndex], input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(values[i], input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1497,7 +1541,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1514,18 +1558,18 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
-			if(containsNull && filter.test(values[nullIndex])) return values[nullIndex];
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(containsNull && filter.test(values[nullIndex])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[nullIndex]);
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(values[i])) return values[i];
+				if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -4,32 +4,41 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -54,10 +63,13 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !SAME_TYPE
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
-
+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
@@ -210,13 +222,13 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToFirstIndex(nullIndex);
+				moveToFirstIndex(nullIndex, false);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
+			moveToFirstIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
@@ -224,7 +236,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				if(KEY_EQUALS(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToFirstIndex(pos);
+					moveToFirstIndex(pos, false);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -232,7 +244,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos);
+			moveToFirstIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -244,13 +256,13 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			if(containsNull) {
 				VALUE_TYPE lastValue = values[nullIndex];
 				values[nullIndex] = value;
-				moveToLastIndex(nullIndex);
+				moveToLastIndex(nullIndex, false);
 				return lastValue;
 			}
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex);
+			moveToLastIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
@@ -258,7 +270,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				if(KEY_EQUALS(keys[pos], key)) {
 					VALUE_TYPE lastValue = values[pos];
 					values[pos] = value;
-					moveToLastIndex(pos);
+					moveToLastIndex(pos, false);
 					return lastValue;
 				}
 				pos = ++pos & mask;
@@ -266,7 +278,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos);
+			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -279,18 +291,18 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToFirstIndex(nullIndex);
+			moveToFirstIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
-			while(KEY_EQUALS_NULL(key)) {
+			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) return values[pos];
 				pos = ++pos & mask;
 			}
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToFirstIndex(pos);
+			moveToFirstIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -303,18 +315,18 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			values[nullIndex] = value;
 			containsNull = true;
 			onNodeAdded(nullIndex);
-			moveToLastIndex(nullIndex);
+			moveToLastIndex(nullIndex, true);
 		}
 		else {
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
-			while(KEY_EQUALS_NULL(key)) {
+			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) return values[pos];
 				pos = ++pos & mask;
 			}
 			keys[pos] = key;
 			values[pos] = value;
 			onNodeAdded(pos);
-			moveToLastIndex(pos);
+			moveToLastIndex(pos, true);
 		}
 		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
 		return getDefaultReturnValue();
@@ -325,7 +337,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
-				moveToFirstIndex(nullIndex);
+				moveToFirstIndex(nullIndex, false);
 				return true;
 			}
 		}
@@ -333,7 +345,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
 			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) {
-					moveToFirstIndex(pos);
+					moveToFirstIndex(pos, false);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -347,7 +359,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		if(isEmpty() || KEY_EQUALS(LAST_ENTRY_KEY(), key)) return false;
 		if(KEY_EQUALS_NULL(key)) {
 			if(containsNull) {
-				moveToLastIndex(nullIndex);
+				moveToLastIndex(nullIndex, false);
 				return true;
 			}
 		}
@@ -355,7 +367,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
 			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
 				if(KEY_EQUALS(keys[pos], key)) {
-					moveToLastIndex(pos);
+					moveToLastIndex(pos, false);
 					return true;
 				}
 				pos = ++pos & mask;
@@ -368,7 +380,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToFirstIndex(index);
+		moveToFirstIndex(index, false);
 		return values[index];
 	}
 	
@@ -376,7 +388,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) {
 		int index = findIndex(key);
 		if(index < 0) return getDefaultReturnValue();
-		moveToLastIndex(index);
+		moveToLastIndex(index, false);
 		return values[index];
 	}
 	
@@ -579,8 +591,8 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		containsNull = false;
 	}
 	
-	protected void moveToFirstIndex(int startPos) {
-		if(size == 1 || firstIndex == startPos) return;
+	protected void moveToFirstIndex(int startPos, boolean adding) {
+		if(size == (adding ? 0 : 1) || firstIndex == startPos) return;
 		if(lastIndex == startPos) {
 			lastIndex = (int)(links[startPos] >>> 32);
 			links[lastIndex] |= 0xFFFFFFFFL;
@@ -597,8 +609,8 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		firstIndex = startPos;
 	}
 	
-	protected void moveToLastIndex(int startPos) {
-		if(size == 1 || lastIndex == startPos) return;
+	protected void moveToLastIndex(int startPos, boolean adding) {
+		if(size == (adding ? 0 : 1) || lastIndex == startPos) return;
 		if(firstIndex == startPos) {
 			firstIndex = (int)links[startPos];
 			links[lastIndex] |= 0xFFFFFFFF00000000L;
@@ -712,6 +724,10 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -822,6 +838,17 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1) {
+				action.accept(new ValueMapEntry(index), input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -877,7 +904,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -892,21 +919,21 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.apply(state, new ValueMapEntry(index));
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			MapEntry entry = new MapEntry();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(index);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 				index = (int)links[index];
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -999,6 +1026,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }

+		@Override
+		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }

@@ -1095,6 +1128,17 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(keys[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1159,7 +1203,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1174,19 +1218,19 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_KEY_VALUE;
+			if(size() <= 0) return OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return keys[index];
+				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1280,6 +1324,17 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(values[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1344,7 +1399,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1359,19 +1414,19 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return values[index];
+				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -5,29 +5,37 @@ import java.util.ConcurrentModificationException;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 #if !VALUE_BOOLEAN || !JDK_TYPE
@@ -37,9 +45,12 @@ 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 && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+#endif
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 #if !TYPE_OBJECT
@@ -70,9 +81,12 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
 #endif
-
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 import speiger.src.collections.objects.collections.ObjectIterator;
@@ -982,6 +996,16 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(new ValueMapEntry(nullIndex), input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NOT_NULL(keys[i])) action.accept(new ValueMapEntry(i), input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -1049,7 +1073,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -1066,25 +1090,25 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			MapEntry entry = new MapEntry();
 			if(containsNull) {
 				entry.set(nullIndex);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 			}
 			for(int i = nullIndex-1;i>=0;i--) {
 				if(KEY_EQUALS_NOT_NULL(keys[i])) {
 					entry.set(i);
-					if(filter.test(entry)) return entry;
+					if(filter.test(entry)) return Optional.ofNullable(entry);
 				}
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -1225,6 +1249,16 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(keys[nullIndex], input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NOT_NULL(keys[i])) action.accept(keys[i], input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1286,7 +1320,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1303,18 +1337,18 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_KEY_VALUE;
-			if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
+			if(size() <= 0) return OPTIONAL.empty();
+			if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return keys[i];
+				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1391,6 +1425,16 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			if(containsNull) action.accept(values[nullIndex], input);
+			for(int i = nullIndex-1;i>=0;i--) {
+				if(KEY_EQUALS_NOT_NULL(keys[i])) action.accept(values[i], input);
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1452,7 +1496,7 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1469,18 +1513,18 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
-			if(containsNull && filter.test(values[nullIndex])) return values[nullIndex];
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
+			if(containsNull && filter.test(values[nullIndex])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[nullIndex]);
 			for(int i = nullIndex-1;i>=0;i--) {
-				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(values[i])) return values[i];
+				if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -4,32 +4,43 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if !VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#endif
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 #if !VALUE_BOOLEAN || !JDK_TYPE
@@ -59,6 +70,7 @@ import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_C
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT
@@ -75,6 +87,9 @@ import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
 import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
 import speiger.src.collections.VALUE_PACKAGE.utils.VALUE_ARRAYS;
 #endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
+#endif
 #endif
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 #if !TYPE_OBJECT
@@ -630,6 +645,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -728,6 +747,17 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			}
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1) {
+				action.accept(new BasicEntryKV_BRACES(keys[index], values[index]), input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -783,7 +813,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -798,21 +828,21 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.apply(state, new BasicEntryKV_BRACES(keys[index], values[index]));
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES();
 			int index = firstIndex;
 			while(index != -1) {
 				entry.set(keys[index], values[index]);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 				index = (int)links[index];
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -887,6 +917,12 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			throw new UnsupportedOperationException();
 		}
 		
+		@Override
+		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
+		@Override
+		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }

@@ -973,6 +1009,17 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			}
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(keys[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1037,7 +1084,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1052,19 +1099,19 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.APPLY_KEY_VALUE(state, keys[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_KEY_VALUE;
+			if(size() <= 0) return OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(keys[index])) return keys[index];
+				if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1149,6 +1196,17 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			}
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			if(size() <= 0) return;
+			int index = firstIndex;
+			while(index != -1){
+				action.accept(values[index], input);
+				index = (int)links[index];
+			}
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1213,7 +1271,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1228,19 +1286,19 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 				state = operator.APPLY_VALUE(state, values[index]);
 				index = (int)links[index];
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return EMPTY_VALUE;
+			if(size() <= 0) return VALUE_OPTIONAL.empty();
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.test(values[index])) return values[index];
+				if(filter.test(values[index])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[index]);
 				index = (int)links[index];
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -4,32 +4,43 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#endif
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
 #if !VALUE_BOOLEAN || !JDK_TYPE
@@ -60,12 +71,16 @@ import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
 import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #endif
 #if !SAME_TYPE
-#if VALUE_OBJECT
+#if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;

+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !VALUE_OBJECT
@@ -861,6 +876,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -961,6 +980,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				action.accept(input, new ValueMapEntry(i));
 			}
 		}
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;i++) {
+				action.accept(new ValueMapEntry(i), input);
+			}
+		}
 		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
@@ -1009,7 +1035,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -1021,19 +1047,19 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.apply(state, new ValueMapEntry(i));
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			MapEntry entry = new MapEntry();
 			for(int i = 0;i<size;i++) {
 				entry.set(i);
-				if(filter.test(entry)) return entry;
+				if(filter.test(entry)) return Optional.ofNullable(entry);
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -1119,6 +1145,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		@Override
 		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
+		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -1166,6 +1196,12 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			for(int i = 0;i<size;action.accept(input, keys[i++])); 
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;action.accept(keys[i++], input)); 
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1218,7 +1254,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1230,16 +1266,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.APPLY_KEY_VALUE(state, keys[i]);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0;i<size;i++) {
-				if(filter.test(keys[i])) return keys[i];
+				if(filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
 			}
-			return EMPTY_KEY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1308,6 +1344,18 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			for(int i = 0;i<size;action.accept(i, values[i++]));
 		}
 		
+		@Override
+		public <E> void forEach(E input, VALUE_BI_FROM_OBJECT_CONSUMER VSV_GENERIC_TYPE<E> action) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;action.accept(input, values[i++])); 
+		}
+		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;action.accept(values[i++], input)); 
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1359,7 +1407,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 		
 #endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1371,16 +1419,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 				}
 				state = operator.APPLY_VALUE(state, values[i]);
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(int i = 0;i<size;i++) {
-				if(filter.test(values[i])) return values[i];
+				if(filter.test(values[i])) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(values[i]);
 			}
-			return EMPTY_VALUE;
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -473,6 +473,10 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 	}
 	
 	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -637,7 +641,10 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		public boolean add(T o) {
 			throw new UnsupportedOperationException();
 		}
-		
+		@Override
+		public void addFirst(T o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(T o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(T o) { throw new UnsupportedOperationException(); }

@@ -6,15 +6,18 @@ import java.util.Map;
 import java.util.Comparator;
 #endif
 import java.util.Objects;
+import java.util.Optional;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif


@@ -23,9 +26,14 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
@@ -34,12 +42,15 @@ import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUME
 #if !VALUE_BOOLEAN || !JDK_TYPE
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -70,9 +81,13 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;

+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT
@@ -1277,6 +1292,13 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				action.accept(input, entry.key);
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				action.accept(entry.key, input);
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1323,7 +1345,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1335,15 +1357,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.APPLY_KEY_VALUE(state, entry.key);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
-				if(filter.test(entry.key)) return entry.key;
-			return EMPTY_KEY_VALUE;
+				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -1979,6 +2001,13 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					action.accept(input, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
 			
+			@Override
+			public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+				Objects.requireNonNull(action);
+				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					action.accept(new BasicEntryKV_BRACES(entry.key, entry.value), input);
+			}
+			
 			@Override
 			public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
@@ -2026,7 +2055,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			}
 			
 			@Override
-			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			public Optional<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;
@@ -2038,19 +2067,19 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					}
 					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 				}
-				return state;
+				return empty ? Optional.empty() : Optional.ofNullable(state);
 			}
 			
 			@Override
-			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
-				if(size() <= 0) return null;
+				if(size() <= 0) return Optional.empty();
 				BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
 					subEntry.set(entry.key, entry.value);
-					if(filter.test(subEntry)) return subEntry;
+					if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
 				}
-				return null;
+				return Optional.empty();
 			}
 			
 			@Override
@@ -2119,6 +2148,13 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					action.accept(input, entry.value);
 			}
 			
+			@Override
+			public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+				Objects.requireNonNull(action);
+				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					action.accept(entry.value, input);
+			}
+			
 			@Override
 			public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -2165,7 +2201,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 			
 #endif
 			@Override
-			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 				Objects.requireNonNull(operator);
 				VALUE_TYPE state = EMPTY_VALUE;
 				boolean empty = true;
@@ -2177,15 +2213,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 					}
 					state = operator.APPLY_VALUE(state, entry.value);
 				}
-				return state;
+				return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 			}
 			
 			@Override
-			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+			public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
-					if(filter.test(entry.value)) return entry.value;
-				return EMPTY_VALUE;
+					if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+				return VALUE_OPTIONAL.empty();
 			}
 			
 			@Override
@@ -2521,7 +2557,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		
 		#endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -2533,15 +2569,15 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.APPLY_VALUE(state, entry.value);
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
-				if(filter.test(entry.value)) return entry.value;
-			return EMPTY_VALUE;
+				if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -2640,6 +2676,13 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				action.accept(input, new BasicEntryKV_BRACES(entry.key, entry.value));
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				action.accept(new BasicEntryKV_BRACES(entry.key, entry.value), input);
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -2687,7 +2730,7 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -2699,19 +2742,19 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 				}
 				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
 				subEntry.set(entry.key, entry.value);
-				if(filter.test(subEntry)) return subEntry;
+				if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -6,15 +6,18 @@ import java.util.Map;
 import java.util.Comparator;
 #endif
 import java.util.Objects;
+import java.util.Optional;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 import java.util.function.Predicate;
 #if !TYPE_OBJECT && JDK_TYPE
 import java.util.function.PREDICATE;
+import java.util.OPTIONAL;
 #endif
 #if !SAME_TYPE && JDK_VALUE && !VALUE_OBJECT
 import java.util.function.VALUE_PREDICATE;
+import java.util.VALUE_OPTIONAL;
 #endif

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
@@ -22,9 +25,14 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !VALUE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
 #endif
+#endif
+#if !TYPE_INT || !SAME_TYPE
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
-#if !TYPE_OBJECT && !VALUE_OBJECT
+#endif
+#if !TYPE_OBJECT && !VALUE_OBJECT && !TYPE_INT
 import speiger.src.collections.ints.functions.consumer.IntObjectConsumer;
 #endif
 #if !SAME_TYPE && !TYPE_INT
@@ -33,12 +41,15 @@ import speiger.src.collections.ints.functions.consumer.VALUE_BI_FROM_INT_CONSUME
 #if !VALUE_BOOLEAN || !JDK_TYPE
 import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
 #endif
-#if !TYPE_INT || !SAME_TYPE
+#if !TYPE_INT || !SAME_TYPE || !VALUE_OBJECT
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 #endif
-#if !TYPE_OBJECT && !VALUE_BOOLEAN && !JDK_TYPE
+#if !TYPE_OBJECT && !JDK_TYPE
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#if!VALUE_BOOLEAN
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+#endif
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !SAME_TYPE
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
@@ -68,10 +79,13 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer;
 #if !SAME_TYPE
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.functions.consumer.VALUE_BI_FROM_OBJECT_CONSUMER;
-
+#endif
+#if !VALUE_OBJECT && !VALUE_INT
+import speiger.src.collections.VALUE_PACKAGE.functions.consumer.VALUE_BI_TO_OBJECT_CONSUMER;
 #endif
 #if !JDK_VALUE
 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_OPTIONAL;
 #endif
 #endif
 #if !TYPE_OBJECT && !VALUE_OBJECT
@@ -1333,6 +1347,13 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				action.accept(input, entry.key);
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
+				action.accept(entry.key, input);
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1379,7 +1400,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(SINGLE_UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_KEY_VALUE;
 			boolean empty = true;
@@ -1391,15 +1412,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.APPLY_KEY_VALUE(state, entry.key);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = start(), end = end();entry != null && (end == null || (end != previous(entry)));entry = next(entry))
-				if(filter.test(entry.key)) return entry.key;
-			return EMPTY_KEY_VALUE;
+				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -2045,6 +2066,13 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					action.accept(input, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
 			
+			@Override
+			public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+				Objects.requireNonNull(action);
+				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					action.accept(new BasicEntryKV_BRACES(entry.key, entry.value), input);
+			}
+			
 			@Override
 			public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
@@ -2092,7 +2120,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			}
 			
 			@Override
-			public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+			public Optional<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;
@@ -2104,19 +2132,19 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					}
 					state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 				}
-				return state;
+				return empty ? Optional.empty() : Optional.ofNullable(state);
 			}
 			
 			@Override
-			public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+			public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 				Objects.requireNonNull(filter);
-				if(size() <= 0) return null;
+				if(size() <= 0) return Optional.empty();
 				BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry)) {
 					subEntry.set(entry.key, entry.value);
-					if(filter.test(subEntry)) return subEntry;
+					if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
 				}
-				return null;
+				return Optional.empty();
 			}
 			
 			@Override
@@ -2185,6 +2213,13 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					action.accept(input, entry.value);
 			}
 			
+			@Override
+			public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+				Objects.requireNonNull(action);
+				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
+					action.accept(entry.value, input);
+			}
+			
 			@Override
 			public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
@@ -2231,7 +2266,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 			
 #endif
 			@Override
-			public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+			public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 				Objects.requireNonNull(operator);
 				VALUE_TYPE state = EMPTY_VALUE;
 				boolean empty = true;
@@ -2243,15 +2278,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 					}
 					state = operator.APPLY_VALUE(state, entry.value);
 				}
-				return state;
+				return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 			}
 			
 			@Override
-			public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+			public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 				Objects.requireNonNull(filter);
 				for(Node KEY_VALUE_GENERIC_TYPE entry = subLowest(), last = subHighest();entry != null && (last == null || last != previous(entry));entry = next(entry))
-					if(filter.test(entry.value)) return entry.value;
-				return EMPTY_VALUE;
+					if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+				return VALUE_OPTIONAL.empty();
 			}
 			
 			@Override
@@ -2541,6 +2576,13 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				action.accept(input, entry.value);
 		}
 		
+		@Override
+		public <E> void forEach(VALUE_BI_TO_OBJECT_CONSUMER VVS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				action.accept(entry.value, input);
+		}
+		
 		@Override
 		public boolean matchesAny(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -2587,7 +2629,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		
 		#endif
 		@Override
-		public VALUE_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE reduce(VALUE_SINGLE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			VALUE_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -2599,15 +2641,15 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.APPLY_VALUE(state, entry.value);
 			}
-			return state;
+			return empty ? VALUE_OPTIONAL.empty() : VALUE_OPTIONAL.GET_OPTIONAL_VALUE(state);
 		}
 		
 		@Override
-		public VALUE_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
+		public VALUE_OPTIONAL VALUE_GENERIC_TYPE findFirst(VALUE_PREDICATE VALUE_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
-				if(filter.test(entry.value)) return entry.value;
-			return EMPTY_VALUE;
+				if(filter.test(entry.value)) return VALUE_OPTIONAL.GET_OPTIONAL_VALUE(entry.value);
+			return VALUE_OPTIONAL.empty();
 		}
 		
 		@Override
@@ -2706,6 +2748,13 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				action.accept(input, new BasicEntryKV_BRACES(entry.key, entry.value));
 		}
 		
+		@Override
+		public <E> void forEach(ObjectObjectConsumer<MAP.Entry KEY_VALUE_GENERIC_TYPE, E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+				action.accept(new BasicEntryKV_BRACES(entry.key, entry.value), input);
+		}
+		
 		@Override
 		public boolean matchesAny(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
@@ -2753,7 +2802,7 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE reduce(ObjectObjectUnaryOperator<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP.Entry KEY_VALUE_GENERIC_TYPE> operator) {
+		public Optional<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;
@@ -2765,19 +2814,19 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 				}
 				state = operator.apply(state, new BasicEntryKV_BRACES(entry.key, entry.value));
 			}
-			return state;
+			return empty ? Optional.empty() : Optional.ofNullable(state);
 		}
 		
 		@Override
-		public MAP.Entry KEY_VALUE_GENERIC_TYPE findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
+		public Optional<MAP.Entry KEY_VALUE_GENERIC_TYPE> findFirst(Predicate<MAP.Entry KEY_VALUE_GENERIC_TYPE> filter) {
 			Objects.requireNonNull(filter);
-			if(size() <= 0) return null;
+			if(size() <= 0) return Optional.empty();
 			BasicEntry KEY_VALUE_GENERIC_TYPE subEntry = new BasicEntryKV_BRACES();
 			for(Node KEY_VALUE_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
 				subEntry.set(entry.key, entry.value);
-				if(filter.test(subEntry)) return subEntry;
+				if(filter.test(subEntry)) return Optional.ofNullable(subEntry);
 			}
-			return null;
+			return Optional.empty();
 		}
 		
 		@Override
@@ -7,12 +7,26 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+#endif
 import java.util.NoSuchElementException;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif

 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -99,6 +113,47 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 		this(MIN_CAPACITY);
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ArrayFIFOQueue
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, ARRAY_FIFO_QUEUE<T>, ARRAY_FIFO_QUEUE<T>> toQueue() {
+		return Collector.of(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a ArrayFIFOQueue
+	 * @Type(T)
+	 * @return a queue with the contents of the Stream
+	 */
+	public static <T> ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
+		return stream.collect(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
+	}
+	
+	private ARRAY_FIFO_QUEUE<T> merge(ARRAY_FIFO_QUEUE<T> a) {
+		enqueueAll(a.toArray((T[])new Object[a.size()]));
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ArrayFIFOQueue
+	 * @return a queue with the contents of the Stream
+	 */
+	public static ARRAY_FIFO_QUEUE toQueue(JAVA_STREAM stream) {
+		return stream.collect(ARRAY_FIFO_QUEUE::new, ARRAY_FIFO_QUEUE::enqueue, ARRAY_FIFO_QUEUE::merge);
+	}
+	
+	private ARRAY_FIFO_QUEUE merge(ARRAY_FIFO_QUEUE a) {
+		enqueueAll(a.TO_ARRAY());
+		return this;
+	}
+	
+#endif
+#endif
 	@Override
 	public ITERATOR KEY_GENERIC_TYPE iterator() {
 		return new Iter();
@@ -318,17 +373,17 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0,m=size();i<m;i++) {
 			int index = (first + i) % array.length;
 			if(filter.test(array[index])) {
 				KEY_TYPE data = array[index];
 				removeIndex(index);
-				return data;
+				return OPTIONAL.GET_OPTIONAL(data);
 			}
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -355,7 +410,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -367,7 +422,7 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 			}
 			state = operator.APPLY_VALUE(state, array[(first + i) % array.length]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -8,12 +8,26 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif

 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -190,7 +204,47 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 		queue.size = size;
 		return queue;
 	}
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ArrayPriorityQueue
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, ARRAY_PRIORITY_QUEUE<T>, ARRAY_PRIORITY_QUEUE<T>> toQueue() {
+		return Collector.of(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
+	}
 	
+	/**
+	 * Collects a Stream to a ArrayPriorityQueue
+	 * @Type(T)
+	 * @return a queue with the contents of the Stream
+	 */
+	public static <T> ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
+		return stream.collect(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
+	}
+	
+	private ARRAY_PRIORITY_QUEUE<T> merge(ARRAY_PRIORITY_QUEUE<T> a) {
+		enqueueAll(a.toArray((T[])new Object[a.size()]));
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ArrayPriorityQueue
+	 * @return a queue with the contents of the Stream
+	 */
+	public static ARRAY_PRIORITY_QUEUE toQueue(JAVA_STREAM stream) {
+		return stream.collect(ARRAY_PRIORITY_QUEUE::new, ARRAY_PRIORITY_QUEUE::enqueue, ARRAY_PRIORITY_QUEUE::merge);
+	}
+	
+	private ARRAY_PRIORITY_QUEUE merge(ARRAY_PRIORITY_QUEUE a) {
+		enqueueAll(a.TO_ARRAY());
+		return this;
+	}
+	
+#endif
+#endif
 	@Override
 	public void enqueue(KEY_TYPE e) {
 		if(size == array.length) array = Arrays.copyOf(array, (int)Math.max(Math.min((long)array.length + (long)(array.length >> 1), (long)SanityChecks.MAX_ARRAY_SIZE), size+1));
@@ -346,7 +400,7 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -358,20 +412,20 @@ public class ARRAY_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUE
 			}
 			state = operator.APPLY_VALUE(state, array[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
 			if(filter.test(array[i])) {
 				KEY_TYPE data = array[i];
 				removeIndex(i);
-				return data;
+				return OPTIONAL.GET_OPTIONAL(data);
 			}
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -8,12 +8,26 @@ import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
+#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif

 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -193,6 +207,47 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 		return queue;
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ArrayFIFOQueue
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, HEAP_PRIORITY_QUEUE<T>, HEAP_PRIORITY_QUEUE<T>> toQueue() {
+		return Collector.of(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a ArrayFIFOQueue
+	 * @Type(T)
+	 * @return a queue with the contents of the Stream
+	 */
+	public static <T> HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE toQueue(Stream<T> stream) {
+		return stream.collect(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
+	}
+	
+	private HEAP_PRIORITY_QUEUE<T> merge(HEAP_PRIORITY_QUEUE<T> a) {
+		enqueueAll(a.toArray((T[])new Object[a.size()]));
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ArrayFIFOQueue
+	 * @return a queue with the contents of the Stream
+	 */
+	public static HEAP_PRIORITY_QUEUE toQueue(JAVA_STREAM stream) {
+		return stream.collect(HEAP_PRIORITY_QUEUE::new, HEAP_PRIORITY_QUEUE::enqueue, HEAP_PRIORITY_QUEUE::merge);
+	}
+	
+	private HEAP_PRIORITY_QUEUE merge(HEAP_PRIORITY_QUEUE a) {
+		enqueueAll(a.TO_ARRAY());
+		return this;
+	}
+	
+#endif
+#endif
 	@Override
 	public int size() {
 		return size;
@@ -326,7 +381,7 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -338,20 +393,20 @@ public class HEAP_PRIORITY_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEU
 			}
 			state = operator.APPLY_VALUE(state, array[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
 			if(filter.test(array[i])) {
 				KEY_TYPE data = array[i];
 				removeIndex(i);
-				return data;
+				return OPTIONAL.GET_OPTIONAL(data);
 			}
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -10,6 +10,15 @@ import java.util.function.BiFunction;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -19,8 +28,14 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -208,6 +223,42 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a AVLTreeSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, AVL_TREE_SET<T>, AVL_TREE_SET<T>> toSet() {
+		return Collector.of(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a AVLTreeSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> AVL_TREE_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
+		return stream.collect(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::merge);
+	}
+	
+	private AVL_TREE_SET<T> merge(AVL_TREE_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a AVLTreeSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static AVL_TREE_SET toSet(JAVA_STREAM stream) {
+		return stream.collect(AVL_TREE_SET::new, AVL_TREE_SET::add, AVL_TREE_SET::addAll);
+	}
+	
+#endif
+#endif
 #if !TYPE_OBJECT
 	@Override
 	public void setDefaultMaxValue(KEY_TYPE value) { defaultMaxNotFound = value; }
@@ -377,6 +428,13 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			action.accept(input, entry.key);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+			action.accept(entry.key, input);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -405,12 +463,12 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
-			if(filter.test(entry.key)) return entry.key;
+			if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -437,7 +495,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -449,7 +507,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.key);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -1263,6 +1321,13 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				action.accept(input, entry.key);		
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry))
+				action.accept(entry.key, input);
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1314,7 +1379,7 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1326,16 +1391,16 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				}
 				state = operator.APPLY_VALUE(state, entry.key);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
-				if(filter.test(entry.key)) return entry.key;
+				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
 			}
-			return EMPTY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -74,6 +74,16 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 			return set.iterator();
 		}
 		
+		@Override
+		public void addFirst(KEY_TYPE o) {
+			set.addLast(o);
+		}
+		
+		@Override
+		public void addLast(KEY_TYPE o) {
+			set.addFirst(o);
+		}
+		
 		@Override
 #if !TYPE_OBJECT
 		public boolean remove(KEY_TYPE o) {
@@ -8,6 +8,15 @@ import java.util.function.BiFunction;
 #endif
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 import java.util.Set;
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
@@ -18,9 +27,14 @@ import java.util.function.JAVA_PREDICATE;
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
-
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -69,7 +83,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	 * @param array the array that should be used for set.
 	 */
 	public ARRAY_SET(KEY_TYPE[] array) {
-		this(array, array.length);
+		this(array, 0, array.length);
 	}
 	
 	/**
@@ -83,6 +97,18 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		addAll(array, length);
 	}
 	
+	/**
+	 * Constructur using initial Array
+	 * @param array the array that should be used for set.
+	 * @param offset the starting offset of where the array should be copied from
+	 * @param length the amount of elements present within the array
+	 * @throws NegativeArraySizeException if the length is negative
+	 */
+	public ARRAY_SET(KEY_TYPE[] array, int offset, int length) {
+		this(length);
+		addAll(array, offset, length);
+	}
+	
 	/**
 	 * A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
 	 * @param c the elements that should be added to the set.
@@ -126,6 +152,42 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		for(ITERATOR KEY_GENERIC_TYPE iter = s.iterator();iter.hasNext();data[size++] = iter.NEXT());
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a ArraySet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, ARRAY_SET<T>, ARRAY_SET<T>> toList() {
+		return Collector.of(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a ArraySet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> ARRAY_SET KEY_GENERIC_TYPE toList(Stream<T> stream) {
+		return stream.collect(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::merge);
+	}
+	
+	private ARRAY_SET<T> merge(ARRAY_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a ArraySet
+	 * @return a set with the contents of the Stream
+	 */
+	public static ARRAY_SET toList(JAVA_STREAM stream) {
+		return stream.collect(ARRAY_SET::new, ARRAY_SET::add, ARRAY_SET::addAll);
+	}
+	
+#endif
+#endif
 	@Override
 	public boolean add(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -148,6 +210,25 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 	
 #endif
+	@Override
+	public void addFirst(KEY_TYPE o) {
+		int index = findIndex(o);
+		if(index == -1) {
+			if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+			System.arraycopy(data, 0, data, 1, size++);
+			data[0] = o;
+		}
+	}
+	
+	@Override
+	public void addLast(KEY_TYPE o) {
+		int index = findIndex(o);
+		if(index == -1) {
+			if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2);
+			data[size++] = o;
+		}
+	}
+	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		int index = findIndex(o);
@@ -410,6 +491,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			action.accept(input, data[i]);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(int i = 0;i<size;i++)
+			action.accept(data[i], input);
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -438,12 +526,12 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(int i = 0;i<size;i++) {
-			if(filter.test(data[i])) return data[i];
+			if(filter.test(data[i])) return OPTIONAL.GET_OPTIONAL(data[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 #if !TYPE_OBJECT
@@ -470,7 +558,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -482,7 +570,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 			}
 			state = operator.APPLY_VALUE(state, data[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
@@ -9,6 +9,9 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -19,8 +22,14 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -258,6 +267,10 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	@Override
 	public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); }
 	@Override
+	public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	@Override
+	public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 	@Override
 	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -353,6 +366,16 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		}
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		int index = firstIndex;
+		while(index != -1) {
+			action.accept(keys[index], input);
+			index = (int)links[index];
+		}
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -414,7 +437,7 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -427,18 +450,18 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return keys[index];
+			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 			index = (int)links[index];
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -9,6 +9,15 @@ import java.util.Objects;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
@@ -18,6 +27,9 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -25,6 +37,9 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -235,6 +250,82 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	}
 	
 #endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a LinkedCustomHashSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, LINKED_CUSTOM_HASH_SET<T>, LINKED_CUSTOM_HASH_SET<T>> toLinkedSet(STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return Collector.of(() -> new LINKED_CUSTOM_HASH_SET<>(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a LinkedCustomHashSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE toLinkedSet(Stream<T> stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return stream.collect(() -> new LINKED_CUSTOM_HASH_SET<>(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::merge);
+	}
+	
+	private LINKED_CUSTOM_HASH_SET<T> merge(LINKED_CUSTOM_HASH_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a LinkedCustomHashSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static LINKED_CUSTOM_HASH_SET toList(JAVA_STREAM stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return stream.collect(() -> new LINKED_CUSTOM_HASH_SET(strategy), LINKED_CUSTOM_HASH_SET::add, LINKED_CUSTOM_HASH_SET::addAll);
+	}
+	
+#endif
+#endif
+	@Override
+	public void addFirst(KEY_TYPE o) {
+		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
+			if(containsNull) return;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+			moveToFirstIndex(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
+			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
+				if(strategy.equals(keys[pos], o)) return;
+				pos = ++pos & mask;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+			moveToFirstIndex(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+	}
+	
+	@Override
+	public void addLast(KEY_TYPE o) {
+		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
+			if(containsNull) return;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(strategy.hashCode(o)) & mask;
+			while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
+				if(strategy.equals(keys[pos], o)) return;
+				pos = ++pos & mask;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+	}
+	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		if(strategy.equals(o, EMPTY_KEY_VALUE)) {
@@ -595,6 +686,16 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		}
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		int index = firstIndex;
+		while(index != -1) {
+			action.accept(keys[index], input);
+			index = (int)links[index];
+		}
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -656,7 +757,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -669,18 +770,18 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return keys[index];
+			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 			index = (int)links[index];
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -5,6 +5,15 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -21,8 +30,14 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -206,6 +221,82 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	}
 	
 #endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a LinkedHashSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, LINKED_HASH_SET<T>, LINKED_HASH_SET<T>> toLinkedSet() {
+		return Collector.of(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a LinkedHashSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> LINKED_HASH_SET KEY_GENERIC_TYPE toLinkedSet(Stream<T> stream) {
+		return stream.collect(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::merge);
+	}
+	
+	private LINKED_HASH_SET<T> merge(LINKED_HASH_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a LinkedHashSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static LINKED_HASH_SET toLinkedSet(JAVA_STREAM stream) {
+		return stream.collect(LINKED_HASH_SET::new, LINKED_HASH_SET::add, LINKED_HASH_SET::addAll);
+	}
+	
+#endif
+#endif
+	@Override
+	public void addFirst(KEY_TYPE o) {
+		if(KEY_EQUALS_NULL(o)) {
+			if(containsNull) return;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+			moveToFirstIndex(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
+			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
+				if(KEY_EQUALS(keys[pos], o)) return;
+				pos = ++pos & mask;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+			moveToFirstIndex(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+	}
+	
+	@Override
+	public void addLast(KEY_TYPE o) {
+		if(KEY_EQUALS_NULL(o)) {
+			if(containsNull) return;
+			containsNull = true;
+			onNodeAdded(nullIndex);
+		}
+		else {
+			int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask;
+			while(KEY_EQUALS_NOT_NULL(keys[pos])) {
+				if(KEY_EQUALS(keys[pos], o)) return;
+				pos = ++pos & mask;
+			}
+			keys[pos] = o;
+			onNodeAdded(pos);
+		}
+		if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
+	}
+	
 	@Override
 	public boolean addAndMoveToFirst(KEY_TYPE o) {
 		if(KEY_EQUALS_NULL(o)) {
@@ -450,6 +541,16 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		}
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		int index = firstIndex;
+		while(index != -1) {
+			action.accept(keys[index], input);
+			index = (int)links[index];
+		}
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -511,7 +612,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -524,18 +625,18 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 			else state = operator.APPLY_VALUE(state, keys[index]);
 			index = (int)links[index];
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		int index = firstIndex;
 		while(index != -1) {
-			if(filter.test(keys[index])) return keys[index];
+			if(filter.test(keys[index])) return OPTIONAL.GET_OPTIONAL(keys[index]);
 			index = (int)links[index];
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -6,6 +6,15 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -16,12 +25,18 @@ import java.util.function.PREDICATE;

 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -251,6 +266,42 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
+#endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a CustomHashSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, CUSTOM_HASH_SET<T>, CUSTOM_HASH_SET<T>> toSet(STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return Collector.of(() -> new CUSTOM_HASH_SET<>(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a CustomHashSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> CUSTOM_HASH_SET KEY_GENERIC_TYPE toSet(Stream<T> stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return stream.collect(() -> new CUSTOM_HASH_SET<>(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::merge);
+	}
+	
+	private CUSTOM_HASH_SET<T> merge(CUSTOM_HASH_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a CustomHashSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static CUSTOM_HASH_SET toSet(JAVA_STREAM stream, STRATEGY KEY_SUPER_GENERIC_TYPE strategy) {
+		return stream.collect(() -> new CUSTOM_HASH_SET(strategy), CUSTOM_HASH_SET::add, CUSTOM_HASH_SET::addAll);
+	}
+	
+#endif
 #endif
 	/**
 	 * Helper getter function to get the current strategy
@@ -574,6 +625,16 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 		}
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		if(size() <= 0) return;
+		if(containsNull) action.accept(keys[nullIndex], input);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE)) action.accept(keys[i], input);
+		}
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -635,7 +696,7 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -652,18 +713,18 @@ public class CUSTOM_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_T
 			}
 			state = operator.APPLY_VALUE(state, keys[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
-		if(size() <= 0) return EMPTY_VALUE;
-		if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
+		if(size() <= 0) return OPTIONAL.empty();
+		if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
 		for(int i = nullIndex-1;i>=0;i--) {
-			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return keys[i];
+			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -6,6 +6,15 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if TYPE_OBJECT
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
@@ -20,8 +29,14 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -218,6 +233,42 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
+#endif
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a HashSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, HASH_SET<T>, HASH_SET<T>> toSet() {
+		return Collector.of(HASH_SET::new, HASH_SET::add, HASH_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a HashSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> HASH_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
+		return stream.collect(HASH_SET::new, HASH_SET::add, HASH_SET::merge);
+	}
+	
+	private HASH_SET<T> merge(HASH_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a HashSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static HASH_SET toSet(JAVA_STREAM stream) {
+		return stream.collect(HASH_SET::new, HASH_SET::add, HASH_SET::addAll);
+	}
+	
+#endif
 #endif
 	@Override
 	public boolean add(KEY_TYPE o) {
@@ -437,6 +488,16 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 		}
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		if(size() <= 0) return;
+		if(containsNull) action.accept(keys[nullIndex], input);
+		for(int i = nullIndex-1;i>=0;i--) {
+			if(KEY_EQUALS_NOT_NULL(keys[i])) action.accept(keys[i], input);
+		}
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -498,7 +559,7 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -515,18 +576,18 @@ public class HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE imp
 			}
 			state = operator.APPLY_VALUE(state, keys[i]);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
-		if(size() <= 0) return EMPTY_VALUE;
-		if(containsNull && filter.test(keys[nullIndex])) return keys[nullIndex];
+		if(size() <= 0) return OPTIONAL.empty();
+		if(containsNull && filter.test(keys[nullIndex])) return OPTIONAL.GET_OPTIONAL(keys[nullIndex]);
 		for(int i = nullIndex-1;i>=0;i--) {
-			if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return keys[i];
+			if(KEY_EQUALS_NOT_NULL(keys[i]) && filter.test(keys[i])) return OPTIONAL.GET_OPTIONAL(keys[i]);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -5,6 +5,7 @@ import java.util.SequencedSet;

 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
+import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION;
 #if SPLIT_ITERATOR_FEATURE
 import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
@@ -23,9 +24,9 @@ import speiger.src.collections.PACKAGE.utils.SETS;
 * @Type(T)
 */
 #if JAVA_VERSION>=21
-public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SequencedSet<CLASS_TYPE>
+public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE, SequencedSet<CLASS_TYPE>
 #else
-public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
+public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE
 #endif
 {
 	/**
@@ -2,6 +2,15 @@ package speiger.src.collections.PACKAGE.sets;

 import java.util.Collection;
 import java.util.Collections;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#if !TYPE_OBJECT
+import java.util.stream.JAVA_STREAM;
+#else
+import java.util.stream.Stream;
+import java.util.stream.Collector;
+#endif
+#endif
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.Consumer;
@@ -19,8 +28,14 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
@@ -208,6 +223,42 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		while(iterator.hasNext()) add(iterator.NEXT());
 	}
 	
+#if JDK_TYPE && SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
+#if TYPE_OBJECT
+	/**
+	 * Creates a Collector for a RBTreeSet
+	 * @Type(T)
+	 * @return a collector
+	 */
+	public static <T> Collector<T, RB_TREE_SET<T>, RB_TREE_SET<T>> toSet() {
+		return Collector.of(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::merge);
+	}
+	
+	/**
+	 * Collects a Stream to a RBTreeSet
+	 * @Type(T)
+	 * @return a set with the contents of the Stream
+	 */
+	public static <T> RB_TREE_SET KEY_GENERIC_TYPE toSet(Stream<T> stream) {
+		return stream.collect(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::merge);
+	}
+	
+	private RB_TREE_SET<T> merge(RB_TREE_SET<T> a) {
+		addAll(a);
+		return this;
+	}
+	
+#else
+	/**
+	 * Collects a Stream to a RBTreeSet
+	 * @return a set with the contents of the Stream
+	 */
+	public static RB_TREE_SET toSet(JAVA_STREAM stream) {
+		return stream.collect(RB_TREE_SET::new, RB_TREE_SET::add, RB_TREE_SET::addAll);
+	}
+	
+#endif
+#endif
 #if !TYPE_OBJECT
 	@Override
 	public void setDefaultMaxValue(KEY_TYPE value) { defaultMaxNotFound = value; }
@@ -376,6 +427,13 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			action.accept(input, entry.key);		
 	}
 	
+	@Override
+	public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+		Objects.requireNonNull(action);
+		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next())
+			action.accept(entry.key, input);		
+	}
+	
 	@Override
 	public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
@@ -427,7 +485,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	
 #endif
 	@Override
-	public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+	public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 		Objects.requireNonNull(operator);
 		KEY_TYPE state = EMPTY_VALUE;
 		boolean empty = true;
@@ -439,16 +497,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			}
 			state = operator.APPLY_VALUE(state, entry.key);
 		}
-		return state;
+		return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 	}
 	
 	@Override
-	public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+	public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 		Objects.requireNonNull(filter);
 		for(Entry KEY_GENERIC_TYPE entry = first;entry != null;entry = entry.next()) {
-			if(filter.test(entry.key)) return entry.key;
+			if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
 		}
-		return EMPTY_VALUE;
+		return OPTIONAL.empty();
 	}
 	
 	@Override
@@ -1323,6 +1381,13 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				action.accept(input, entry.key);		
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry))
+				action.accept(entry.key, input);		
+		}
+		
 		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
@@ -1374,7 +1439,7 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 		
 #endif
 		@Override
-		public KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			Objects.requireNonNull(operator);
 			KEY_TYPE state = EMPTY_VALUE;
 			boolean empty = true;
@@ -1386,16 +1451,16 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 				}
 				state = operator.APPLY_VALUE(state, entry.key);
 			}
-			return state;
+			return empty ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(state);
 		}
 		
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
 			Objects.requireNonNull(filter);
 			for(Entry KEY_GENERIC_TYPE entry = start();entry != null && inRange(entry.key);entry = next(entry)) {
-				if(filter.test(entry.key)) return entry.key;
+				if(filter.test(entry.key)) return OPTIONAL.GET_OPTIONAL(entry.key);
 			}
-			return EMPTY_VALUE;
+			return OPTIONAL.empty();
 		}
 		
 		@Override
@@ -17,6 +17,7 @@ import java.util.function.IntFunction;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.utils.SanityChecks;
+import speiger.src.collections.utils.Swapper;

 /**
 * A Helper class for Arrays
@@ -337,6 +338,69 @@ public class ARRAYS
 		return array;
 	}
 	
+	/**
+	 * Simple Shuffle method for Arrays.
+	 * With a Callback for indirect shuffling
+	 * @param array the elements that should be shuffled
+	 * @param swapper the callback on the swaps
+	 * @ArrayType(T)
+	 * @note This uses the SanityChecks#getRandom
+	 * @return the provided sorted array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, Swapper swapper) {
+		return indirectShuffle(array, SanityChecks.getRandom(), swapper);
+	}
+	
+	/**
+	 * Simple Shuffle method for Arrays.
+	 * With a Callback for indirect shuffling
+	 * @param array the elements that should be shuffled
+	 * @param random the Random Number Generator that should be used for the shuffling
+	 * @param swapper the callback on the swaps
+	 * @ArrayType(T)
+	 * @return the provided sorted array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, RANDOM random, Swapper swapper) {
+		return indirectShuffle(array, 0, array.length, random, swapper);
+	}
+	
+	/**
+	 * Simple Shuffle method for Arrays.
+	 * With a Callback for indirect shuffling
+	 * @param array the elements that should be shuffled
+	 * @param length the length of the array
+	 * @param random the Random Number Generator that should be used for the shuffling
+	 * @param swapper the callback on the swaps
+	 * @ArrayType(T)
+	 * @return the provided sorted array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, int length, RANDOM random, Swapper swapper) {
+		return indirectShuffle(array, 0, length, random, swapper);
+	}
+	
+	/**
+	 * Simple Shuffle method for Arrays.
+	 * With a Callback for indirect shuffling
+	 * @param array the elements that should be shuffled
+	 * @param offset the start array
+	 * @param length the length of the array
+	 * @param random the Random Number Generator that should be used for the shuffling
+	 * @param swapper the callback on the swaps
+	 * @ArrayType(T)
+	 * @return the provided sorted array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectShuffle(KEY_TYPE[] array, int offset, int length, RANDOM random, Swapper swapper) {
+		for(int i = length-1; i>=0;i--) {
+			int j = offset + i;
+			int p = offset + random.nextInt(i + 1);
+			swapper.swap(j, p);
+			KEY_TYPE t = array[j];
+			array[j] = array[p];
+			array[p] = t;
+		}
+		return array;
+	}
+	
 	/**
 	 * Simple Array Reversal method
 	 * @param array the Array that should flip
@@ -575,6 +639,55 @@ public class ARRAYS
 		}
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @return input array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectInsertionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectInsertionSort(array, 0, array.length, comp, swapper);
+		return array;
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectInsertionSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectInsertionSort(array, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectInsertionSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		for (int i = from+1;i<to; i++) {
+			KEY_TYPE current = array[i];
+			int j = i - 1;
+			while(j >= from && comp.compare(current, array[j]) < 0) {
+				swapper.swap(j+1, j);
+				array[j+1] = array[j--];
+			}
+			array[j+1] = current;
+		}
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using InsertionSort, 
 	 * @param array the array that needs to be sorted
@@ -661,6 +774,60 @@ public class ARRAYS
 		}
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @return input array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectSelectionSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectSelectionSort(array, 0, array.length, comp, swapper);
+		return array;
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectSelectionSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectSelectionSort(array, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
+	 * On top of that allows to sort other things along with it.
+	 * @param array the array that needs to be sorted
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectSelectionSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		for (int i = from; i < to; i++) {
+			KEY_TYPE min = array[i];
+			int minId = i;
+			for(int j = i+1; j < to; j++) {
+				if(comp.compare(array[j], min) < 0) {
+					min = array[j];
+					minId = j;
+				}
+			}
+			swapper.swap(i, minId);
+			KEY_TYPE temp = array[i];
+			array[i] = min;
+			array[minId] = temp;
+		}
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using Selection Sort, 
 	 * @param array the array that needs to be sorted
@@ -760,6 +927,72 @@ public class ARRAYS
 		}
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @return input array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectMergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectMergeSort(array, null, 0, array.length, comp, swapper);
+		return array;
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectMergeSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectMergeSort(array, null, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param supp the auxillary array that is used to simplify the sorting
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectMergeSort(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		if(to - from < BASE_THRESHOLD) {
+			indirectInsertionSort(array, from, to, comp, swapper);
+			return;
+		}
+		if(supp == null) supp = Arrays.copyOf(array, to);
+		int mid = (from + to) >>> 1;
+		indirectMergeSort(supp, array, from, mid, comp, swapper);
+		indirectMergeSort(supp, array, mid, to, comp, swapper);
+		if(comp.compare(supp[mid - 1], supp[mid]) <= 0)
+		{
+			System.arraycopy(supp, from, array, from, to - from);
+			return;
+		}
+		for(int p = from, q = mid;from < to;from++) {
+			if(q >= to || p < mid && comp.compare(supp[p], supp[q]) < 0) {
+				swapper.swap(from, p);
+				array[from] = supp[p++];
+				continue;
+			}
+			swapper.swap(from, q);
+			array[from] = supp[q++];
+		}
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using Merge Sort, 
 	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
@@ -856,6 +1089,56 @@ public class ARRAYS
 		mergeSort(array, supp, from, to, comp);
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectParallelMergeSort(array, null, 0, array.length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param swapper the callback which elements were swapped
+	 * @param comp the Comparator that decides the sorting order
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectParallelMergeSort(array, null, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
+	 * @param array the array that needs to be sorted
+	 * @param supp the auxillary array that is used to simplify the sorting
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelMergeSort(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		if(SanityChecks.canParallelTask() && to - from >= PARALLEL_THRESHOLD) {
+			SanityChecks.invokeTask(new MergeSortActionCompSwapBRACES(array, supp, from, to, comp, swapper));
+			return;
+		}
+		indirectMergeSort(array, supp, from, to, comp, swapper);
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using Parallel Merge Sort, 
 	 * This implementation was copied from <a href="https://github.com/vigna/fastutil">FastUtil</a> with a couple custom optimizations
@@ -1209,6 +1492,73 @@ public class ARRAYS
 		if((length = d - c) > 1) quickSort(array, to - length, to, comp);
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @return input array
+	 */
+	public static GENERIC_KEY_BRACES KEY_TYPE[] indirectQuickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectQuickSort(array, 0, array.length, comp, swapper);
+		return array;
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectQuickSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectQuickSort(array, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 */
+	public static GENERIC_KEY_BRACES void indirectQuickSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		int length = to - from;
+		if(length <= 0) return;
+		if(length < BASE_THRESHOLD) {
+			indirectSelectionSort(array, from, to, comp, swapper);
+			return;			
+		}
+		KEY_TYPE pivot = array[length > 128 ? subMedium(array, from, from + (length / 2), to - 1, length / 8, comp) : medium(array, from, from + (length / 2), to - 1, comp)];
+		int a = from, b = a, c = to - 1, d = c;
+		for(int compare;;swap(array, b++, c--, swapper)) {
+			for(;b<=c && (compare = comp.compare(array[b], pivot)) <= 0;b++) {
+				if(compare == 0) swap(array, a++, b, swapper);
+			}
+			for(;c>=b && (compare = comp.compare(array[c], pivot)) >= 0;c--) {
+				if(compare == 0) swap(array, c, d--, swapper);
+			}
+			if(b>c) break;
+		}
+		swap(array, from, b, Math.min(a - from, b - a), swapper); 
+		swap(array, b, to, Math.min(d - c, to - d - 1), swapper);
+		if((length = b - a) > 1) indirectQuickSort(array, from, from + length, comp, swapper);
+		if((length = d - c) > 1) indirectQuickSort(array, to - length, to, comp, swapper);
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using Quick Sort, 
 	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
@@ -1313,6 +1663,58 @@ public class ARRAYS
 		quickSort(array, from, to, comp);
 	}
 	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectParallelQuickSort(array, 0, array.length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param length the maxmium size of the array to be sorted
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, int length, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		indirectParallelQuickSort(array, 0, length, comp, swapper);
+	}
+	
+	/**
+	 * Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort,
+	 * On top of that allows to sort other things along with it.
+	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
+	 * and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993. 
+	 * @param array the array that needs to be sorted
+	 * @param from where the array should be sorted from
+	 * @param to where the array should be sorted to
+	 * @param comp the Comparator that decides the sorting order
+	 * @param swapper the callback which elements were swapped
+	 * @ArrayType(T)
+	 * @note This parallelization is invoked through {@link SanityChecks#invokeTask} which the threadpool can be changed as needed
+	 */
+	public static GENERIC_KEY_BRACES void indirectParallelQuickSort(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+		if(SanityChecks.canParallelTask() && to - from >= PARALLEL_THRESHOLD) {
+			SanityChecks.invokeTask(new QuickSortActionCompSwapBRACES(array, from, to, comp, swapper));
+			return;
+		}
+		indirectQuickSort(array, from, to, comp, swapper);
+	}
+	
 	/**
 	 * Sorts an array according to the natural ascending order using Parallel Quick Sort, 
 	 * This implementation is a custom of <a href="https://github.com/vigna/fastutil">FastUtil</a> quicksort but with a different code structure,
@@ -1367,6 +1769,18 @@ public class ARRAYS
 		for(int i = 0;i<length;i++,swap(a, from++, to++));
 	}
 	
+	static GENERIC_KEY_BRACES void swap(KEY_TYPE[] a, int from, int to, Swapper swapper) {
+		swapper.swap(from, to);
+		KEY_TYPE t = a[from];
+		a[from] = a[to];
+		a[to] = t;
+	}
+	
+	static GENERIC_KEY_BRACES void swap(KEY_TYPE[] a, int from, int to, int length, Swapper swapper) {
+		to -= length;
+		for(int i = 0;i<length;i++,swap(a, from++, to++, swapper));
+	}
+	
 	static GENERIC_KEY_BRACES int subMedium(KEY_TYPE[] data, int a, int b, int c, int length, COMPARATOR KEY_GENERIC_TYPE comp) {
 		return medium(data, medium(data, a, a + length, a + (length * 2), comp), medium(data, b - length, b, b + length, comp), medium(data, c - (length * 2), c - length, c, comp), comp);
 	}
@@ -1389,16 +1803,14 @@ public class ARRAYS
 		int from;
 		int to;
 		
-		QuickSortAction(KEY_TYPE[] array, int from, int to)
-		{
+		QuickSortAction(KEY_TYPE[] array, int from, int to) {
 			this.array = array;
 			this.from = from;
 			this.to = to;
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			int length = to - from;
 			if(length <= 0) return;
 			if(length < BASE_THRESHOLD) {
@@ -1431,8 +1843,7 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		QuickSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
-		{
+		QuickSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
 			this.array = array;
 			this.from = from;
 			this.to = to;
@@ -1440,8 +1851,7 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			int length = to - from;
 			if(length <= 0) return;
 			if(length < BASE_THRESHOLD) {
@@ -1467,6 +1877,49 @@ public class ARRAYS
 		}
 	}
 	
+	static class QuickSortActionCompSwap KEY_GENERIC_TYPE extends RecursiveAction {
+		private static final long serialVersionUID = 0L;
+		KEY_TYPE[] array;
+		int from;
+		int to;
+		COMPARATOR KEY_GENERIC_TYPE comp;
+		Swapper swapper;
+		
+		QuickSortActionCompSwap(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+			this.array = array;
+			this.from = from;
+			this.to = to;
+			this.comp = comp;
+			this.swapper = swapper;
+		}
+		
+		@Override
+		protected void compute() {
+			int length = to - from;
+			if(length <= 0) return;
+			if(length < BASE_THRESHOLD) {
+				indirectSelectionSort(array, from, to, comp, swapper);
+				return;			
+			}
+			KEY_TYPE pivot = array[length > 128 ? subMedium(array, from, from + (length / 2), to - 1, length / 8, comp) : medium(array, from, from + (length / 2), to - 1, comp)];
+			int a = from, b = a, c = to - 1, d = c;
+			for(int compare;;swap(array, b++, c--, swapper)) {
+				for(;b<=c && (compare = comp.compare(array[b], pivot)) <= 0;b++) {
+					if(compare == 0) swap(array, a++, b, swapper);
+				}
+				for(;c>=b && (compare = comp.compare(array[c], pivot)) >= 0;c--) {
+					if(compare == 0) swap(array, c, d--, swapper);
+				}
+				if(b>c) break;
+			}
+			swap(array, from, b, Math.min(a - from, b - a), swapper); 
+			swap(array, b, to, Math.min(d - c, to - d - 1), swapper);
+			if(b - a > 1 && d - c > 1) invokeAll(new QuickSortActionCompSwapBRACES(array, from, from + (b - a), comp, swapper), new QuickSortActionCompSwapBRACES(array, to - (d - c), to, comp, swapper));
+			else if(b - a > 1) new QuickSortActionCompSwapBRACES(array, from, from + (b - a), comp, swapper).invoke();
+			else if(d - c > 1) new QuickSortActionCompSwapBRACES(array, to - (d - c), to, comp, swapper).invoke();
+		}
+	}
+	
 	static class MergeSortAction KEY_GENERIC_TYPE extends RecursiveAction {
 		private static final long serialVersionUID = 0L;
 		KEY_TYPE[] array;
@@ -1474,8 +1927,7 @@ public class ARRAYS
 		int from;
 		int to;
 		
-		MergeSortAction(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to)
-		{
+		MergeSortAction(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to) {
 			this.array = array;
 			this.supp = supp;
 			this.from = from;
@@ -1483,8 +1935,7 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to);
 				return;
@@ -1512,8 +1963,7 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		MergeSortActionComp(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
-		{
+		MergeSortActionComp(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
 			this.array = array;
 			this.supp = supp;
 			this.from = from;
@@ -1522,8 +1972,7 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to, comp);
 				return;
@@ -1543,22 +1992,64 @@ public class ARRAYS
 		}
 	}
 	
+	static class MergeSortActionCompSwap KEY_GENERIC_TYPE extends RecursiveAction {
+		private static final long serialVersionUID = 0L;
+		KEY_TYPE[] array;
+		KEY_TYPE[] supp;
+		int from;
+		int to;
+		COMPARATOR KEY_GENERIC_TYPE comp;
+		Swapper swapper;
+		
+		MergeSortActionCompSwap(KEY_TYPE[] array, KEY_TYPE[] supp, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp, Swapper swapper) {
+			this.array = array;
+			this.supp = supp;
+			this.from = from;
+			this.to = to;
+			this.comp = comp;
+			this.swapper = swapper;
+		}
+		
+		@Override
+		protected void compute() {
+			if(to - from < BASE_THRESHOLD) {
+				indirectInsertionSort(array, from, to, comp, swapper);
+				return;
+			}
+			if(supp == null) supp = Arrays.copyOf(array, to);
+			int mid = (from + to) >>> 1;
+			invokeAll(new MergeSortActionCompSwapBRACES(supp, array, from, mid, comp, swapper), new MergeSortActionCompSwapBRACES(supp, array, mid, to, comp, swapper));
+			if(comp.compare(supp[mid - 1], supp[mid]) <= 0)
+			{
+				System.arraycopy(supp, from, array, from, to - from);
+				return;
+			}
+			for(int p = from, q = mid;from < to;from++) {
+				if(q >= to || p < mid && comp.compare(supp[p], supp[q]) < 0) {
+					swapper.swap(from, p);
+					array[from] = supp[p++];
+					continue;
+				}
+				swapper.swap(from, q);
+				array[from] = supp[q++];
+			}
+		}
+	}
+	
 	static class MemFreeMergeSortAction KEY_GENERIC_TYPE extends RecursiveAction {
 		private static final long serialVersionUID = 0L;
 		KEY_TYPE[] array;
 		int from;
 		int to;
 		
-		MemFreeMergeSortAction(KEY_TYPE[] array, int from, int to)
-		{
+		MemFreeMergeSortAction(KEY_TYPE[] array, int from, int to) {
 			this.array = array;
 			this.from = from;
 			this.to = to;
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to);
 				return;
@@ -1604,8 +2095,7 @@ public class ARRAYS
 		int to;
 		COMPARATOR KEY_GENERIC_TYPE comp;
 		
-		MemFreeMergeSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp)
-		{
+		MemFreeMergeSortActionComp(KEY_TYPE[] array, int from, int to, COMPARATOR KEY_GENERIC_TYPE comp) {
 			this.array = array;
 			this.from = from;
 			this.to = to;
@@ -1613,8 +2103,7 @@ public class ARRAYS
 		}
 		
 		@Override
-		protected void compute()
-		{
+		protected void compute() {
 			if(to - from < BASE_THRESHOLD) {
 				insertionSort(array, from, to, comp);
 				return;
@@ -1,12 +1,18 @@
 package speiger.src.collections.PACKAGE.utils;

 import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.LockSupport;
 import java.util.function.Consumer;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#else
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT

 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -299,9 +305,8 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * @param operator that reduces the elements.
 	 * @return self with the reduce action applied
 	 */
-	public ASYNC_BUILDER KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
-		task = new SimpleReduceTaskBRACES(iterable.iterator(), operator);
-		return this;
+	public ObjectAsyncBuilder<OPTIONAL KEY_GENERIC_TYPE> reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
+		return new ObjectAsyncBuilder<>(new SimpleReduceTaskBRACES(iterable.iterator(), operator));
 	}
 	
 #if TYPE_OBJECT
@@ -435,9 +440,8 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * @param filter that decides the desired elements
 	 * @return self with the findFirst function applied
 	 */
-	public ASYNC_BUILDER KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
-		task = new FindFirstTaskBRACES(iterable.iterator(), filter);
-		return this;
+	public ObjectAsyncBuilder<OPTIONAL KEY_GENERIC_TYPE> findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
+		return new ObjectAsyncBuilder<>(new FindFirstTaskBRACES(iterable.iterator(), filter));
 	}
 	
 #if INT_ASYNC_MODULE
@@ -517,6 +521,16 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return toRun.GET_KEY(timeout, unit);
 	}
 	
+	/**
+	 * Starts the execution of the task and returns a future so it can be used with a future.
+	 * @return the task as a future
+	 */
+	public CompletableFuture<CLASS_TYPE> toFuture() {
+		BASE_TASK KEY_GENERIC_TYPE toRun = task;
+		task = null;
+		return toRun.toFuture();
+	}
+	
 #if !TYPE_OBJECT
 	private static class ReduceTask extends BASE_TASK
 	{
@@ -590,7 +604,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	}
 	
 #endif
-	private static class SimpleReduceTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
+	private static class SimpleReduceTask KEY_GENERIC_TYPE extends BaseObjectTask<OPTIONAL KEY_GENERIC_TYPE>
 	{
 		ITERATOR KEY_GENERIC_TYPE iter;
 		UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator;
@@ -600,6 +614,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		public SimpleReduceTask(ITERATOR KEY_GENERIC_TYPE iter, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
 			this.iter = iter;
 			this.operator = operator;
+			this.setResult(OPTIONAL.empty());
 		}
 		
 		@Override
@@ -614,7 +629,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 				}
 			}
 			if(!iter.hasNext()) {
-				setResult(value);
+				setResult(OPTIONAL.GET_OPTIONAL(value));
 				return true;
 			}
 			return false;
@@ -689,7 +704,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	}
 	
 #endif
-	private static class FindFirstTask KEY_GENERIC_TYPE extends BASE_TASK KEY_GENERIC_TYPE
+	private static class FindFirstTask KEY_GENERIC_TYPE extends BaseObjectTask<OPTIONAL KEY_GENERIC_TYPE>
 	{
 		ITERATOR KEY_GENERIC_TYPE iter;
 		PREDICATE KEY_GENERIC_TYPE filter;
@@ -697,6 +712,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		public FindFirstTask(ITERATOR KEY_GENERIC_TYPE iter, PREDICATE KEY_GENERIC_TYPE filter) {
 			this.iter = iter;
 			this.filter = filter;
+			this.setResult(OPTIONAL.empty());
 		}

 		@Override
@@ -704,7 +720,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 			while(shouldRun() && iter.hasNext()) {
 				KEY_TYPE entry = iter.NEXT();
 				if(filter.test(iter.NEXT())) {
-					setResult(entry);
+					setResult(OPTIONAL.GET_OPTIONAL(entry));
 					return true;
 				}
 			}
@@ -876,6 +892,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		private static final int CANCELLED = 7;
 		private volatile WaitNode waiter;
 		private volatile int state = CREATED;
+		private volatile boolean locked = false;
 		Consumer<TASK KEY_GENERIC_TYPE> callback;
 		Executor executor = SanityChecks::invokeAsyncTask;
 		KEY_TYPE result;
@@ -945,6 +962,17 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	    	onCompletion();
 	    }
 	    
+		CompletableFuture<CLASS_TYPE> toFuture() {
+			locked = true;
+			Executor exe = this.executor;
+			this.executor = Runnable::run;
+			return CompletableFuture.supplyAsync(() -> {
+				begin();
+				try { return GET_KEY(); }
+				catch(Exception e) { throw new RuntimeException(e); }
+			}, exe);
+		}
+		
 		@Override
 		public boolean cancel(boolean cancelIfRunnning) {
 			if(state == RUNNING && !cancelIfRunnning) return false;
@@ -1039,12 +1067,14 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		
 		@Override
 		public void pause() {
+			if(locked) throw new IllegalStateException("Completable Future Wrap doesn't support pause");
 			if(state == PAUSED || state == PAUSING || state >= FINISHING) return;
 			state = PAUSING;
 		}
 		
 		@Override
 		public void awaitPausing() {
+			if(locked) throw new IllegalStateException("Completable Future Wrap doesn't support pause");
 			if(state == PAUSED) return;
 			pause();
 			if(state == PAUSING) {
@@ -1056,6 +1086,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		
 		@Override
 		public void resume() {
+			if(locked) throw new IllegalStateException("Completable Future Wrap doesn't support pause");
 			if(state != PAUSED && state != PAUSING) return;
 			if(state == PAUSING) {
 				while(state == PAUSING) {
@@ -8,6 +8,9 @@ import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#endif
 #if TYPE_OBJECT
 import java.util.Comparator;
 import java.util.function.BiFunction;
@@ -30,6 +33,9 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if !TYPE_OBJECT
 import speiger.src.collections.objects.utils.ObjectArrays;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
@@ -40,6 +46,9 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.consumer.BI_TO_OBJECT_CONSUMER;
+#endif
 #if !TYPE_BOOLEAN
 import speiger.src.collections.utils.HashUtil;
 #endif
@@ -141,7 +150,10 @@ public class COLLECTIONS
 		return new SingletonCollectionBRACES(element);
 	}
 	
-	protected static GENERIC_KEY_BRACES CollectionWrapper KEY_GENERIC_TYPE wrapper() {
+	/**
+	 * Internal Use mainly. Its a collection wrapper with 0 dependencies for those actions where a collector is needed.
+	 */
+	public static GENERIC_KEY_BRACES CollectionWrapper KEY_GENERIC_TYPE wrapper() {
 		return new CollectionWrapperBRACES();
 	}
 	
@@ -285,6 +297,13 @@ public class COLLECTIONS
 				action.accept(elements[i]);
 		}
 		
+		@Override
+		public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;i++)
+				action.accept(i, elements[i]);
+		}
+		
 		@Override
 		public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
 			Objects.requireNonNull(action);
@@ -292,6 +311,13 @@ public class COLLECTIONS
 				action.accept(input, elements[i]);		
 		}
 		
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) {
+			Objects.requireNonNull(action);
+			for(int i = 0;i<size;i++)
+				action.accept(elements[i], input);
+		}
+		
 		@Override
 		public boolean trim(int size) {
 			if(size > size() || size() == elements.length) return false;
@@ -846,6 +872,10 @@ public class COLLECTIONS
 		@Override
 		public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) { synchronized(mutex) { c.forEachIndexed(action); } }
 		@Override
+		public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) { synchronized(mutex) { c.forEach(input, action); } }
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) { synchronized(mutex) { c.forEach(action, input); } }
+		@Override
 		public int hashCode() { synchronized(mutex) { return c.hashCode(); } }
 		@Override
 		public boolean equals(Object obj) {
@@ -855,8 +885,6 @@ public class COLLECTIONS
 		@Override
 		public String toString() { synchronized(mutex) { return c.toString(); } }
 		@Override
-		public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) { synchronized(mutex) { c.forEach(input, action); } }
-		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.matchesAny(filter); } }
 		@Override
 		public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.matchesNone(filter); } }
@@ -869,9 +897,9 @@ public class COLLECTIONS
 		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); } }
+		public OPTIONAL KEY_GENERIC_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); } }
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.findFirst(filter); } }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.count(filter); } }
 	}
@@ -1001,14 +1029,16 @@ public class COLLECTIONS
 		@Override
 		public void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) { c.forEachIndexed(action); }
 		@Override
+		public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) { c.forEach(input, action); }
+		@Override
+		public <E> void forEach(BI_TO_OBJECT_CONSUMER KKS_GENERIC_TYPE<E> action, E input) { c.forEach(action, input); }
+		@Override
 		public int hashCode() { return c.hashCode(); }
 		@Override
 		public boolean equals(Object obj) { return obj == this || c.equals(obj); }
 		@Override
 		public String toString() { return c.toString(); }
 		@Override
-		public <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) { c.forEach(input, action); }
-		@Override
 		public boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) { return c.matchesAny(filter); }
 		@Override
 		public boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) { return c.matchesNone(filter); }
@@ -1021,9 +1051,9 @@ public class COLLECTIONS
 		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); }
+		public OPTIONAL KEY_GENERIC_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); }
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { return c.findFirst(filter); }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { return c.count(filter); }
 	}
@@ -4,16 +4,22 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.function.Consumer;
+import java.util.function.BiFunction;
 #endif
 #if JDK_FUNCTION
 import java.util.function.PREDICATE;
 #endif
-
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
+#if !JDK_TYPE 
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
 #if DEQUEUE_FEATURE
 import speiger.src.collections.PACKAGE.queues.PRIORITY_DEQUEUE;
 #endif
@@ -24,6 +30,7 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #if !JDK_FUNCTION
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #endif
+import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;

 /**
@@ -140,7 +147,15 @@ public class PRIORITY_QUEUES
 		@Override
 		public boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.matchesAll(filter); } }
 		@Override
-		public KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.findFirst(filter); } }
+		public OPTIONAL KEY_GENERIC_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.findFirst(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 queue.reduce(identity, operator); } }
+#else
+		@Override
+		public KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return queue.reduce(identity, operator); } }
+#endif
+		@Override
+		public OPTIONAL KEY_GENERIC_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) { synchronized(mutex) { return queue.reduce(operator); } }
 		@Override
 		public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return queue.count(filter); } }
 	}
@@ -360,6 +360,10 @@ public class SETS
 			s = c;
 		}
 		
+		@Override
+		public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -651,6 +655,10 @@ public class SETS
 			s = c;
 		}
 		
+		@Override
+		public void addFirst(KEY_TYPE o) { synchronized(mutex) { s.addFirst(o); } }
+		@Override
+		public void addLast(KEY_TYPE o) { synchronized(mutex) { s.addLast(o); } }
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
 		@Override
@@ -755,6 +755,10 @@ public class MAPS
 			set = c;
 		}
 		
+		@Override
+		public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
+		@Override
+		public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -20,6 +20,7 @@ import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
 import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
 import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
 import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester;
 #if !TYPE_OBJECT
 import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
 import speiger.src.testers.objects.generators.TestObjectSetGenerator;
@@ -41,6 +42,7 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
 		List<Class<? extends AbstractTester>> testers = super.getTesters();
 		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class);
 		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester.class);
 		return testers;
 	}
 	
@@ -77,7 +79,7 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
 		features.addAll(parentBuilder.getFeatures());
 		features.remove(SpecialFeature.COPYING);
 		features.remove(SpecialFeature.CHILDREN_COPY);
-		return ORDERED_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.ReverseTestOrderedMapGenerator(delegate))
+		return ORDERED_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.ReverseTestOrderedMapGeneratorKV_BRACES(delegate))
 				.named(parentBuilder.getName() + " reversed").withFeatures(features)
 				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
 	}
@@ -27,6 +27,8 @@ import speiger.src.collections.PACKAGE.maps.impl.concurrent.CONCURRENT_HASH_MAP;
 #if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.reference.REF_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.reference.LINKED_REF_MAP;
 #endif

 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
@@ -134,6 +136,97 @@ public class MAP_CONSTRUCTOR_TESTS
 	}
 	
 #if TYPE_OBJECT
+	public static class RefMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public RefMap() {
+			setSimpleConstructor(REF_MAP::new);
+			setSizeConstructor(REF_MAP::new);
+			setPArrayConstructor(REF_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(REF_MAP::new);
+#endif
+			setPMapConstructor(REF_MAP::new);
+			setMapConstructor(REF_MAP::new);
+		}
+	
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {}
+		
+			setSizeConstructor(T -> new REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {}
+		}
+	
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class LinkedRefMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public LinkedRefMap() {
+			setSimpleConstructor(LINKED_REF_MAP::new);
+			setSizeConstructor(LINKED_REF_MAP::new);
+			setPArrayConstructor(LINKED_REF_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(LINKED_REF_MAP::new);
+#endif
+			setPMapConstructor(LINKED_REF_MAP::new);
+			setMapConstructor(LINKED_REF_MAP::new);
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new LINKED_REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new LINKED_REF_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	
 #if VALUE_OBJECT
 	public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
 #else
@@ -26,6 +26,15 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
 	}

+#ignore
+	@CollectionFeature.Require(absent = KNOWN_ORDER)
+	public void testIndexedForEachUnknownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEachIndexed((K, V) -> elements.add(V));
+		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
+	}
+	
 #ignore
@CollectionFeature.Require(absent = KNOWN_ORDER)
 	public void testForEachExtraUnknownOrder() {
@@ -35,6 +44,15 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
 	}
 	
+#ignore
+	@CollectionFeature.Require(absent = KNOWN_ORDER)
+	public void testForEachExtraUnknownOrderReverse() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach((K, V) -> V.add(K), elements);
+		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
+	}
+	
 #ignore
 	@CollectionFeature.Require(KNOWN_ORDER)
 	public void testForEachKnownOrder() {
@@ -44,6 +62,15 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
 	}

+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testIndexedForEachKnownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEachIndexed((K, V) -> elements.add(V));
+		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
+	}
+	
 #ignore
 	@CollectionFeature.Require(KNOWN_ORDER)
 	public void testForEachExtraKnownOrder() {
@@ -52,4 +79,13 @@ public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTR
 		collection.forEach(elements, LIST::add);
 		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
 	}
+
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testForEachExtraKnownOrderReverse() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach((K, V) -> V.add(K), elements);
+		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
+	}
 }
@@ -4,6 +4,12 @@ package speiger.src.testers.PACKAGE.tests.iterable;
 import java.util.Objects;

 #endif
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#else
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
+#endif
+
 import org.junit.Ignore;

 import com.google.common.collect.testing.features.CollectionSize;
@@ -27,17 +33,17 @@ public class FILE_KEY_TYPEIterableFindFirstTester KEY_GENERIC_TYPE extends ABSTR
 	@CollectionSize.Require(absent = CollectionSize.ZERO)
 #endignore
 	public void testIterableFindFirst_FindFirstElements() {
-		assertEquals("First Element should be found", e0(), container.findFirst(T -> KEY_EQUALS(T, e0())));
+		assertEquals("First Element should be found", e0(), container.findFirst(T -> KEY_EQUALS(T, e0())).SUPPLY_GET());
 	}
 	
 	public void testIterableFindFirst_FindNothing() {
-		assertEquals("No element should be found", EMPTY_KEY_VALUE, container.findFirst(T -> KEY_EQUALS(T, e4())));
+		assertEquals("No element should be found", OPTIONAL.empty(), container.findFirst(T -> KEY_EQUALS(T, e4())));
 	}
 	
 #ignore
 	@CollectionSize.Require(CollectionSize.SEVERAL)
 #endignore
 	public void testIterableFindFirst_FindLastElement() {
-		assertEquals("Last Element should be found", e2(), container.findFirst(T -> KEY_EQUALS(T, e2())));
+		assertEquals("Last Element should be found", e2(), container.findFirst(T -> KEY_EQUALS(T, e2())).SUPPLY_GET());
 	}
 }
@@ -3,9 +3,16 @@ package speiger.src.testers.PACKAGE.tests.iterable;
 #if TYPE_OBJECT
 import java.util.Objects;

+#endif
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#else
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 #endif
 import org.junit.Ignore;

+import com.google.common.collect.testing.features.CollectionSize;
+
 import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;

@Ignore
@@ -29,7 +36,7 @@ public class FILE_KEY_TYPEIterableReduceTester KEY_GENERIC_TYPE extends ABSTRACT
 	}
 	
 	public void testIterableReduce() {
-		assertEquals("The sum of the collection should match", getSum(), collection.reduce(this::sum));
+		assertEquals("The sum of the collection should match", size == CollectionSize.ZERO ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(getSum()), collection.reduce(this::sum));
 	}
 	
 	public void testIterableExtraReduce() {
@@ -27,6 +27,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY

 #ignore
 	@CollectionSize.Require(absent = ZERO)
+	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testContainsObject_yes() {
 		assertTrue("contains(present) should return true", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e0())));
@@ -36,6 +37,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY
 		assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(e3()));
 	}
 	
+	@SuppressWarnings("unlikely-arg-type")
 	public void testContainsObject_no() {
 		assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e3())));
 	}
@@ -136,6 +136,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC
 #ignore
 	@CollectionSize.Require(ONE)
 	@MapFeature.Require(SUPPORTS_REMOVE)
+	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testRemove_supportedObjectEntryPresent() {
 		assertTrue(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e0())));
@@ -154,6 +155,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC
 #ignore
 	@CollectionSize.Require(ONE)
 	@MapFeature.Require(SUPPORTS_REMOVE)
+	@SuppressWarnings("unlikely-arg-type")
 #endignore
 	public void testRemove_supportedObjectEntryMissing() {
 		assertFalse(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e3())));
@@ -0,0 +1,118 @@
+package speiger.src.testers.PACKAGE.tests.maps;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT;
+import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_REMOVE;
+import static org.junit.Assert.assertNotEquals;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.MapFeature;
+
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.testers.PACKAGE.tests.base.maps.ABSTRACT_MAP_TESTER;
+import speiger.src.testers.objects.utils.ObjectHelpers;
+
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP_TESTER KEY_VALUE_GENERIC_TYPE
+{
+	private ORDERED_MAP KEY_VALUE_GENERIC_TYPE orderedMap;
+	private ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> values;
+	private KEY_TYPE a;
+	private VALUE_TYPE aValue;
+	
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+		orderedMap = (ORDERED_MAP KEY_VALUE_GENERIC_TYPE)getMap();
+		values = ObjectHelpers.copyToList(getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
+		if (values.size() >= 1) {
+			a = values.get(0).ENTRY_KEY();
+			aValue = values.get(0).ENTRY_VALUE();
+		}
+	}
+	
+#ignore
+	@MapFeature.Require(SUPPORTS_PUT)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testPutFirst() {
+		assertEquals(aValue, orderedMap.putFirst(a, v3()));
+		assertNotEquals(v3(), orderedMap.FIRST_ENTRY_VALUE());
+		assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putFirst(k4(), v4()));
+		assertEquals(v4(), orderedMap.FIRST_ENTRY_VALUE());
+		assertEquals(e4(), orderedMap.firstEntry());
+	}
+	
+
+#ignore
+	@MapFeature.Require(SUPPORTS_PUT)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testPutLast() {
+		assertEquals(aValue, orderedMap.putLast(a, v3()));
+		assertNotEquals(v3(), orderedMap.LAST_ENTRY_VALUE());
+		assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putLast(k4(), v4()));
+		assertEquals(v4(), orderedMap.LAST_ENTRY_VALUE());
+		assertEquals(e4(), orderedMap.lastEntry());
+	}
+	
+#ignore
+	@MapFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(CollectionSize.ONE)
+#endignore
+	public void testPollFirst() {
+		assertFalse(orderedMap.isEmpty());
+		assertEquals(e0(), orderedMap.pollFirstEntry());
+		assertTrue(orderedMap.isEmpty());
+	}
+	
+#ignore
+	@MapFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(CollectionSize.ONE)
+#endignore
+	public void testPollLast() {
+		assertFalse(orderedMap.isEmpty());
+		assertEquals(e0(), orderedMap.pollLastEntry());
+		assertTrue(orderedMap.isEmpty());
+	}
+	
+#ignore
+	@MapFeature.Require(absent = SUPPORTS_PUT)
+#endignore
+	public void testUnsupportedPutFirst() {
+		try { orderedMap.putFirst(a, aValue); }
+		catch (UnsupportedOperationException tolerated) {}
+		expectUnchanged();
+	}
+	
+#ignore
+	@MapFeature.Require(absent = SUPPORTS_PUT)
+#endignore
+	public void testUnsupportedPutLast() {
+		try { orderedMap.putLast(a, aValue); }
+		catch (UnsupportedOperationException tolerated) {}
+		expectUnchanged();
+	}
+	
+#ignore
+	@MapFeature.Require(absent = SUPPORTS_REMOVE)
+#endignore
+	public void testUnsupportedPollFirst() {
+		try { orderedMap.pollFirstEntry(); }
+		catch (UnsupportedOperationException tolerated) {}
+		expectUnchanged();
+	}
+	
+#ignore
+	@MapFeature.Require(absent = SUPPORTS_REMOVE)
+#endignore
+	public void testUnsupportedPollLast() {
+		try { orderedMap.pollFirstEntry(); }
+		catch (UnsupportedOperationException tolerated) {}
+		expectUnchanged();
+	}
+}
@@ -2,6 +2,11 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators;

 #if TYPE_OBJECT
 import java.util.Objects;
+#endif
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#else
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;

 #endif
 import org.junit.Ignore;
@@ -27,17 +32,17 @@ public class FILE_KEY_TYPEQueueFindFirstTester KEY_GENERIC_TYPE extends ABSTRACT
 	@CollectionSize.Require(absent = CollectionSize.ZERO)
 #endignore
 	public void testQueueFindFirst_FindFirstElements() {
-		assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0())));
+		assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0())).SUPPLY_GET());
 	}
 	
 	public void testQueueFindFirst_FindNothing() {
-		assertEquals("No element should be found", EMPTY_KEY_VALUE, queue.findFirst(T -> KEY_EQUALS(T, e4())));
+		assertEquals("No element should be found", OPTIONAL.empty(), queue.findFirst(T -> KEY_EQUALS(T, e4())));
 	}
 	
 #ignore
 	@CollectionSize.Require(CollectionSize.SEVERAL)
 #endignore
 	public void testQueueFindFirst_FindLastElement() {
-		assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2())));
+		assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2())).SUPPLY_GET());
 	}
 }
@@ -3,10 +3,16 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators;
 #if TYPE_OBJECT
 import java.util.Objects;

+#endif
+#if JDK_TYPE
+import java.util.OPTIONAL;
+#else
+import speiger.src.collections.PACKAGE.functions.OPTIONAL;
 #endif
 import org.junit.Ignore;

 import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_QUEUE_TESTER;
+import com.google.common.collect.testing.features.CollectionSize;

@Ignore
@SuppressWarnings("javadoc")
@@ -29,7 +35,7 @@ public class FILE_KEY_TYPEQueueReduceTester KEY_GENERIC_TYPE extends ABSTRACT_QU
 	}
 	
 	public void testQueueReduce() {
-		assertEquals("The sum of the queue should match", getSum(), queue.reduce(this::sum));
+		assertEquals("The sum of the queue should match", size == CollectionSize.ZERO ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(getSum()), queue.reduce(this::sum));
 	}
 	
 	public void testQueueExtraReduce() {
@@ -12,6 +12,9 @@ import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.SetFeature;
 import com.google.common.collect.testing.features.Feature;
 #if TYPE_OBJECT
+import com.google.common.collect.testing.testers.CollectionAddTester;
+import com.google.common.collect.testing.testers.CollectionAddAllTester;
+import com.google.common.collect.testing.testers.CollectionCreationTester;
 import com.google.common.collect.testing.features.CollectionFeature;
 #endif
 import junit.framework.Test;
@@ -122,6 +125,9 @@ public class SET_TESTS extends TestCase
 #ignore
 			.withFeatures(getSizes(size)).withFeatures(features);
 		if(nullValues) builder.withFeatures(CollectionFeature.ALLOWS_NULL_VALUES);
+		builder.suppressing(CollectionAddTester.getAddNullUnsupportedMethod(), CollectionAddTester.getAddNullSupportedMethod());
+		builder.suppressing(CollectionAddAllTester.getAddAllNullUnsupportedMethod());
+		builder.suppressing(CollectionCreationTester.getCreateWithNullUnsupportedMethod());
 #endignore
 		return builder.createTestSuite();
 	}
@@ -41,6 +41,8 @@ import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
 #if TYPE_OBJECT
 import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.reference.REF_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.reference.LINKED_REF_MAP;
 #endif
 import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
@@ -104,6 +106,7 @@ public class MAP_TESTS extends TestCase
 #if TYPE_OBJECT
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.EnumMap.class));
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.LinkedEnumMap.class));
+		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.RefMap.class));
 #endif
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.CustomHashMap.class));
 		constructors.addTest(new TestSuite(MAP_CONSTRUCTOR_TESTS.LinkedCustomHashMap.class));
@@ -130,27 +133,29 @@ public class MAP_TESTS extends TestCase
 	}
 	
 	public static void suite(TestSuite suite) {
-		suite.addTest(mapSuite("HASH_MAP", HASH_MAP::new, getFeatures(), -1, true));
-		suite.addTest(orderedMapSuite("LINKED_HASH_MAP", LINKED_HASH_MAP::new, getFeatures(), -1));
-		suite.addTest(orderedMapSuite("IMMUTABLE_HASH_MAP", IMMUTABLE_HASH_MAP::new, getImmutableFeatures(), -1));
+		suite.addTest(mapSuite("HASH_MAP", HASH_MAP::new, getFeatures(), -1, true, true));
+		suite.addTest(orderedMapSuite("LINKED_HASH_MAP", LINKED_HASH_MAP::new, getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("IMMUTABLE_HASH_MAP", IMMUTABLE_HASH_MAP::new, getImmutableFeatures(), -1, true));
 #if TYPE_OBJECT
 		suite.addTest(enumMapSuite("ENUM_MAP", ENUM_MAP::new, getFeatures(), 5));
 		suite.addTest(enumOrderedMapSuite("LINKED_ENUM_MAP", (K, V) -> K.length <= 0 ? new LINKED_ENUM_MAP<>(AnEnum.class) : new LINKED_ENUM_MAP<>(K, V), getFeatures(), 5));
+		suite.addTest(mapSuite("REF_MAP", REF_MAP::new, getFeatures(), - 1, true, false));
+		suite.addTest(orderedMapSuite("LINKED_REF_MAP", LINKED_REF_MAP::new, getFeatures(), - 1, false));
 #endif
-		suite.addTest(mapSuite("CUSTOM_HASH_MAP", (K, V) -> new CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true));
-		suite.addTest(orderedMapSuite("LINKED_CUSTOM_HASH_MAP", (K, V) -> new LINKED_CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1));
-		suite.addTest(orderedMapSuite("ARRAY_MAP", ARRAY_MAP::new, getFeatures(), -1));
+		suite.addTest(mapSuite("CUSTOM_HASH_MAP", (K, V) -> new CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true, true));
+		suite.addTest(orderedMapSuite("LINKED_CUSTOM_HASH_MAP", (K, V) -> new LINKED_CUSTOM_HASH_MAPKV_BRACES(K, V, HashStrategy.INSTANCE), getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("ARRAY_MAP", ARRAY_MAP::new, getFeatures(), -1, true));
 		suite.addTest(concurrentMapSuite("CONCURRENT_HASH_MAP", CONCURRENT_HASH_MAP::new, getFeatures(), 2));
 		suite.addTest(concurrentMapSuite("CONCURRENT_HASH_MAP", CONCURRENT_HASH_MAP::new, getFeatures(), 3));
 		suite.addTest(navigableMapSuite("RB_TREE_MAP", RB_TREE_MAP::new, getFeatures(), -1));
 		suite.addTest(navigableMapSuite("AVL_TREE_MAP", AVL_TREE_MAP::new, getFeatures(), -1));
 		suite.addTest(navigableMapSuite("SynchronizedRB_TREE_MAP", (K, V) -> new RB_TREE_MAPKV_BRACES(K, V).synchronize(), getLimitedFeatures(), -1));
 		suite.addTest(navigableMapSuite("UnmodifiableRB_TREE_MAP", (K, V) -> new RB_TREE_MAPKV_BRACES(K, V).unmodifiable(), getLimitedImmutableFeatures(), -1));
-		suite.addTest(orderedMapSuite("SynchronizedORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).synchronize(), getFeatures(), -1));
-		suite.addTest(orderedMapSuite("UnmodifiableORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).unmodifiable(), getImmutableFeatures(), -1));
-		suite.addTest(mapSuite("EmptyMAP", (K, V) -> MAPS.empty(), getEmptyFeatures(), 0, false));
-		suite.addTest(mapSuite("SingletonMAP", (K, V) -> MAPS.singleton(K[0], V[0]), getEmptyFeatures(), 1, false));
-		suite.addTest(mapSuite("AbstractMap", SIMPLE_TEST_MAP::new, getTestFeatures(), -1, false));
+		suite.addTest(orderedMapSuite("SynchronizedORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).synchronize(), getFeatures(), -1, true));
+		suite.addTest(orderedMapSuite("UnmodifiableORDERED_MAP", (K, V) -> new LINKED_HASH_MAPKV_BRACES(K, V).unmodifiable(), getImmutableFeatures(), -1, true));
+		suite.addTest(mapSuite("EmptyMAP", (K, V) -> MAPS.empty(), getEmptyFeatures(), 0, false, true));
+		suite.addTest(mapSuite("SingletonMAP", (K, V) -> MAPS.singleton(K[0], V[0]), getEmptyFeatures(), 1, false, true));
+		suite.addTest(mapSuite("AbstractMap", SIMPLE_TEST_MAP::new, getTestFeatures(), -1, false, true));
 	}
 	
 #if TYPE_OBJECT
@@ -209,14 +214,14 @@ public class MAP_TESTS extends TestCase
 	
 #endif
 	
-	private static Test mapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean sorted) {
+	private static Test mapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean sorted, boolean allowNullKeys) {
 		SIMPLE_MAP_TEST_GENERATOR.Maps KEY_VALUE_STRING_GENERIC_TYPE generator = new SIMPLE_MAP_TEST_GENERATOR.Maps KEY_VALUE_STRING_GENERIC_TYPE(factory);
 		MAP_TEST_BUILDER KEY_VALUE_STRING_GENERIC_TYPE builder = MAP_TEST_BUILDER.using(generator);
 		builder.shouldBlockKeys(sorted);
 #if TYPE_OBJECT
 		generator.setKeys(createKeys());
 #ignore
-		builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
+		if(allowNullKeys) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
 #endignore
 #endif
 #if VALUE_OBJECT
@@ -265,13 +270,13 @@ public class MAP_TESTS extends TestCase
 		return builder.named(name).createTestSuite();
 	}
 	
-	private static Test orderedMapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], ORDERED_MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size) {
+	private static Test orderedMapSuite(String name, BiFunction<KEY_STRING_TYPE[], VALUE_STRING_TYPE[], ORDERED_MAP KEY_VALUE_STRING_GENERIC_TYPE> factory, Collection<Feature<?>> features, int size, boolean allowNullKeys) {
 		SIMPLE_MAP_TEST_GENERATOR.OrderedMaps KEY_VALUE_STRING_GENERIC_TYPE generator = new SIMPLE_MAP_TEST_GENERATOR.OrderedMaps KEY_VALUE_STRING_GENERIC_TYPE(factory);
 		ORDERED_MAP_TEST_BUILDER KEY_VALUE_STRING_GENERIC_TYPE builder = ORDERED_MAP_TEST_BUILDER.using(generator);
 #if TYPE_OBJECT
 		generator.setKeys(createKeys());
 #ignore
-		builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
+		if(allowNullKeys) builder.withFeatures(MapFeature.ALLOWS_NULL_KEYS);
 #endignore
 #endif
 #if VALUE_OBJECT
@@ -1,318 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Collection;
-import java.util.function.Supplier;
-import java.util.Objects;
-import java.util.AbstractCollection;
-
-import speiger.src.collections.booleans.lists.BooleanListIterator;
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.utils.BooleanIterators;
-import speiger.src.collections.booleans.utils.BooleanArrays;
-
-/**
- * Abstract Type Specific Collection that reduces boxing/unboxing
- */
-public abstract class AbstractBooleanCollection extends AbstractCollection<Boolean> implements BooleanCollection
-{
-	@Override
-	public abstract BooleanIterator iterator();
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean add(Boolean e) { return BooleanCollection.super.add(e); }
-
-	@Override
-	public boolean addAll(BooleanCollection c) {
-		boolean modified = false;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();modified |= add(iter.nextBoolean()));
-		return modified;
-	}
-	
-	@Override
-	public BooleanCollection copy() { throw new UnsupportedOperationException(); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean contains(Object e) { return BooleanCollection.super.contains(e); }
-	
-	/**
-	 * A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
-	 * @param e the element that should be searched for.
-	 * @return true if the value was found.
-	 */
-	@Override
-	public boolean contains(boolean e) {
-		for(BooleanIterator iter = iterator();iter.hasNext();) { if(iter.nextBoolean() == e) return true; }
-		return false;
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean addAll(Collection<? extends Boolean> c)
-	{
-		return c instanceof BooleanCollection ? addAll((BooleanCollection)c) : super.addAll(c);
-	}
-	
-	/**
-	 * A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
-	 * @param c the collection that should be checked if it contains all elements.
-	 * @return true if all elements were found in the collection
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean containsAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return true;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();)
-			if(!contains(iter.nextBoolean()))
-				return false;
-		return true;
-	}
-	
-	@Override
-	public boolean containsAll(Collection<?> c) {
-		Objects.requireNonNull(c);
-		return c instanceof BooleanCollection ? containsAll((BooleanCollection)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
-	 * @return true if any element is in this collection
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	@Deprecated
-	public boolean containsAny(Collection<?> c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		for(Object e : c) 
-			if(contains(e))
-				return true;
-		return false;
-	}
-	
-	/**
-	 * 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
-	 * @return true if any element is in this collection
- 	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean containsAny(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		for(BooleanIterator iter = c.iterator();iter.hasNext();) 
-			if(contains(iter.nextBoolean()))
-				return true;
-		return false;
-	}
-		
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public boolean remove(Object e) { return BooleanCollection.super.remove(e); }
-	
-	/**
-	 * 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.
-	 * It stops after finding the first element
-	 * @param e the element that is searched for
-	 * @return true if the element was found and removed.
-	 */
-	@Override
-	public boolean remBoolean(boolean e) {
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(iter.nextBoolean() == e) {
-				iter.remove();
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	/**
-	 * A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
-	 * @param c the elements that should be deleted
-	 * @return true if the collection was modified.
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean removeAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(c.contains(iter.nextBoolean())) {
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-
-	@Override
-	public boolean removeAll(BooleanCollection c, BooleanConsumer r) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) return false;
-		Objects.requireNonNull(r);
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean e = iter.nextBoolean();
-			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
-	 * @return true if the collection was modified.
-	 * @throws java.lang.NullPointerException if the collection is null
-	 */
-	@Override
-	public boolean retainAll(BooleanCollection c) {
-		Objects.requireNonNull(c);
-		if(c.isEmpty()) {
-			boolean modified = !isEmpty();
-			clear();
-			return modified;
-		}
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(!c.contains(iter.nextBoolean())) {
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-	
-	@Override
-	public boolean retainAll(BooleanCollection c, BooleanConsumer r) {
-		Objects.requireNonNull(c);
-		Objects.requireNonNull(r);
-		if(c.isEmpty()) {
-			boolean modified = !isEmpty();
-			forEach(r);
-			clear();
-			return modified;
-		}
-		boolean modified = false;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean e = iter.nextBoolean();
-			if(!c.contains(e)) {
-				r.accept(e);
-				iter.remove();
-				modified = true;
-			}
-		}
-		return modified;
-	}
-	
-	/**
-	 * A Type-Specific implementation of toArray that links to {@link #toBooleanArray(boolean[])} with a newly created array.
-	 * @return an array containing all of the elements in this collection
-	 */
-	@Override
-	public boolean[] toBooleanArray() {
-		if(isEmpty()) return BooleanArrays.EMPTY_ARRAY;
-		return toBooleanArray(new boolean[size()]);
-	}
-	
-	/**
-	 * A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	 * @return an array containing all of the elements in this collection
-	 */
-	@Override
-	public boolean[] toBooleanArray(boolean[] a) {
-		if(a == null || a.length < size()) a = new boolean[size()];
-		BooleanIterators.unwrap(a, iterator());
-		if (a.length > size()) a[size()] = false;
-		return a;
-	}
-
-	public static class ReverseBooleanOrderedCollection extends AbstractBooleanCollection implements BooleanOrderedCollection {
-		BooleanOrderedCollection collection;
-		Supplier<BooleanIterator> reverseIterator;
-		
-		public ReverseBooleanOrderedCollection(BooleanOrderedCollection collection, Supplier<BooleanIterator> reverseIterator) {
-			this.collection = collection;
-			this.reverseIterator = reverseIterator;
-		}
-		
-		@Override
-		public boolean add(boolean o) { return collection.add(o); }
-		@Override
-		public BooleanOrderedCollection reversed() { return collection; }
-		@Override
-		public void addFirst(boolean e) { collection.addLast(e); }
-		@Override
-		public void addLast(boolean e) { collection.addFirst(e); }
-		@Override
-		public boolean contains(boolean e) { return collection.contains(e); }
-		@Override
-		public boolean remBoolean(boolean e) { return collection.remBoolean(e); }
-		@Override
-		public void clear() { collection.clear(); }
-		@Override
-		public boolean getFirstBoolean() { return collection.getLastBoolean(); }
-		@Override
-		public boolean removeFirstBoolean() { return collection.removeLastBoolean(); }
-		@Override
-		public boolean getLastBoolean() { return collection.getFirstBoolean(); }
-		@Override
-		public boolean removeLastBoolean() { return collection.removeFirstBoolean(); }
-		@Override
-		public BooleanIterator iterator() { return reverseIterator.get(); }
-		@Override
-		public int size() { return collection.size(); }
-	}
-	
-	public static class ReverseBiIterator implements BooleanListIterator {
-		BooleanListIterator it;
-		
-		public ReverseBiIterator(BooleanListIterator it) {
-			this.it = it;
-		}
-		
-		@Override
-		public boolean nextBoolean() { return it.previousBoolean(); }
-		@Override
-		public boolean hasNext() { return it.hasPrevious(); }
-		@Override
-		public boolean hasPrevious() { return it.hasNext(); }
-		@Override
-		public boolean previousBoolean() { return it.nextBoolean(); }
-		@Override
-		public void remove() { it.remove(); }
-		@Override
-		public int nextIndex() { return it.previousIndex(); }
-		@Override
-		public int previousIndex() { return it.nextIndex(); }
-		@Override
-		public void set(boolean e) { it.set(e); }
-		@Override
-		public void add(boolean e) { it.add(e); }
-	}
-}
@@ -1,52 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-/**
- * This is a basically a {@link java.util.ListIterator} without the index functions.
- * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index.
- */
-public interface BooleanBidirectionalIterator extends BooleanIterator
-{
-	/**
-	 * Returns true if the Iterator has a Previous element
-	 * @return true if the Iterator has a Previous element
-	 */
-	public boolean hasPrevious();
-	
-	/**
-	 * Returns the Previous element of the iterator.
-	 * @return the Previous element of the iterator.
- 	 * @throws java.util.NoSuchElementException if the iteration has no more elements
-	 */
-	public boolean previousBoolean();
-	
-	/**
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 * @return the Previous element of the iterator.+
-	 */
-	@Deprecated
-	public default Boolean previous() {
-		return Boolean.valueOf(previousBoolean());
-	}
-	
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	default int skip(int amount)
-	{
-		return BooleanIterator.super.skip(amount);
-	}
-	
-	/**
-	 * Reverses the Given amount of elements if possible. A Optimization function to reverse elements faster if the implementation allows it.
-	 * @param amount the amount of elements that should be reversed
-	 * @return the amount of elements that were reversed
-	 */
-	public default int back(int amount) {
-		if(amount < 0) throw new IllegalStateException("Can't go forward");
-		int i = 0;
-		for(;i<amount && hasPrevious();previousBoolean(),i++);
-		return i;
-	}
-}
@@ -1,231 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Collection;
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.utils.BooleanSplititerators;
-import speiger.src.collections.booleans.utils.BooleanCollections;
-import speiger.src.collections.utils.ISizeProvider;
-import speiger.src.collections.utils.SanityChecks;
-
-/**
- * A Type-Specific {@link Collection} that reduces (un)boxing
- */
-public interface BooleanCollection extends Collection<Boolean>, BooleanIterable, ISizeProvider
-{
-	/**
-	 * A Type-Specific add function to reduce (un)boxing
-	 * @param o the element that should be added
-	 * @return true if the element was added to the collection
-	 */
-	public boolean add(boolean o);
-	
-	/**
-	 * A Type-Specific addAll function to reduce (un)boxing
-	 * @param c the collection of elements that should be added
-	 * @return true if elements were added into the collection
-	 */
-	public boolean addAll(BooleanCollection c);
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean... e) { return addAll(e, 0, e.length); }
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean[] e, int length) { return addAll(e, 0, length); }
-	
-	/**
-	 * A Type-Specific Array based addAll method to reduce the amount of Wrapping
-	 * @param e the elements that should be added
-	 * @param offset where to start within the array
-	 * @param length how many elements of the array should be added
-	 * @return if the collection was modified
-	 */
-	public default boolean addAll(boolean[] e, int offset, int length) {
-		if(length <= 0) return false;
-		SanityChecks.checkArrayCapacity(e.length, offset, length);
-		boolean added = false;
-		for(int i = 0;i<length;i++) {
-			if(add(e[offset+i])) added = true;
-		}
-		return added;
-	}
-	
-	/**
-	 * A Type-Specific contains function to reduce (un)boxing
-	 * @param o the element that is checked for
-	 * @return true if the element is found in the collection
-	 */
-	public boolean contains(boolean o);
-	
-	/**
- 	 * A Type-Specific containsAll function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
- 	 * @return true if all the element is found in the collection
- 	 */
-	public boolean containsAll(BooleanCollection c);
-	
-	/**
-	 * A Type-Specific containsAny function to reduce (un)boxing
- 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found
-	 */
-	public boolean containsAny(BooleanCollection c);
-	
-	/**
-	 * Returns true if any element of the Collection is found in the provided collection.
-	 * A Small Optimization function to find out of any element is present when comparing collections and not all of them.
- 	 * @param c the collection of elements that should be tested for
-	 * @return true if any element was found.
-	 */
-	@Deprecated
-	public boolean containsAny(Collection<?> c);
-	
-	/**
-	 * A Type-Specific remove function that reduces (un)boxing.
-	 * @param o the element that should be removed
-	 * @return true if the element was removed
-	 * @see Collection#remove(Object)
-	 */
-	public boolean remBoolean(boolean o);
-	
-	/**
-	 * A Type-Specific removeAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be removed
-	 * @return true if any element was removed
-	 * @see Collection#removeAll(Collection)
-	 */
-	public boolean removeAll(BooleanCollection 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(BooleanCollection c, BooleanConsumer r);
-	
-	/**
- 	 * A Type-Specific retainAll function that reduces (un)boxing.
-	 * @param c the collection of elements that should be kept
- 	 * @return true if any element was removed
- 	 * @see Collection#retainAll(Collection)
- 	 */
-	public boolean retainAll(BooleanCollection 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(BooleanCollection c, BooleanConsumer 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 BooleanCollection> 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.
-	 * It can be compared to Cloneable but with less exception risk
-	 * @return a Shallow Copy of the collection
-	 * @note Wrappers and view collections will not support this feature
-	 */
-	public BooleanCollection copy();
-	
-	/**
-	 * A Type-Specific toArray function that delegates to {@link #toBooleanArray(boolean[])} with a newly created array.
-	 * @return an array containing all of the elements in this collection
-	 * @see Collection#toArray()
-	 */
-	public boolean[] toBooleanArray();
-	
-	/**
-	 * A Type-Specific toArray function that reduces (un)boxing.
-	 * @param a array that the elements should be injected to. If null or to small a new array with the right size is created
-	 * @return an array containing all of the elements in this collection
-	 * @see Collection#toArray(Object[])
-	 */
-	public boolean[] toBooleanArray(boolean[] a);
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public default boolean add(Boolean o) { return add(o.booleanValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	public default boolean contains(Object o) { return o != null && contains(((Boolean)o).booleanValue()); }
-	
-	/** {@inheritDoc}
- 	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	public default boolean remove(Object o) { return o != null && remBoolean(((Boolean)o).booleanValue()); }
-	
-	/**
-	 * Returns a Type-Specific Iterator to reduce (un)boxing
-	 * @return a iterator of the collection
-	 * @see Collection#iterator()
-	 */
-	@Override
-	public BooleanIterator iterator();
-	
-	/**
-	 * Creates a Wrapped Collection that is Synchronized
-	 * @return a new Collection that is synchronized
-	 * @see BooleanCollections#synchronize
-	 */
-	public default BooleanCollection synchronize() { return BooleanCollections.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 BooleanCollections#synchronize
-	 */
-	public default BooleanCollection synchronize(Object mutex) { return BooleanCollections.synchronize(this, mutex); }
-	
-	/**
-	 * Creates a Wrapped Collection that is unmodifiable
-	 * @return a new Collection Wrapper that is unmodifiable
-	 * @see BooleanCollections#unmodifiable
-	 */
-	public default BooleanCollection unmodifiable() { return BooleanCollections.unmodifiable(this); }
-	
-
-	/**
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
-	 * @return type specific splititerator
-	 */
-	@Override
-	default BooleanSplititerator spliterator() { return BooleanSplititerators.createSplititerator(this, 0); }
-}
@@ -1,333 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Objects;
-import java.util.function.Consumer;
-
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-import speiger.src.collections.booleans.functions.BooleanComparator;
-import speiger.src.collections.objects.collections.ObjectIterable;
-import speiger.src.collections.booleans.functions.function.BooleanFunction;
-import speiger.src.collections.ints.functions.consumer.IntBooleanConsumer;
-import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer;
-import speiger.src.collections.booleans.functions.function.BooleanPredicate;
-import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator;
-import speiger.src.collections.booleans.lists.BooleanList;
-import speiger.src.collections.booleans.lists.BooleanArrayList;
-import speiger.src.collections.booleans.utils.BooleanArrays;
-import speiger.src.collections.booleans.utils.BooleanAsyncBuilder;
-import speiger.src.collections.booleans.utils.BooleanSplititerators;
-import speiger.src.collections.booleans.utils.BooleanIterables;
-import speiger.src.collections.booleans.utils.BooleanIterators;
-import speiger.src.collections.utils.ISizeProvider;
-
-/**
- * A Type-Specific {@link Iterable} that reduces (un)boxing
- */
-public interface BooleanIterable extends Iterable<Boolean>
-{
-	/**
-	 * Returns an iterator over elements of type {@code T}.
-	 *
-	 * @return an Iterator.
-	 */
-	@Override
-	BooleanIterator iterator();
-	
-	/**
-	 * A Type Specific foreach function that reduces (un)boxing
-	 * 
-	 * @implSpec
-	 * <p>The default implementation behaves as if:
-	 * <pre>{@code
-	 *	iterator().forEachRemaining(action);
-	 * }</pre>
-	 *
-	 * @param action The action to be performed for each element
-	 * @throws NullPointerException if the specified action is null
-	 * @see Iterable#forEach(Consumer)
-	 */
-	default void forEach(BooleanConsumer action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(action);
-	}
-	
-	/** {@inheritDoc}
-	* <p>This default implementation delegates to the corresponding type-specific function.
-	* @deprecated Please use the corresponding type-specific function instead. 
-	*/
-	@Deprecated
-	@Override
-	default void forEach(Consumer<? super Boolean> action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(action);
-	}
-	
-	/**
-	 * A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
-	 * @param action The action to be performed for each element
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	public default void forEachIndexed(IntBooleanConsumer action) {
-		Objects.requireNonNull(action);
-		int index = 0;
-		for(BooleanIterator iter = iterator();iter.hasNext();action.accept(index++, iter.nextBoolean()));
-	}
-	
-	/**
-	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
-	 * @param input the object that should be included
-	 * @param action The action to be performed for each element
-	 * @param <E> the generic type of the Object
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	default <E> void forEach(E input, ObjectBooleanConsumer<E> action) {
-		Objects.requireNonNull(action);
-		iterator().forEachRemaining(input, action);
-	}
-	
-	/**
-	 * A Type Specific Type Splititerator to reduce boxing/unboxing
-	 * @return type specific splititerator
-	 */
-	@Override
-	default BooleanSplititerator spliterator() { return BooleanSplititerators.createUnknownSplititerator(iterator(), 0); }
-	
-	/**
-	 * Creates a Async Builder for moving work of the thread.
-	 * It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
-	 * @see BooleanAsyncBuilder
-	 * @return a AsyncBuilder
-	 */
-	default BooleanAsyncBuilder asAsync() {
-		return new BooleanAsyncBuilder(this);
-	}
-
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the mapping function
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 */
-	default <E> ObjectIterable<E> map(BooleanFunction<E> mapper) {
-		return BooleanIterables.map(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the flatMapping function
-	 * @param <V> The return type supplier.
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(BooleanFunction<V> mapper) {
-		return BooleanIterables.flatMap(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
-	 * @param mapper the flatMapping function
-	 * @param <E> The return type.
-	 * @return a new Iterable that returns the desired result
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default <E> ObjectIterable<E> arrayflatMap(BooleanFunction<E[]> mapper) {
-		return BooleanIterables.arrayFlatMap(this, mapper);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
-	 * @param filter the elements that should be kept.
-	 * @return a Iterable that filtered out all unwanted elements
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default BooleanIterable filter(BooleanPredicate filter) {
-		return BooleanIterables.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
-	 * @note does not support toBooleanArray optimizations.
-	 */
-	default BooleanIterable distinct() {
-		return BooleanIterables.distinct(this);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
-	 * @param repeats how many times the elements should be repeated
-	 * @return a Iterable that is repeating multiple times
-	 */
-	default BooleanIterable repeat(int repeats) {
-		return BooleanIterables.repeat(this, repeats);
-	}
-	
-	/**
-	 * 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 BooleanIterable limit(long limit) {
-		return BooleanIterables.limit(this, limit);
-	}
-	
-	/**
-	 * A Helper function to reduce the usage of Streams and allows to sort the elements
-	 * @param sorter that sorts the elements.
-	 * @return a Iterable that is sorted
-	 */
-	default BooleanIterable sorted(BooleanComparator sorter) {
-		return BooleanIterables.sorted(this, sorter);
-	}
-	
-	/**
-	 * 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 BooleanIterable peek(BooleanConsumer action) {
-		return BooleanIterables.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 BooleanCollection> E pour(E collection) {
-		BooleanIterators.pour(iterator(), collection);
-		return collection;
-	}
-	
-	/**
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
-	 * @return a new ArrayList of all elements
-	 */
-	default BooleanList pourAsList() {
-		return pour(new BooleanArrayList());
-	}
-	
-	/**
-	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
-	 * @return a new Array of all elements
-	 */
-	default boolean[] toBooleanArray() {
-		ISizeProvider prov = ISizeProvider.of(this);
-		if(prov != null) {
-			int size = prov.size();
-			if(size >= 0) {
-				boolean[] array = new boolean[size];
-				BooleanIterators.unwrap(array, iterator());
-				return array;
-			}
-		}
-		return BooleanArrays.pour(iterator());
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for any matches.
-	 * @param filter that should be applied
-	 * @return true if any matches were found
-	 */
-	default boolean matchesAny(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) return true;
-		}
-		return false;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for no matches.
-	 * @param filter that should be applied
-	 * @return true if no matches were found
-	 */
-	default boolean matchesNone(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) return false;
-		}
-		return true;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for all matches.
-	 * @param filter that should be applied
-	 * @return true if all matches.
-	 */
-	default boolean matchesAll(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(!filter.test(iter.nextBoolean())) return false;
-		}
-		return true;
-	}
-	
-	/**
-	 * Helper function to reduce stream usage that allows to filter for the first match.
-	 * @param filter that should be applied
-	 * @return the found value or the null equivalent variant.
-	 */
-	default boolean findFirst(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			boolean entry = iter.nextBoolean();
-			if(filter.test(entry)) return entry;
-		}
-		return false;
-	}
-	
-	/**
-	 * 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 boolean reduce(boolean identity, BooleanBooleanUnaryOperator operator) {
-		Objects.requireNonNull(operator);
-		boolean state = identity;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			state = operator.applyAsBoolean(state, iter.nextBoolean());
-		}
-		return state;
-	}
-	
-	/**
-	 * 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 boolean reduce(BooleanBooleanUnaryOperator operator) {
-		Objects.requireNonNull(operator);
-		boolean state = false;
-		boolean empty = true;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(empty) {
-				empty = false;
-				state = iter.nextBoolean();
-				continue;
-			}
-			state = operator.applyAsBoolean(state, iter.nextBoolean());
-		}
-		return state;
-	}	
-	
-	/**
-	 * Helper function to reduce stream usage that allows to count the valid elements.
-	 * @param filter that should be applied
-	 * @return the amount of Valid Elements
-	 */
-	default int count(BooleanPredicate filter) {
-		Objects.requireNonNull(filter);
-		int result = 0;
-		for(BooleanIterator iter = iterator();iter.hasNext();) {
-			if(filter.test(iter.nextBoolean())) result++;
-		}
-		return result;
-	}
-}
@@ -1,88 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Iterator;
-import java.util.Objects;
-import java.util.function.Consumer;
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-
-import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer;
-
-/**
- * A Type-Specific {@link Iterator} that reduces (un)boxing
- */
-public interface BooleanIterator extends Iterator<Boolean>
-{
-	/**
- 	* Returns the next element in the iteration.
- 	*
- 	* @return the next element in the iteration
- 	* @throws java.util.NoSuchElementException if the iteration has no more elements
- 	* @see Iterator#next()
- 	*/
-	public boolean nextBoolean();
-	
-	/** {@inheritDoc}
-	* <p>This default implementation delegates to the corresponding type-specific function.
-	* @deprecated Please use the corresponding type-specific function instead. 
-	*/
-	@Override
-	@Deprecated
-	public default Boolean next() { return Boolean.valueOf(nextBoolean()); }
-	
-	/**
-	 * Performs the given action for each remaining element until all elements
-	 * have been processed or the action throws an exception.  Actions are
-	 * performed in the order of iteration, if that order is specified.
-	 * Exceptions thrown by the action are relayed to the caller.
-	 *
-	 * @implSpec
-	 * <p>The default implementation behaves as if:
-	 * <pre>{@code
-	 *	while (hasNext()) action.accept(nextBoolean());
-	 * }</pre>
-	 *
-	 * @param action The action to be performed for each element
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 * @see Iterator#forEachRemaining(Consumer)
-	 */
-	public default void forEachRemaining(BooleanConsumer action) {
-		Objects.requireNonNull(action);
-		while(hasNext()) { action.accept(nextBoolean()); }
-	}
-	
-	/** {@inheritDoc}
- 	* <p>This default implementation delegates to the corresponding type-specific function.
- 	* @deprecated Please use the corresponding type-specific function instead. 
- 	*/
-	@Deprecated
-	@Override
-	default void forEachRemaining(Consumer<? super Boolean> action) {
-		Objects.requireNonNull(action);
-		forEachRemaining(action::accept);
-	}
-	
-	/**
-	 * Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
-	 * @param input the object that should be included
-	 * @param action The action to be performed for each element
-	 * @param <E> the generic type of the Object
-	 * @throws java.lang.NullPointerException if the specified action is null
-	 */
-	default <E> void forEachRemaining(E input, ObjectBooleanConsumer<E> action) {
-		Objects.requireNonNull(action);
-		while(hasNext()) { action.accept(input, nextBoolean()); }
-	}
-	
-	/**
-	 * Skips the Given amount of elements if possible. A Optimization function to skip elements faster if the implementation allows it.
-	 * @param amount the amount of elements that should be skipped
-	 * @return the amount of elements that were skipped
-	 */
-	default int skip(int amount) {
-		if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
-		int i = 0;
-		for(;i<amount && hasNext();nextBoolean(), i++);
-		return i;
-	}
-}
@@ -1,40 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-public interface BooleanOrderedCollection extends BooleanCollection {
-	
-	BooleanOrderedCollection reversed();
-	
-	/**
-	 * A method to add an element to the start of a collection
-	 * @param e that should be added at the start.
-	 */
-	public void addFirst(boolean e);
-	
-	/**
-	 * A method to add an element to the end of a collection
-	 * @param e that should be added at the end.
-	 */
-	public void addLast(boolean e);
-	
-	/**
-	 * A method to get the first element in the collection
-	 * @return first element in the collection
-	 */
-	public boolean getFirstBoolean();
-	/**
-	 * A method to get and remove the first element in the collection
-	 * @return first element in the collection
-	 */
-	public boolean removeFirstBoolean();
-	/**
-	 * A method to get the last element in the collection
-	 * @return last element in the collection
-	 */
-	public boolean getLastBoolean();
-	/**
-	 * A method to get and remove the last element in the collection
-	 * @return last element in the collection
-	 */
-	public boolean removeLastBoolean();
-	
-}
@@ -1,19 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.Spliterator.OfPrimitive;
-import java.util.function.Consumer;
-
-import speiger.src.collections.booleans.functions.BooleanConsumer;
-
-/**
- * A Type Specific Split-Iterator that reduces boxing/unboxing
- * It fills the gaps of the java and uses this collection interfaces
- */
-public interface BooleanSplititerator extends OfPrimitive<Boolean, BooleanConsumer, BooleanSplititerator>, BooleanIterator
-{
-	@Override
-	default void forEachRemaining(BooleanConsumer action) { BooleanIterator.super.forEachRemaining(action); }
-	@Override
-	@Deprecated
-	default void forEachRemaining(Consumer<? super Boolean> action) { BooleanIterator.super.forEachRemaining(action); }
-}
@@ -1,85 +0,0 @@
-package speiger.src.collections.booleans.collections;
-
-import java.util.NoSuchElementException;
-
-import speiger.src.collections.utils.Stack;
-
-/**
- * A Type-Specific {@link Stack} that reduces (un)boxing
- */
-public interface BooleanStack
-{
-	/**
-	 * Inserts a given Object on top of the stack
-	 * @param e the Object to insert
-	 * @see Stack#push(Object)
-	 */
-	public void push(boolean e);
-	
-	/**
-	 * Helper function that pushes the top element on top of the stack again.
-	 * @throws NoSuchElementException if the stack is empty
-	 */
-	public default void pushTop() {
-		push(top());
-	}
-	
-	/**
-	 * Removes the Object on top of the stack.
-	 * @return the element that is on top of the stack
-	 * @throws ArrayIndexOutOfBoundsException if the stack is empty
-	 * @see Stack#pop()
-	 */
-	public boolean pop();
-	
-	/**
-	 * Provides the Object on top of the stack
-	 * @return the element that is on top of the stack
-	 * @throws ArrayIndexOutOfBoundsException if the stack is empty
- 	 * @see Stack#top()
-	 */
-	public default boolean top() {
-		return peek(0);
-	}
-	
-	/**
-	 * Provides the Selected Object from the stack.
-	 * Top to bottom
-	 * @param index of the element that should be provided
-	 * @return the element that was requested
- 	 * @throws ArrayIndexOutOfBoundsException if the index is out of bounds
- 	 * @see Stack#peek(int)
-	 */
-	public boolean peek(int index);
-	
-	/**
-	 * Clears the stack
-	 */
-	public void clear();
-	
-	/**
-	 * Provides the amount of elements currently in the stack
-	 * @return amount of elements in the list
-	 */
-	public int size();
-	
-	/**
-	 * @return if the stack is empty
-	 */
-	public default boolean isEmpty() {
-		return size() == 0;
-	}
-	
-	/**
-	 * A method to drop the contents of the Stack without clearing the stack
-	 * @return the contents of the stack into a seperate array.
-	 */
-	public default boolean[] toBooleanArray() { return toBooleanArray(new boolean[size()]); }
-	/**
-	 * A method to drop the contents of the Stack without clearing the stack
-	 * @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
-	 * @return the contents of the stack into a seperate array.
-	 * @note if the Type is generic then a Object Array is created instead of a Type Array
-	 */
-	public boolean[] toBooleanArray(boolean[] input);
-}
@@ -1,70 +0,0 @@
-package speiger.src.collections.booleans.functions;
-
-import java.util.Comparator;
-import java.util.Objects;
-
-/**
- * Type-Specific Class for Comparator to reduce (un)boxing
- */
-public interface BooleanComparator extends Comparator<Boolean> 
-{
-	/**
-	 * Type-Specific compare function to reduce (un)boxing
-	 * @param o1 the first object to be compared.
-	 * @param o2 the second object to be compared.
-	 * @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
-	 * @see Comparator#compare(Object, Object)
-	 */
-	int compare(boolean o1, boolean o2);
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default int compare(Boolean o1, Boolean o2) {
-		return compare(o1.booleanValue(), o2.booleanValue());
-	}
-	
-	/**
-	 * A Wrapper function to convert a Non-Type-Specific Comparator to a Type-Specific-Comparator
-	 * @param c comparator to convert
-	 * @return the wrapper of the comparator
-	 * @throws NullPointerException if the comparator is null
-	 */
-	public static BooleanComparator of(Comparator<Boolean> c) {
-		Objects.requireNonNull(c);
-		return (K, V) -> c.compare(Boolean.valueOf(K), Boolean.valueOf(V));
-	}
-	
-	@Override
-	public default BooleanComparator reversed() {
-		return new Reversed(this);
-	}
-	
-	/**
-	 * A Type Specific Reversed Comparator to reduce boxing/unboxing
-	 */
-	static class Reversed implements BooleanComparator
-	{
-		BooleanComparator original;
-		
-		/**
-		 * default constructor
-		 * @param original that is going to be reversed
-		 */
-		public Reversed(BooleanComparator original) {
-			this.original = original;
-		}
-		
-		public int compare(boolean o1, boolean o2) {
-			return original.compare(o2, o1);
-		}
-		
-		@Override
-		public BooleanComparator reversed() {
-			return original;
-		}
-	}
-}
@@ -1,48 +0,0 @@
-package speiger.src.collections.booleans.functions;
-
-import java.util.Objects;
-import java.util.function.Consumer;
-/**
- * Type-Specific Consumer interface that reduces (un)boxing and allows to merge other consumer types into this interface
- */
-@FunctionalInterface
-public interface BooleanConsumer extends Consumer<Boolean>
-{
-	/**
-	 * Type-Specific function to reduce (un)boxing. 
-	 * Performs this operation on the given argument.
-	 *
-	 * @param t the input argument
-	 */
-	void accept(boolean t);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced consumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanConsumer andThen(BooleanConsumer after) {
-		Objects.requireNonNull(after);
-		return T -> {accept(T); after.accept(T);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean t) { accept(t.booleanValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanConsumer andThen(Consumer<? super Boolean> after) {
-		Objects.requireNonNull(after);
-		return T -> {accept(T); after.accept(Boolean.valueOf(T));};
-	}
-}
@@ -1,12 +0,0 @@
-package speiger.src.collections.booleans.functions;
-
-/**
- * Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
- */
-public interface BooleanSupplier
-{
-	/**
-	 * @return the supplied value
-	 */
-	public boolean getAsBoolean();
-}
@@ -1,87 +0,0 @@
-package speiger.src.collections.booleans.functions;
-
-import java.util.concurrent.RunnableFuture;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * 
- * A Type Specific Task interface that allows you to keep track of the task that is currently running.<br>
- * It extends Runnable future and supports said functions but also provides quality of life functions like:<br>
- * 
- * - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed.
- * - pause/resume: which allows to pause/resume the task at any moment, making it easier to create thread-safe actions.
- */
-public interface BooleanTask extends RunnableFuture<Boolean> {
-	/**
-	 * Helper function to detect if the task is currently paused.
-	 * @return true if paused
-	 */
-	public boolean isPaused();
-	
-	/**
-	 * Pauses the task, which lets the thread finish without completing the task.
-	 * Tasks are written in the way where they can pause without any issues.
-	 * This won't be instant, as this function is applied asynchronous and doesn't check if the thread paused.
-	 * So make sure it had the time to pause.
-	 */
-	public void pause();
-	
-	/**
-	 * Pauses the task, which lets the thread finish without completing the task.
-	 * Tasks are written in the way where they can pause without any issues.
-	 * This won't be instant, as this function is applied asynchronous.
-	 * It will await the pausing of the task.
-	 */
-	public void awaitPausing();
-	
-	/**
-	 * Continues the task if it wasn't already completed.
-	 * This is done by resubmitting the task to the executor provided.
-	 */
-	public void resume();
-	
-	/**
-	 * Quality of life function that allows to detect if no cancellation/exception was applied to this task and it completed on its own.
-	 * @return true if it was properly completed
-	 */
-	public boolean isSuccessful();
-	
-	/**
-	 * A Type Specific get method that allows to reduce (un)boxing of primtives.
-	 * 
-	 * Waits if necessary for the computation to complete, and then
-	 * retrieves its result.
-	 *
-	 * @return the computed result as primitive
-	 * @throws CancellationException if the computation was cancelled
-	 * @throws ExecutionException if the computation threw an exception
-	 * @throws InterruptedException if the current thread was interrupted
-	 * while waiting
-	 */
-	public boolean getBoolean() throws InterruptedException, ExecutionException;
-
-	/**
-	 * Waits if necessary for at most the given time for the computation
-	 * to complete, and then retrieves its result, if available.
-	 *
-	 * @param timeout the maximum time to wait
-	 * @param unit the time unit of the timeout argument
-	 * @return the computed result as primitive
-	 * @throws CancellationException if the computation was cancelled
-	 * @throws ExecutionException if the computation threw an exception
-	 * @throws InterruptedException if the current thread was interrupted while waiting
-	 * @throws TimeoutException if the wait timed out
-	 */
-	public boolean getBoolean(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
-	
-	@Override
-	@Deprecated
-	public default Boolean get() throws InterruptedException, ExecutionException { return Boolean.valueOf(getBoolean()); }
-	
-	@Override
-	@Deprecated
-	public default Boolean get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return Boolean.valueOf(getBoolean(timeout, unit)); }
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanBooleanConsumer extends BiConsumer<Boolean, Boolean>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, boolean v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanBooleanConsumer andThen(BooleanBooleanConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Boolean v) { accept(k.booleanValue(), v.booleanValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanBooleanConsumer andThen(BiConsumer<? super Boolean, ? super Boolean> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Boolean.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanByteConsumer extends BiConsumer<Boolean, Byte>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, byte v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanByteConsumer andThen(BooleanByteConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Byte v) { accept(k.booleanValue(), v.byteValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanByteConsumer andThen(BiConsumer<? super Boolean, ? super Byte> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Byte.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanCharConsumer extends BiConsumer<Boolean, Character>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, char v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanCharConsumer andThen(BooleanCharConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Character v) { accept(k.booleanValue(), v.charValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanCharConsumer andThen(BiConsumer<? super Boolean, ? super Character> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Character.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanDoubleConsumer extends BiConsumer<Boolean, Double>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, double v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanDoubleConsumer andThen(BooleanDoubleConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Double v) { accept(k.booleanValue(), v.doubleValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanDoubleConsumer andThen(BiConsumer<? super Boolean, ? super Double> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Double.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanFloatConsumer extends BiConsumer<Boolean, Float>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, float v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanFloatConsumer andThen(BooleanFloatConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Float v) { accept(k.booleanValue(), v.floatValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanFloatConsumer andThen(BiConsumer<? super Boolean, ? super Float> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Float.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanIntConsumer extends BiConsumer<Boolean, Integer>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, int v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanIntConsumer andThen(BooleanIntConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Integer v) { accept(k.booleanValue(), v.intValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanIntConsumer andThen(BiConsumer<? super Boolean, ? super Integer> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Integer.valueOf(V));};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanLongConsumer extends BiConsumer<Boolean, Long>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, long v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanLongConsumer andThen(BooleanLongConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Long v) { accept(k.booleanValue(), v.longValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanLongConsumer andThen(BiConsumer<? super Boolean, ? super Long> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Long.valueOf(V));};
-	}
-}
@@ -1,50 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- * @param <V> the keyType of elements maintained by this Collection
- */
-public interface BooleanObjectConsumer<V> extends BiConsumer<Boolean, V>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, V v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanObjectConsumer<V> andThen(BooleanObjectConsumer<V> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, V v) { accept(k.booleanValue(), v); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanObjectConsumer<V> andThen(BiConsumer<? super Boolean, ? super V> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), V);};
-	}
-}
@@ -1,49 +0,0 @@
-package speiger.src.collections.booleans.functions.consumer;
-
-import java.util.Objects;
-import java.util.function.BiConsumer;
-
-/**
- * A Type Specific BiConsumer class to reduce boxing/unboxing and that fills the gaps that java has.
- */
-public interface BooleanShortConsumer extends BiConsumer<Boolean, Short>
-{
-	/**
-	 * A Type Specific operation method to reduce boxing/unboxing
-	 * Performs this operation on the given arguments.
-	 *
-	 * @param k the first input argument
-	 * @param v the second input argument
-	 */
-	void accept(boolean k, short v);
-	
-	/**
-	 * Type Specific sequencing method to reduce boxing/unboxing.
-	 * @param after a operation that should be performed afterwards
-	 * @return a sequenced biconsumer that does 2 operations
-	 * @throws NullPointerException if after is null
-	 */
-	public default BooleanShortConsumer andThen(BooleanShortConsumer after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(K, V);};
-	}
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
-	 * @deprecated Please use the corresponding type-specific function instead. 
-	 */
-	@Override
-	@Deprecated
-	default void accept(Boolean k, Short v) { accept(k.booleanValue(), v.shortValue()); }
-	
-	/** {@inheritDoc}
-	 * <p>This default implementation delegates to the corresponding type-specific function.
- 	 * @deprecated Please use the corresponding type-specific function instead. 
- 	 */
-	@Override
-	@Deprecated
-	default BooleanShortConsumer andThen(BiConsumer<? super Boolean, ? super Short> after) {
-		Objects.requireNonNull(after);
-		return (K, V) -> {accept(K, V); after.accept(Boolean.valueOf(K), Short.valueOf(V));};
-	}
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2BooleanFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public boolean test(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2ByteFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public byte applyAsByte(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2CharFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public char applyAsChar(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2DoubleFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public double applyAsDouble(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2FloatFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public float applyAsFloat(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2IntFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public int applyAsInt(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2LongFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public long applyAsLong(boolean k);
-	
-}
@@ -1,18 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- * @param <V> the keyType of elements maintained by this Collection
- */
-@FunctionalInterface
-public interface Boolean2ObjectFunction<V>
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public V apply(boolean k);
-	
-}
@@ -1,17 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-
-/**
- * A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
- */
-@FunctionalInterface
-public interface Boolean2ShortFunction
-{
-	/**
-	 * Type Specific get function to reduce boxing/unboxing
-	 * @param k the value that should be processed
-	 * @return the result of the function
-	 */
-	public short applyAsShort(boolean k);
-	
-}
@@ -1,22 +0,0 @@
-package speiger.src.collections.booleans.functions.function;
-
-import java.util.function.BiFunction;
-
-/**
- * A Type Specific Unary Operator to support Compute/Merge functions with type specific methods to reduce boxing/unboxing
- */
-public interface BooleanBooleanUnaryOperator extends BiFunction<Boolean, Boolean, Boolean>
-{
-	/**
-	 * A Type Specifc apply method to reduce boxing/unboxing.
-	 * Applies this function to the given arguments.
-	 *
-	 * @param k the first function argument
-	 * @param v the second function argument
-	 * @return the function result
-	 */
-	public boolean applyAsBoolean(boolean k, boolean v);
-	
-	@Override
-	public default Boolean apply(Boolean k, Boolean v) { return Boolean.valueOf(applyAsBoolean(k.booleanValue(), v.booleanValue())); }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Speiger	3bff703d91	Version Bump	2026-08-10 20:14:19 +02:00
Speiger	d140aaa788	Added CompletableFuture Support and fixed a small bug in a test	2026-08-10 19:38:35 +02:00
Speiger	180b603ffd	fixed unit test	2026-08-10 09:49:53 +02:00
Speiger	2306917b10	Added forEach(CONSUMER, Input)	2026-08-09 21:43:57 +02:00
Speiger	075f3ad183	Updated Docs	2026-05-15 02:45:00 +02:00
Speiger	363160441d	JDK8 compat	2026-05-15 02:34:19 +02:00
Speiger	2a97d017b7	1.0.0 release for now	2026-05-15 01:42:51 +02:00
Speiger	374b027120	Fixed the last unit tests	2026-05-15 00:04:54 +02:00
Speiger	21ccbee3b2	Disabled Google Tests that we don't have to deal.	2026-05-14 21:32:16 +02:00
Speiger	58a9eb38b4	Loads of additions. -Added: Indirect Sorters. -Added: ReferenceMaps -Fixed: A bunch of smaller bugs found due to tests	2026-05-14 19:21:38 +02:00
Speiger	2f1525ab57	Fixes and new updates. - Added: Collectors to lists/queues/sets - Fixed: Bugs in linked hash sets. - Fixed: Bugs in unit tests.	2026-05-14 02:51:38 +02:00
Speiger	9f46091282	Added Tests for Ordered Maps and more work on completing the implementation	2026-05-12 13:37:22 +02:00
Speiger	3d39d5526d	Breaking update - Added: Optionals for the missing JDK ones. - Removed: Default values for Reduce and FindFirst. Using Optionals instead.	2026-05-11 18:00:00 +02:00
Speiger	c6f656ee66	Switched to yearly activity	2026-05-11 00:36:08 +02:00
Speiger	f0139d1a22	Fixed Badge Generator	2026-05-11 00:34:48 +02:00
Speiger	58e20bb513	Fixed Enums	2026-05-11 00:10:44 +02:00
Speiger	502f22cea3	Removed java 25 support. Gradlew isn't supporting this yet.	2026-05-10 22:11:18 +02:00
Speiger	90e3b7110a	Updated Actions	2026-05-10 22:09:21 +02:00
Speiger	a26106cc89	Fixed a bunch of Iterator code and implemented Reverse Map/Set Tests	2026-05-10 22:00:55 +02:00
Speiger	d002f0094f	Updated Build Matrix to incude newer java versions and remove obsolete ones	2026-05-09 05:25:26 +02:00
Speiger	042460a338	Started Adding support for JDK21 SequencedCollections. Implementation is mostly finished. Just need to iron out bugs. But at this point i want to push activity.	2026-05-09 05:22:35 +02:00
Speiger	20927a97eb	Reworked Module Settings System Changelog: - Added: Dependency System that will resolve missing classes and enable them as needed. (This isn't perfect on some low level modules like Functions) - Added: Dependency Error system that will throw errors if a dependency is that is required is specifically disabled. - Added: Default setting for "undefined" entries. - Fixed: A few bugs that made the dependency system unnecessary difficult. - Updated: Documentation	2025-03-09 23:29:13 +01:00
Speiger	ebe75b0fea	Fixing a few things and testing more. Not useable atm.	2025-03-08 01:08:31 +01:00
Speiger	a6be24c59d	Start of a Advanced Dependency System. The idea behind this system is that you can select systems a lot easier. So if a custom system isn't required it can be disabled and all the subsystems that require it either get disabled too. it also allows you to set systems as: Only if they are required. Meaning if only a specific system is required its dependencies can still load.	2025-03-08 01:08:31 +01:00
Speiger	afdd27648e	Updated Changelog and Readme to include Maven Central	2024-04-11 19:11:07 +02:00
Speiger	7e475b5472	Fixed a few bugs in the maven central script	2024-03-30 05:12:57 +01:00
Speiger	e65fde736b	Fixed	2024-03-30 01:08:38 +01:00
Speiger	bf0b4172de	Added Maven central Badge	2024-03-30 01:07:46 +01:00
Speiger	961b47a58c	Fixed java8 compat	2024-03-30 01:02:42 +01:00
Speiger	330be87338	finalizing the maven central release.	2024-03-30 00:32:37 +01:00
Speiger	4b30ce12c9	Upgraded thread workers and disable GPG temporarly.	2024-03-29 22:35:44 +01:00
Speiger	0be7dba5d3	Fixed script bug	2024-03-29 22:26:34 +01:00
SpeigerandSpeiger	6eaa992f5f	Create SECURITY.md	2024-03-29 22:19:29 +01:00
Speiger	9b23d713ff	Started maven publish plugin.	2024-03-29 22:17:38 +01:00
Speiger	85d230c561	Fixed a auto generation bug where iterators wouldn't accept settings	2023-07-04 17:29:32 +02:00