Pushing release

New Stuff
-Fixed: Crash with FIFOQueues peek function when loops were applied. -Fixed: FIFOQueues clean function was doing unessesary extra work. -Added: Stream Overrides functions now support sorted. -Updated: Changelog. -Added: A couple more badges because why not.
2022-04-21 17:41:50 +02:00 · 2022-04-21 17:25:23 +02:00 · 2022-04-19 17:16:53 +02:00 · 2022-04-19 17:10:57 +02:00 · 2022-04-19 16:58:22 +02:00 · 2022-04-19 16:33:16 +02:00
46 changed files with 5185 additions and 1788 deletions
@@ -15,17 +15,19 @@ on:

 jobs:
  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        jdk: [8, 11, 14, 16, 17]

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
-    - name: Set up JDK 11
+    - name: Set up JDK ${{ matrix.jdk }}
      uses: actions/setup-java@v1
      with:
-        java-version: '11'
-        distribution: 'adopt'
-        cache: gradle
+        java-version: ${{ matrix.jdk }}
    - name: Validate Gradle wrapper
      uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
    - name: Make gradlew executable
@@ -1,8 +1,20 @@
 # Changelog of versions

+### Version 0.6.1
+- Fixed: FIFO queue crashing when the last index is before the first index when peek is called.
+- Fixed: FIFO queue only clears the array if it was in use.
+- Added: Sorted Method for the stream replacing functions.
+
 ### Version 0.6.0
 - Added: addOrGet for sets.
 - Added: Async API which allows to easily execute Iterables/Collections offthread without the complexity.
+- Added: CopyOnWriteArrayList and tests for it
+- Added: Support up to Java17.
+- Added: Build System now adds module-info if the Running JVM is 9 or higher
+- Added: ArrayList.of(Class, size) that allows you to allocate a size right at the creation of the List without having to create a wrapper array.
+- Added: A ConcurrentHashMap implementation.
+- Fixed: containsValue in the HashMap wouldn't check the nullKey
+- Removed: Deprecated functions from SortedMaps/Sets

 ### Version 0.5.3
 - Added: OrderedMap/Set
@@ -1,93 +1,51 @@
 ![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_validator.yml/badge.svg)
-
+[![Latest Release](https://jitpack.io/v/Speiger/Primitive-Collections.svg)](https://jitpack.io/#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)
 # 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.  

-This is a Simple Primitive Collections Library i started as a hobby Project.     
-It is based on Java's Collection Library and FastUtil.     
-But its focus is a different one.     
+## Benchmarks
+Benchmarks can be found here: [[Charts]](https://github.com/Speiger/Primitive-Collections-Benchmarks/blob/master/BENCHMARKS-CHARTS.md), [[Tables]](https://github.com/Speiger/Primitive-Collections-Benchmarks/blob/master/BENCHMARKS.md)
+
+## Special Features
+[Here](features.md) you find a set of features added to Primitive Collections.   
+These are designed to improve performance or to provide Quality of Life.  

 ## Main Features:      
- ArrayLists / LinkedLists
+- ArrayLists / LinkedLists / CopyOnWriteLists
 - HashSets/Maps (Linked & HashControl)
 - TreeSets/Maps (RB & AVL)
 - EnumMaps
 - Immutable Maps/Lists/Sets
+- ConcurrentHashMaps
 - Priority Queues
 - Streams & Functional Queries
- SplitIterators
- Iterators
+- Split/Iterators
 - Pairs
 - Unary/Functions
 - Suppliers
 - Bi/Consumers
-
-
-## Current Level of Stability
-Since this is a relatively new Library, stability was not perfect and some areas are not perfect yet.     
-Thanks to [ben-manes](https://github.com/ben-manes) we now have Roughly 160k unit test covering Maps/Sets/Lists.     
-These tests cover Javas Collection API completely and ensuring a Stable implementation.     
-These freshly added tests allowed me to squash thousands of issues according to Googles Test Library (Guava-Tests).     
-These will be expanded on as time goes on.     
-
-### Benchmarks
-Benchmarks can be found here: [Click Me](https://github.com/Speiger/Primitive-Collections-Benchmarks/tree/master)
-
-## Specialized Functions
-New Specialized functions that were added to increase performance or reduce allocations or Quality Of life.
-To highlight things that may be wanted.
- Iterable:
-	- map/flatMap/arrayFlatMap: A Light weight version of Stream.map().
-	- findFirst: Allows to find the first element of a Predicated Iterable.
-	- filter: Allows to filter unwanted elements for wrapped Iterable
-	- matchAny/matchNone/matchAll: Allows to find elements in a collection.
-	- count: counts all valid elements in a collection.
-	- forEach: Allows to input a second element into a forEach move allowing for more flexibility for Method References
-	- reduce/limit/peek/distinct: Light Versions of the Stream variant, to reduce Stream usage.
-	- pour: a function that allows to collect all elements within the Collection
- Collection:
-	- addAll: addAll array version
-	- containsAny: Allows to test if another collection contains an of the elements of the tested collection.
-	- primitiveStream: Provides access to the closest Java Stream Type.
-	- copy: shallowCopies the collection, used instead of clone because this is better to use.
-		(subCollections not supported for obvious reasons)
-	- toArray: the ToArray function from Java9 and newer that uses a Functional interface and can use a method reference
- List:
-	- add/get/removeElements (From FastUtil): Allows to add/get/remove an Array into/from a list. Just with less overhead
-	- extractElements: Allows to remove a Range of elements from the List and get what was removed.
-	- Unstable Sort(From FastUtil): Uses a faster but not stable sort (Quick-Sort as example) to sort the list.
-	- addIfAbsent/Present: adds a element only if absent/present in the list
-	- swapRemove: deletes a desired element and inserts the last element in its place instead of leftshifting elements.
- SortedSet:
-	- addAndMoveToFirst/Last (From FastUtil but moved to Interface): Allows to add a element to the first/last position of a sorted set.
-	- moveToFirst/Last: Moves the desired element at the first/last position of the SortedSet.
-	- pollFirst/Last: Allows to poll the first/last element of the set.
- Map:
-	- putAll: putAll but in Array form.
-	- putAllIfAbsent: Puts only the elements that are absent.
-	- addTo (Only Primitives Values) (From FastUtil but moved to Interface): allows to add to the value of a given key. If not present it will be added. (Accumulator)
-	- subFrom (Only Primitive Values): allows to subtract from the value of a given key. If value reached getDefaultReturnValue() element will be removed.
-	- addToAll: Same as addTo but bulkVersion.
-	- removeOrDefault: removes a Element and if not present returns the default value instead of the present value.
-	- mergeAll: BulkVersion of Merge function.
-	- supplyIfAbsent: A Supplier based computeIfAbsent
- Sorted Map:
-	- addAndMoveToFirst/Last (From FastUtil but moved to Interface): Allows to add a element to the first/last position of a sorted Map.
-	- moveToFirst/Last: Moves the desired element at the first/last position of the Map.
-	- getAndMoveToFirst/Last: gets the element and moves it to the first/last position. Replicating a Optional LinkedHashMap feature.
-	- pollFirst/LastKey: Allows to poll the first/last element.
-	- first/LastValue: Allows to get the first/last value from the Map.
-	
+- AsyncBuilders  

 # Notes about Versions
 Any 0.x.0 version (Minor) can be reason for massive changes including API.     
 To ensure that problems can be dealt with even if it is breaking the current API.     
-Any breaking changes will be Documented (once 1.0 is released)     
-
-Also to save space every 0.0.x (Patch) that is 2 Minor Versions behind will be removed. 
-So if 0.5.0 is released every 0.3.x patch will be deleted, except for the last patch for that minor version.

 # How to install
-Using Gradle:
+Using Jitpack Gradle
+```gradle
+repositories {
+    maven {
+        url = "https://jitpack.io"
+    }
+}
+dependencies {
+	implementation 'com.github.Speiger:Primitive-Collections:0.6.1'
+}
+```
+Using Custom Gradle:
 ```gradle
 repositories {
    maven {
@@ -95,13 +53,18 @@ repositories {
    }
 }
 dependencies {
-	compile 'de.speiger:Primitive-Collections:0.5.3'
+	implementation 'de.speiger:Primitive-Collections:0.6.1'
 }
 ```
-Direct:
+
+<details>
+<summary>Direct: </summary>
+<p>

 | Version 	| Jar                                                                                                                          	| Sources                                                                                                                              	| Java Doc                                                                                                                             	|
 |---------	|------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|--------------------------------------------------------------------------------------------------------------------------------------	|
+| 0.6.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.1/Primitive-Collections-0.6.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.1/Primitive-Collections-0.6.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.1/Primitive-Collections-0.6.1-javadoc.jar) 	|
+| 0.6.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.6.0/Primitive-Collections-0.6.0-javadoc.jar) 	|
 | 0.5.3   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.3/Primitive-Collections-0.5.3-javadoc.jar) 	|
 | 0.5.2   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.2/Primitive-Collections-0.5.2-javadoc.jar) 	|
 | 0.5.1   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.5.1/Primitive-Collections-0.5.1-javadoc.jar) 	|
@@ -114,6 +77,9 @@ Direct:
 | 0.4.0   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.4.0/Primitive-Collections-0.4.0-javadoc.jar) 	|
 | 0.3.6   	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-sources.jar) 	| [Download](https://maven.speiger.com/repository/main/de/speiger/Primitive-Collections/0.3.6/Primitive-Collections-0.3.6-javadoc.jar) 	|

+</p>
+</details>
+
 # Contributing
 If you want to contribute.      
 This project is created using gradle and java and my Template Library only. Nothing extra.      
@@ -135,6 +101,3 @@ The SourceCode can be generated via:
 to build the jar:           
 /gradlew.bat build      
 do not combine the commands because they can not be executed at the same time.      
-
-## Current Down Sides (Random order)
- Documentation is only present at the lowest level for most cases and needs a typo fixing.
@@ -8,7 +8,7 @@ tasks.withType(JavaCompile) {

 apply plugin: 'java'
 apply plugin: 'eclipse'
-apply plugin: 'maven'
+apply plugin: 'maven-publish'

 repositories {
    mavenCentral()
@@ -18,9 +18,11 @@ repositories {
 }

 archivesBaseName = 'Primitive Collections'
-version = '0.5.3';
+version = '0.6.1';

-sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8'
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
+
+System.out.println("Java Version: "+compileJava.sourceCompatibility)

 javadoc {
    options.tags = [ "implSpec", "note" ] 
@@ -42,10 +44,10 @@ configurations {
 }

 dependencies {
-	builderCompile 'de.speiger:Simple-Code-Generator:1.0.6'
-	runtimeOnly 'de.speiger:Simple-Code-Generator:1.0.6'
+	builderImplementation 'de.speiger:Simple-Code-Generator:1.0.7'
    testImplementation 'junit:junit:4.12'
    testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
+    
 }

 task generateSource(type: JavaExec) {
@@ -81,6 +83,8 @@ task srcJar(type: Jar) {
    classifier = 'sources'
 }

+compileJava.dependsOn generateGithubSource
+
 javadoc.failOnError = false
 javadoc.options.memberLevel = JavadocMemberLevel.PUBLIC
 javadoc.options.quiet()
@@ -94,24 +98,23 @@ test {
    useJUnit()
 }

-uploadArchives {
+publishing {
 	Properties props = new Properties()
-	if(file("$buildDir/credentials.properties").exists())
-	{
+	if(file("$buildDir/credentials.properties").exists()) {
 		props.load(new FileInputStream("$buildDir/credentials.properties"))
 	}
-	repositories.mavenDeployer {
-		repository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: props.mavenUser, password: props.mavenPassword)
-		}
-		snapshotRepository(url: 'https://maven.speiger.com/repository/main') {
-			authentication(userName: props.mavenUser, password: props.mavenPassword)
-		}
+	publications {
+		mavenJava(MavenPublication) {
 			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
 				artifactId = project.archivesBaseName.replace(" ", "-")
 				groupId = 'de.speiger'
-			project {
+				from components.java
+				artifact tasks.srcJar
+				artifact tasks.javadocJar
 				licenses {
 					license {
 						name = 'The Apache License, Version 2.0'
@@ -122,10 +125,25 @@ uploadArchives {
 					developer {
 						id = 'speiger'
 						name = 'Speiger'
-						email = 'speiger@gmx.net'
+					}
+				}
+				scm {
+					url = 'https://github.com/Speiger/Primitive-Collections'
+				}
+				issueManagement {
+					system = 'github'
+					url = 'https://github.com/Speiger/Primitive-Collections/issues'
 				}
 			}
 		}
 	}
+	repositories {
+		maven {
+			url version.endsWith('SNAPSHOT') ? "https://maven.speiger.com/repository/debug" : "https://maven.speiger.com/repository/main"
+			credentials(PasswordCredentials) {
+				username props.mavenUser
+				password props.mavenPassword
+			}
+		}
 	}
 }
@@ -0,0 +1,402 @@
+## Quality Of Life Features
+New Specialized functions/classes that were added to increase performance and/or reduce allocations and/or for Quality of life.  
+
+
+# Functions
+
+Functions that increase performance or are quality of life in their nature.   
+
+<details>
+<summary>Iterable</summary>
+<p>
+
+## Functional Functions
+
+Java adds themselves a lot of functional functions like,  
+- Stream:
+	- Map/FlatMap
+	- Filter/Distinct/Limit/Sorted
+	- Count/FindFirst/Collect
+	- Peek/ForEach/Reduce
+	- anyMatch/allMatch/NoneMatch   
+
+that allows to process a collection in a functional way.   
+But these require streams which have a lot of Overhead in their nature.    
+
+Luckly Primitive Collections adds replacement functions that provide the same functionality but with minimal overhead.   
+Here are some examples:
+```java
+public ObjectIterable<Path> toPath(ObjectIterable<String> iterable) {
+	return iterable.map(Paths::get).filter(Files::exist);
+}
+
+public Iterable<Path> toPath(Iterable<String> iterable) {
+	return ObjectIterables.map(iterable, Paths::get).filter(Files::exist);
+}
+
+public int sum(IntIterable iterable) {
+	return iterable.reduce(Integer::sum);
+}
+```
+
+## AsyncAPI</summary>
+
+The AsyncAPI is a Feature that simplifies the processing of Collections on a separate thread.   
+It uses the same concept as Javas Stream API but uses the light weight Functions from Primitive Collections to achieve the same thing.   
+Unlike Javas StreamAPI the AsyncAPI is always singleThreaded and more like Javas CompletableFuture, which you can await or let run Asynchronous.    
+
+The Goal is it to simplify the processing of Collections asynchronous.   
+Especially on tasks which don't have to be finished instantly but can be processed on the side.   
+
+Here is a example of how the API works.
+```java
+public void processFiles(ObjectCollection<String> potentialFiles) {
+     potentialFiles.asAsync()
+         .map(Paths::get).filter(Files::exists) //Modifies the collection (Optional)
+         .forEach(Files::delete) //Creates the action (Required)
+         .callback(T -> {}} //Callback on completion, still offthread (Optional)
+         .execute() //Starts the task. (Required)
+}
+```
+</p>
+</details>
+<details>
+<summary>Collection</summary>
+<p>
+
+These are functions specific to the Collections interface, stuff that everyone wished it was present to be in the first place.
+
+## AddAll (Array)
+Adding Elements to a Collection usually requires either a for loop or a Arrays.wrap().   
+This isn't an issue with Primitive Collections.
+```java
+public void addMonths(ObjectCollection<String> months) {
+	months.addAll("January", "February", "March", "April", "May", "June", "July", "August", "September, "October", November", "December");
+}
+
+public void addElements(ObjectCollection<String> result, String[] elements) {
+	result.addAll(elements, 0, 5); //elements, offset, length
+}
+```
+
+## containsAny
+Everyone hates comparing if 2 collections have part of each other included.   
+The solution usually requires for loops and keeping track if things were found or not.   
+And every Java Developer had this issue at least once and wished for a clean solution.
+```java
+public boolean hasMonths(ObjectCollection<Month> target, Collection<Month> toFind) {
+	return target.containsAny(toFind);
+}
+```
+
+## Copy
+Collections get copied every now and then. There is only 2 ways that this happens.  
+Javas Clone API or using Constructor that supports collections.  
+Javas Clone API is kinda in a Zombie state, where it is supported or not. Its not really clear if you should use it or not.  
+The Clone CloneNotSupportedException isn't helping either, causing more janky code.  
+While a Constructor can only support so much and testing for every case isn't really viable.  
+
+So the decision was made to straight out not support clone and instead add a copy function which doesn't use a checked exception.  
+It works exactly like the clone function. In a sense where it creates a shallow copy. (SubCollections do not work for obvious reasons)
+```java
+public IntCollection copy(IntCollection original) {
+	return original.copy();
+}
+```
+
+## Primitive Streams
+Since Javas Stream API is still really useful, even at its shortcomings, Primitive Collections provides easy access to it.  
+Generic Streams and the closest Primitive Stream will be provided. So a FloatCollection goes to a DoubleStream.
+```java
+public IntStream createStream(IntCollection source) {
+	return source.primitiveStream();
+}
+```
+
+## RemoveAll/RetainAll with listener
+Ever wanted use removeAll or retainAll and wanted to know what elements actually got deleted?  
+The usual solution is to create a copy and then apply it to the original and cross reference them.  
+Which leads to really messy code and just hasn't a clean solution.  
+Luckly Primitive Collections got you covered.
+```java
+public void removeInvalidFiles(ObjectCollections<Path> files, ObjectCollection<Path> toRemove) {
+	files.removeAll(toRemove, T -> System.out.println(T));
+}
+
+public void removeInvalidFiles(ObjectCollections<Path> files, ObjectCollection<Path> toKeep) {
+	files.retainFiles(toKeep, T -> System.out.println(T));
+}
+```
+
+## ToArray 
+Primitive Collections supports primitive/generic toArray functions for its Primitive Collections.  
+On top of that the Object side gets a Java9 function ported back to java8, which uses a functional Interface to create the backing array.
+```java
+public Integer[] toArray(IntCollection c) {
+	return c.toArray(new Integer[c.size]);
+}
+
+public int[] toArray(IntCollection c) {
+	return c.toIntArray();
+}
+
+public String[] toArray(ObjectCollection<String> c) {
+	return c.toArray(String::new);
+}
+```
+</p>
+</details>
+
+<details>
+<summary>List</summary>
+<p>
+
+These functions are List specific functions, a couple of these are from FastUtil.
+
+## add/get/remove/extractElements
+These functions really useful helper functions. 3 of which are copied from FastUtil. (extract is from Primitive Collections)  
+They are basically array forms of addAll, getAll, removeRange and removeAndGetRange. This is the simplest way to describe it.  
+
+Here some example:
+```java
+public void addAll(DoubleList list) {
+	list.addElements(0D, 12.2D, 3.5D, 4.2D);
+}
+
+public double[] getAll(DoubleList list, int amount) {
+	double[] result = new double[amount];
+	list.getElements(0, result);
+	return result;
+}
+
+public void removeRange(FloatList list) {
+	list.removeElements(5, 14);
+}
+
+public float[] extractRange(FloatList list) {
+	return list.extractElements(5, 14); //Returns the removed elements
+}
+```
+
+## addIfPresent/addIfAbsent
+These two functions are simple helper functions that check internally if a element is present or absent before adding them to the List.   
+Removing the need for a contains or indexOf check every time you want to add a element.
+While it is of course better to use a set, there is cases where this is still useful.
+
+```java
+public void addElements(IntList list, int... numbersToAdd) {
+	for(int e : numbersToAdd) {
+		list.addIfAbsent(e);
+	}
+}
+
+public void addExisting(ObjectList<String> list, String... textToAdd) {
+	for(String s : textToAdd) {
+		list.addIfPresent(s);
+	}
+}
+```
+
+## SwapRemove
+Lists when removing a Element shift usually the backing array to the left based to shrink the elements.  
+While that isn't computational expensive with LinkedLists, it is with ArrayLists.  
+Here comes swapRemove into play, which just removes the desired elements and instead of shifting left puts the last element in its place.
+This reduces the data copying required down to 1 element instead of an array.
+
+```java
+public int remove(IntList elements, int indexToRemove) {
+	return elements.swapRemove(indexToRemove);
+}
+```
+
+## Unstable Sort (From FastUtil)
+Unstable Sort uses a Faster but not as stable sorting algorithm to sort the Collection.  
+Stable doesn't mean crashing, but more like that the result isn't exactly perfectly sorted.  
+```java
+public void sort(List<Month> list, Comparator<Month> sorter) {
+	list.unstableSort(sorter);
+}
+```
+</p>
+</details>
+
+<details>
+<summary>Map</summary>
+<p>
+
+These functions are based on the Map interface. Useful functions you really would want.  
+
+## addTo/subFrom
+addTo (from FastUtil) and subFrom are mathematically functions that either add or subtract from the value of a given key.   
+And if the key isn't present or would result in the default value it will either add or remove the entry from the Map. Given the circumstance.   
+This is a really useful function and I wish FastUtil made it accessible by default but sadly it isn't.   
+To simplify the explanation:    
+- addTo if no element is present puts in the desired number, otherwise it sums up the two values.   
+- subFrom if a element is present subtracts from it, if the element reaches the default value it removes the element from the map. If not present it will be ignored.   
+```java
+public void addTo(Object2DoubleMap<Month> map, Month key, double averageTrainsRepaired) {
+	map.addTo(key, averageTrainsRepaired);
+}
+
+public void subFrom(Long2IntMap map, long key, double amount) {
+	map.subFrom(key, amount);
+}
+```
+
+## addToAll
+Simple bulk version of the addTo function since sometimes you want to merge 2 maps for summing.  
+Especially if your work is multi-threaded this can become useful.
+
+```java
+public void addTo(Object2DoubleMap<Month> map, Object2DoubleMap<Month> trainsRepaired) {
+	map.addToAll(trainsRepaired);
+}
+```
+
+## mergeAll
+This is a simple bulk version of merge since merging 2 maps is more frequent then people might think and leads to cleaner code too.
+```java
+public void merge(Long2ByteMap result, Long2ByteMap toMerge) {
+	result.mergeAll(toMerge);
+}
+```
+
+## putAll (Array)
+This allows to put keys and values as arrays instead of requiring a WrapperMap to insert the elements.  
+Not as useful as the Collections.addAll variant but still really useful.
+```java
+public void putAll(Int2DoubleMap map, int[] keys, double[] values) {
+	map.put(keys, values, 2, 15);
+}
+```
+
+## putAllIfAbsent
+putAll has this usual quirk where if a element is present it will replace the value, and sometimes this is not wanted.  
+While putIfAbsent exists it has no real mass form and makes iterative solutions really uneasy to use.  
+Here comes the helper function that gets rid of that problem.
+```java
+public void merge(Long2ObjectMap<String> regionFiles, Long2ObjectMap<String> toAdd) {
+	regionFiles.putAllIfAbsent(toAdd);
+}
+```
+
+## removeOrDefault
+getOrDefault is a really useful function that find use cases all the time.   
+Sadly by default there is no variant of removeOrDefault, while it has less cases still could be used every now and then.  
+This function basically tries to remove a element, if it is not present it will just return your desired default.
+```java
+public Path removeCache(Long2ObjectMap<Path> caches, long key) {
+	return caches.removeOrDefault(key, Paths.get("nuclearFun"));
+}
+```
+
+## supplyIfAbsent
+This one is one of my favorites. computeIfAbsent is a really useful function.   
+But in 90% of the cases I use it the value is a collection.  
+This becomes really annoying since methodReferences are faster/cleaner then Lambdas in my opinion.  
+supplyIfAbsent is basically computeIfAbsent but without a key, perfect for the default constructor of a collection.  
+This is the whole reason it exists.  
+```java
+public void example(Int2ObjectMap<List<String>> map, Int2ObjectMap<String> toAdd) {
+	for(Entry<String> entry : toAdd.entrySet()) {
+		map.supplyIfAbsent(entry.getKey(), ObjectArrayList::new).add(entry.getValue());
+	}
+}
+```
+</p>
+</details>
+
+# Interfaces
+
+Interfaces that provide essential or quality of life features.
+
+<details>
+<summary>ITrimmable</summary>
+<p>
+
+The ITrimmable is Accessor interface that allows you to access a couple helper functions to control the size of your collections.  
+This was created for the constant casting requirement to implementations just to shrink collections which get annoying over time.  
+
+## trim
+This function basically trims down the backing implementation to use as little memory as required to store the elements in the collection.  
+Optionally a desired minimum size can be provided as of how low it should go at worst.  
+
+## clearAndTrim
+when you want to reset a Collection completely you have 2 options. Clear it and then call trim, or recreate the collection.  
+clearAndTrim solves this problem by clearing the collection and trimming it in one go, reducing overhead to achieve such a thing.  
+
+</p>
+</details>
+
+<details>
+<summary>IArray</summary>
+<p>
+
+IArray is a Accessor interface that provides more access to collections by providing tools to grow your collection as needed.  
+While putAll/addAll try to ensure that you have enough room for your elements, this is not really a solution for all cases.  
+Sometimes you need to ensure the Collection is pre-initialized.  
+IArray grants you that control.  
+
+There is also a type specific that provides you access to the backing array implementation of Lists for faster Iteration but that is a really specific case.  
+
+## ensureCapacity
+Ensures that your collection has enough storage for the elements you want to insert.  
+
+## elements (ITypeSpecificArray)
+Allows you access to the backing array of a List which is for people who know what they are doing.  
+There is a lambda version of this function too which makes sure for synchronizedLists that you are the only one accessing the array.  
+
+</p>
+</details>
+
+<details>
+<summary>OrderedMap</summary>
+<p>
+
+The OrderedMap is a real edge case interface that was born for a need.    
+FastUtil added functions that were like moveToFirst which were hardcoded to the implementation.  
+They didn't fit into something like a SortedMap because the Set wasn't sorted.  
+So OrderedMap was born, which isn't random but ordered in a specific way that can be changed.  
+
+## getAndMoveToFirst/getAndMoveToLast
+Returns a desired element and removing it to the first/last spot in the Map. Moving the element that was at its spot after/before it.  
+
+## moveToFirst/moveToLast
+Moves the element if present to the first/last spot in the Map. Moving the element that was at its spot after/before it.  
+Returns true if the element was actually moved.  
+
+## putAndMoveToFirst/putAndMoveToLast
+Adds the desired element and moves it to first/last spot in the Map. Moving the element that was at its spot after/before it.  
+
+## firstKey/lastKey (Optional poll)
+Provides access to the current first/last key of the Map.  
+Optionally can be polled if desired.  
+
+## firstValue/lastValue
+Provides access to the current first/last value of the Map.  
+
+</p>
+</details>
+
+<details>
+<summary>OrderedSet</summary>
+<p>
+
+The OrderedSet is a real edge case interface that was born for a need.    
+FastUtil added functions that were like moveToFirst which were hardcoded to the implementation.  
+They didn't fit into something like a SortedSet because the Set wasn't sorted.  
+So OrderedSet was born, which isn't random but ordered in a specific way that can be changed.  
+
+## addAndMoveToFirst/addAndMoveToLast
+Adds the desired element and moves it to first/last spot in the Collection. Moving the element that was at its spot after/before it.  
+
+## moveToFirst/moveToLast
+Moves the element if present to the first/last spot in the Collection. Moving the element that was at its spot after/before it.  
+Returns true if the element was actually moved.  
+
+## first/last (Optional poll)
+Provides access to the current first/last element of the set.  
+Optionally can be polled if desired.
+
+</p>
+</details>
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -0,0 +1,7 @@
+jdk:
+   - openjdk9
+install:
+   - chmod +x ./gradlew
+   - ./gradlew generateGithubSource
+   - ./gradlew build publishToMavenLocal
+   
@@ -158,6 +158,7 @@ public class GlobalVariables
 		
 		//Final Classes
 		addClassMapper("ARRAY_LIST", "ArrayList");
+		addAbstractMapper("COPY_ON_WRITE_LIST", "CopyOnWrite%sArrayList");
 		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
 		addClassMapper("LINKED_LIST", "LinkedList");
 		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
@@ -173,6 +174,7 @@ public class GlobalVariables
 		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
 		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
 		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
+		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
 		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
 		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
 		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
@@ -222,6 +224,7 @@ public class GlobalVariables
 		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
 		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
 		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
+		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
 		addBiClassMapper("MAP", "Map", "2");
 		addClassMapper("NAVIGABLE_SET", "NavigableSet");
 		addBiClassMapper("PAIR", "Pair", "");
@@ -1,6 +1,8 @@
 package speiger.src.builder;

+import java.io.BufferedWriter;
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -10,7 +12,9 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.StringJoiner;
 import java.util.function.Consumer;
+import java.util.stream.Stream;

 import speiger.src.builder.processor.TemplateProcess;
 import speiger.src.builder.processor.TemplateProcessor;
@@ -65,6 +69,23 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		return false;
 	}
 	
+	@Override
+	protected void afterFinish()
+	{
+		if(getVersion() > 8) 
+		{
+			Path basePath = Paths.get("src/main/java");
+			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
+			{
+				writer.write(getModuleInfo(basePath));
+			}
+			catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+	}
+	
 	@Override
 	protected void init()
 	{
@@ -83,7 +104,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		biRequired.put("Pair", "");
 		biRequired.put("MutablePair", "");
 		biRequired.put("ImmutablePair", "");
-		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "AbstractMap", "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 		nameRemapper.put("BiConsumer", "%sConsumer");
 		nameRemapper.put("IArray", "I%sArray");
 		nameRemapper.put("AbstractMap", "Abstract%sMap");
@@ -94,12 +115,13 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		nameRemapper.put("EnumMap", "Enum2%sMap");
 		nameRemapper.put("LinkedEnumMap", "LinkedEnum2%sMap");
 		nameRemapper.put("ImmutableList", "Immutable%sList");
+		nameRemapper.put("CopyOnWriteList", "CopyOnWrite%sArrayList");
 		nameRemapper.put("ImmutableOpenHashSet", "Immutable%sOpenHashSet");
 		nameRemapper.put("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
 		addBlockage(ClassType.OBJECT, "Consumer", "Comparator", "Stack");
 		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "OrderedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
-		addBlockage(ClassType.BOOLEAN, "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		addBlockage(ClassType.BOOLEAN, "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
 	}
 	
 	protected void create(ClassType mainType, ClassType subType) 
@@ -161,6 +183,55 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		return variables;
 	}
 	
+	private String getModuleInfo(Path basePath) {
+		StringJoiner joiner = new StringJoiner("\n", "", "\n");
+		try(Stream<Path> stream = Files.walk(getOutputFolder()))
+		{
+			stream.filter(Files::isDirectory)
+					.filter(this::containsFiles)
+					.map(basePath::relativize)
+					.map(Path::toString)
+					.map(this::sanitize)
+					.forEach(T -> joiner.add("\texports "+T+";"));
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		}
+		StringBuilder builder = new StringBuilder();
+		builder.append("/** @author Speiger */\n");
+		builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
+		builder.append(joiner.toString()).append("}");	
+		return builder.toString();
+	}
+	
+	private String sanitize(String input)
+	{
+		return input.replace("\\", ".").replace("/", ".");
+	}
+	
+	private boolean containsFiles(Path path) 
+	{
+		try(Stream<Path> stream = Files.walk(path, 1))
+		{
+			return stream.filter(Files::isRegularFile).findFirst().isPresent();
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+		return false;
+	}
+	
+	private int getVersion() 
+	{
+		String version = System.getProperty("java.version");
+		if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
+		int dot = version.indexOf(".");
+		return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
+	}
+	
 	public static void main(String...args)
 	{
 		try
@@ -7,7 +7,6 @@ import java.util.AbstractCollection;
 import java.util.function.Consumer;
 #endif

-import speiger.src.collections.PACKAGE.collections.COLLECTION;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -100,7 +99,6 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
 	 * 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
-	 * @deprecated if this is a primitive collection
 	 * @throws java.lang.NullPointerException if the collection is null
 	 */
 	@Override
@@ -5,16 +5,17 @@ import java.util.function.Consumer;
 #if !TYPE_OBJECT

 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.objects.collections.ObjectIterable;
 #else
 import java.util.function.BiFunction;
+import java.util.Comparator;

 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
-import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST;
 import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
 #if !TYPE_BOOLEAN
@@ -157,6 +158,15 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return ITERABLES.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 ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return ITERABLES.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
@@ -50,6 +50,10 @@ public interface COMPARATOR extends Comparator<CLASS_TYPE>
 	{
 		COMPARATOR original;
 		
+		/**
+		 * default constructor
+		 * @param original that is going to be reversed
+		 */
 		public Reversed(COMPARATOR original) {
 			this.original = original;
 		}
@@ -75,7 +75,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	 * The IndexOf implementation iterates over all elements and compares them to the search value.
 	 * @param o the value that the index is searched for.
 	 * @return index of the value that was searched for. -1 if not found
-	 * @deprecated it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
+	 * @note it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
 	 */
 	@Override
 	@Primitive
@@ -103,7 +103,7 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
 	 * The lastIndexOf implementation iterates over all elements and compares them to the search value.
 	 * @param o the value that the index is searched for.
 	 * @return the last index of the value that was searched for. -1 if not found
-	 * @deprecated it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
+	 * @note it is highly suggested not to use this with Primitives because of boxing. But it is still supported because of ObjectComparason that are custom objects and allow to find the contents.
 	 */
 	@Override
 	@Primitive
@@ -188,12 +188,25 @@ public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return list;
 	}

+	/**
+	 * Creates a new ArrayList with a EmptyObject array of the Type requested
+	 * @param c the type of the array
+	 * @param size the initial size of the backing array
+	 * @Type(T)
+	 * @return a typed List
+	 */
+	public static GENERIC_KEY_BRACES ARRAY_LIST KEY_GENERIC_TYPE of(Class<KEY_TYPE> c, int size) {
+		ARRAY_LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		list.data = (KEY_TYPE[])ObjectArrays.newArray(c, size);
+		return list;
+	}
+	
 #endif
 	/**
 	 * Appends the specified element to the end of this list.
 	 *
 	 * @param e element to be appended to this list
-	 * @return <tt>true</tt> (as specified by {@link Collection#add})
+	 * @return true (as specified by {@link Collection#add})
 	 */
 	@Override
 	public boolean add(KEY_TYPE e) {
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.customHash;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,7 +9,6 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-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;
 #endif
@@ -22,9 +20,8 @@ import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.PACKAGE.utils.STRATEGY;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
@@ -60,7 +57,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
@@ -72,7 +68,7 @@ import speiger.src.collections.utils.HashUtil;
 * @Type(T)
 * @ValueType(V) 
 */
-public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -364,20 +360,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public KEY_TYPE FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -621,7 +603,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		values = newValues;
 	}
 	
-	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -861,20 +843,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 		public void clear() {
 			LINKED_CUSTOM_HASH_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -1093,18 +1064,6 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -316,6 +316,7 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
 		for(int i = nullIndex;i >= 0;i--)
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
@@ -325,7 +326,12 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+#else
+		if(containsNull && ((value == null && values[nullIndex] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[nullIndex], value))) return true;
+#endif
+		for(int i = nullIndex-1;i >= 0;i--)
 #if VALUE_OBJECT
 			if(!strategy.equals(keys[i], EMPTY_KEY_VALUE) && EQUALS_VALUE_TYPE(values[i], value)) return true;
 #else
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.hash;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,7 +9,6 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-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;
 #endif
@@ -21,10 +19,9 @@ import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -59,7 +56,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif
 import speiger.src.collections.utils.HashUtil;
@@ -71,7 +67,7 @@ import speiger.src.collections.utils.HashUtil;
 * @Type(T)
 * @ValueType(V)
 */
-public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -368,20 +364,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public KEY_TYPE FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -625,7 +607,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		values = newValues;
 	}
 	
-	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -862,20 +844,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		public void clear() {
 			LINKED_HASH_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -905,9 +876,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 		
 #endif
 		@Override
-		public boolean add(KEY_TYPE o) {
-			throw new UnsupportedOperationException();
-		}
+		public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
@@ -1089,23 +1058,11 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
 			int result = 0;
 			int index = firstIndex;
 			while(index != -1){
-				if(filter.TEST_VALUE(keys[index])) return result++;
+				if(filter.TEST_VALUE(keys[index])) result++;
 				index = (int)links[index];
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -1371,7 +1328,6 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G

 		@Override
 		public void add(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
-		
 	}
 	
 	private class MapIterator {
@@ -287,7 +287,8 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 #if !VALUE_OBJECT
 	@Override
 	public boolean containsValue(VALUE_TYPE value) {
-		for(int i = nullIndex;i >= 0;i--)
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+		for(int i = nullIndex-1;i >= 0;i--)
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && VALUE_EQUALS(values[i], value)) return true;
 		return false;
 	}
@@ -296,7 +297,12 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 	@Override
 	@ValuePrimitive
 	public boolean containsValue(Object value) {
-		for(int i = nullIndex;i >= 0;i--)
+#if VALUE_OBJECT
+		if(containsNull && VALUE_EQUALS(values[nullIndex], value)) return true;
+#else
+		if(containsNull && ((value == null && values[nullIndex] == getDefaultReturnValue()) || EQUALS_VALUE_TYPE(values[nullIndex], value))) return true;
+#endif
+		for(int i = nullIndex-1;i >= 0;i--)
 #if VALUE_OBJECT
 			if(KEY_EQUALS_NOT_NULL(keys[i]) && EQUALS_VALUE_TYPE(values[i], value)) return true;
 #else
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.maps.impl.immutable;

 import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -11,7 +10,6 @@ import java.util.function.BiFunction;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
 #endif
 #if !TYPE_OBJECT && !VALUE_BOOLEAN
@@ -24,11 +22,10 @@ import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 import speiger.src.collections.PACKAGE.functions.function.SINGLE_UNARY_OPERATOR;
 #endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
 import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ARRAYS;
@@ -71,7 +68,6 @@ import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOpera

 #endif
 import speiger.src.collections.objects.lists.ObjectListIterator;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 #endif
 import speiger.src.collections.objects.sets.AbstractObjectSet;
 import speiger.src.collections.objects.sets.ObjectSet;
@@ -85,7 +81,7 @@ import speiger.src.collections.utils.SanityChecks;
 * @Type(T)
 * @ValueType(V)
 */
-public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing keys array */
 	protected transient KEY_TYPE[] keys;
@@ -465,15 +461,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(KEY_TYPE fromKey, KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(KEY_TYPE toKey) { throw new UnsupportedOperationException(); }
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(KEY_TYPE fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public void forEach(BI_CONSUMER KEY_VALUE_GENERIC_TYPE action) {
 		int index = firstIndex;
@@ -597,7 +584,7 @@ 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 SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -810,20 +797,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 		
 		@Override
 		public void clear() { throw new UnsupportedOperationException(); }
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -1024,18 +1000,6 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
 			}
 			return result;
 		}
-		
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -1,6 +1,5 @@
 package speiger.src.collections.PACKAGE.maps.impl.misc;

-import java.util.Comparator;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Consumer;
@@ -10,16 +9,14 @@ import java.util.Objects;

 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.functions.consumer.BI_CONSUMER;
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
 import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
-import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
 import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
-import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
 import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
@@ -32,7 +29,6 @@ import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST_ITERATOR;
 import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 import speiger.src.collections.objects.lists.ObjectListIterator;
 import speiger.src.collections.objects.sets.AbstractObjectSet;
-import speiger.src.collections.objects.sets.ObjectSortedSet;
 import speiger.src.collections.objects.sets.ObjectSet;
 #endif

@@ -43,7 +39,7 @@ import speiger.src.collections.objects.sets.ObjectSet;
 * @Type(T)
 * @ValueType(V)
 */
-public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements SORTED_MAP KEY_VALUE_GENERIC_TYPE, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected long[] links;
@@ -270,20 +266,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		return map;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE subMap(T fromKey, T toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE headMap(T toKey) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_MAP KEY_VALUE_GENERIC_TYPE tailMap(T fromKey) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public T FIRST_ENTRY_KEY() {
 		if(size == 0) throw new NoSuchElementException();
@@ -434,7 +416,7 @@ 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 SORTED_MAP.FastSortedSet KEY_VALUE_GENERIC_TYPE {
+	private class MapEntrySet extends AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE {
 		@Override
 		public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
@@ -559,20 +541,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		public void clear() {
 			LINKED_ENUM_MAP.this.clear();
 		}
-		
-		@Override
-		public Comparator<MAP.Entry KEY_VALUE_GENERIC_TYPE> comparator() {
-			return null;
-		}
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> subSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement, MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> headSet(MAP.Entry KEY_VALUE_GENERIC_TYPE toElement) { throw new UnsupportedOperationException(); }
-		@Override
-		public ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> tailSet(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
-	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE {
+	private final class KeySet extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
 #if TYPE_OBJECT
 		@Override
 		@Deprecated
@@ -685,17 +656,6 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
 		}
 		
 #endif
-		@Override
-		public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-		
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE subSet(T fromElement, T toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE headSet(T toElement) { throw new UnsupportedOperationException(); }
-
-		@Override
-		public SORTED_SET KEY_GENERIC_TYPE tailSet(T fromElement) { throw new UnsupportedOperationException(); }
 	}
 	
 	private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
@@ -363,19 +363,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 	}
 	
 #endif
-	@Override
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }

@@ -1067,14 +1054,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 #endif		
 		@Override
 		public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
@@ -1543,18 +1522,6 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		protected Node KEY_VALUE_GENERIC_TYPE absHighFence() { return (toEnd ? null : (hiInclusive ? map.findHigherNode(hi) : map.findCeilingNode(hi))); }
 		protected Node KEY_VALUE_GENERIC_TYPE absLowFence() { return (fromStart ? null : (loInclusive ?  map.findLowerNode(lo) : map.findFloorNode(lo))); }
 		
-		@Override
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		
@@ -366,19 +366,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 	}
 	
 #endif
-	@Override
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-	@Override
-	public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	@Override
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }

@@ -1125,15 +1112,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 #endif
 		@Override
 		public boolean add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
 			if(map instanceof RB_TREE_MAP) return ((RB_TREE_MAP KEY_VALUE_GENERIC_TYPE)map).keyIterator(fromElement);
@@ -1601,18 +1579,6 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		protected Node KEY_VALUE_GENERIC_TYPE absHighFence() { return (toEnd ? null : (hiInclusive ? map.findHigherNode(hi) : map.findCeilingNode(hi))); }
 		protected Node KEY_VALUE_GENERIC_TYPE absLowFence() { return (fromStart ? null : (loInclusive ?  map.findLowerNode(lo) : map.findFloorNode(lo))); }
 		
-		@Override
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		
@@ -0,0 +1,95 @@
+package speiger.src.collections.PACKAGE.maps.interfaces;
+
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * A type specific ConcurrentMap interface that reduces boxing/unboxing.
+ * Since the interface adds nothing new. It is there just for completion sake.
+ * @Type(T)
+ * @ValueType(V)
+ */
+public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
+{
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.compute(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.computeIfAbsent(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.computeIfPresent(key, mappingFunction);
+	}
+
+	@Override
+	@Primitive
+	public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
+		MAP.super.forEach(action);
+	}
+
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		return MAP.super.merge(key, value, mappingFunction);
+	}
+	
+#if TYPE_OBJECT && VALUE_OBJECT
+	@Override
+	public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
+	@Override
+	public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	@Override
+	public boolean remove(Object key, Object value);
+	@Override
+	public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
+	@Override
+	public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
+	
+#else
+	@Primitive
+	@Override
+	public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
+		return MAP.super.getOrDefault(key, defaultValue);
+	}
+	
+	@Override
+	@Primitive
+	public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+		return MAP.super.putIfAbsent(key, value);
+	}
+	
+	@Override
+	@Deprecated
+	public default boolean remove(Object key, Object value) {
+		return MAP.super.remove(key, value);
+	}
+	
+	@Override
+	@Deprecated
+	public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
+		return MAP.super.replace(key, oldValue, newValue);
+	}
+	
+	@Override
+	@Deprecated
+	public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
+		return MAP.super.replace(key, value);
+	}
+	
+#endif
+	@Override
+	@Deprecated
+	public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
+		MAP.super.replaceAll(mappingFunction);
+	}
+}
@@ -31,6 +31,7 @@ import speiger.src.collections.PACKAGE.maps.impl.immutable.IMMUTABLE_HASH_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
 import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
+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;
@@ -1508,6 +1509,14 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 			return putElements(new LINKED_CUSTOM_HASH_MAPKV_BRACES(size, strategy));
 		}
 		
+		/**
+		 * Builds the Keys and Values into a Concurrent Hash Map
+		 * @return a CONCURRENT_HASH_MAP
+		 */
+		public CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE concurrentMap() {
+			return putElements(new CONCURRENT_HASH_MAPKV_BRACES(size));
+		}
+		
 		/**
 		 * Builds the Keys and Values into a Array Map
 		 * @return a ARRAY_MAP
@@ -1,6 +1,8 @@
 package speiger.src.collections.PACKAGE.maps.interfaces;

 import speiger.src.collections.PACKAGE.utils.maps.MAPS;
+import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
 /**
 * A Special Map Interface giving Access to some really usefull functions
 * The Idea behind this interface is to allow access to functions that give control to the Order of elements.
@@ -98,6 +100,7 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap that is synchronized
 	 * @see MAPS#synchronize
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize() { return MAPS.synchronize(this); }
 	
 	/**
@@ -106,6 +109,7 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap Wrapper that is synchronized
 	 * @see MAPS#synchronize
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE synchronize(Object mutex) { return MAPS.synchronize(this, mutex); }
 	
 	/**
@@ -113,5 +117,22 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
 	 * @return a new SortedMap Wrapper that is unmodifiable
 	 * @see MAPS#unmodifiable
 	 */
+	@Override
 	public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
+	
+	/**
+	 * Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
+	 * @Type(T)
+	 * @ValueType(V)
+	 */
+	interface FastOrderedSet KEY_VALUE_GENERIC_TYPE extends MAP.FastEntrySet KEY_VALUE_GENERIC_TYPE, ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
+		@Override
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator();
+		/**
+		 * Fast iterator that recycles the given Entry object to improve speed and reduce object allocation
+		 * @param fromElement that is going to be started from.
+		 * @return a improved iterator that starts from the desired element
+		 */
+		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator(KEY_TYPE fromElement);
+	}
 }
@@ -22,65 +22,8 @@ import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
 * @note ORDERED_MAP is only extended until 0.6.0 for Compat reasons.
 * The supported classes already implement ORDERED_MAP directly and will remove SORTED_MAP implementations in favor of ORDERED_MAP instead
 */
-public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, ORDERED_MAP KEY_VALUE_GENERIC_TYPE
+public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
 {
-	/**
-	 * A customized put method that allows you to insert into the first index.
-	 * @param key the key that should be inserted
-	 * @param value the value that should be inserted
-	 * @return the previous present or default return value
-	 * @see java.util.Map#put(Object, Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#putAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value);
-	/**
-	 * A customized put method that allows you to insert into the last index. (This may be nessesary depending on the implementation)
-	 * @param key the key that should be inserted
-	 * @param value the value that should be inserted
-	 * @return the previous present or default return value
-	 * @see java.util.Map#put(Object, Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#putAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value);
-	
-	/**
-	 * A specific move method to move a given key/value to the first index.
-	 * @param key that should be moved to the first index
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#moveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean moveToFirst(KEY_TYPE key);
-	/**
-	 * A specific move method to move a given key/value to the last index.
-	 * @param key that should be moved to the first last
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#moveToLast instead (removed in 0.6.0)
-	 */
-	public boolean moveToLast(KEY_TYPE key);
-	
-	/**
-	 * A Specific get method that allows to move teh given key/value int the first index.
-	 * @param key that is searched for
-	 * @return the given value for the requested key or default return value
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#getAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key);
-	/**
-	 * A Specific get method that allows to move teh given key/value int the last index.
-	 * @param key that is searched for
-	 * @return the given value for the requested key or default return value
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_MAP#getAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public VALUE_TYPE getAndMoveToLast(KEY_TYPE key);
-	
 	@Override
 	public COMPARATOR KEY_GENERIC_TYPE comparator();
 	
@@ -227,6 +170,11 @@ public interface SORTED_MAP KEY_VALUE_GENERIC_TYPE extends SortedMap<CLASS_TYPE,
 	interface FastSortedSet KEY_VALUE_GENERIC_TYPE extends MAP.FastEntrySet KEY_VALUE_GENERIC_TYPE, ObjectSortedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
 		@Override
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator();
+		/**
+		 * Fast iterator that recycles the given Entry object to improve speed and reduce object allocation
+		 * @param fromElement that is going to be started from.
+		 * @return a improved iterator that starts from the desired element
+		 */
 		public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator(KEY_TYPE fromElement);
 	}
 }
@@ -106,11 +106,16 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 	@Override
 	public void clear() {
+		if(first != last) {
 #if TYPE_OBJECT
 			Arrays.fill(array, null);
 #endif
 			first = last = 0;
 		}
+		else if(first != 0) {
+			first = last = 0;
+		}
+	}
 	
 	@Override
 	public void enqueue(KEY_TYPE e) {
@@ -152,9 +157,9 @@ public class ARRAY_FIFO_QUEUE KEY_GENERIC_TYPE extends ABSTRACT_PRIORITY_QUEUE K
 	
 	@Override
 	public KEY_TYPE peek(int index) {
-		if(first == last || index < 0 || index > size()) throw new NoSuchElementException();
+		if(first == last || index < 0 || index >= size()) throw new NoSuchElementException();
 		index += first;
-		return index > array.length ? array[index-array.length] : array[index];
+		return index >= array.length ? array[index-array.length] : array[index];
 	}
 	
 	@Override
@@ -295,18 +295,6 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	}
 	
 #endif
-	@Override
-	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-
 	@Override
 	public KEY_TYPE lower(KEY_TYPE e) {
 		Entry KEY_GENERIC_TYPE node = findLowerNode(e);
@@ -1203,15 +1191,6 @@ public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return entry.key;
 		}
 		
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
@@ -3,7 +3,6 @@ package speiger.src.collections.PACKAGE.sets;
 import java.util.Arrays;
 import java.util.Collection;
 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -21,7 +20,6 @@ import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUME
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 import speiger.src.collections.objects.utils.ObjectArrays;
 #endif
@@ -36,7 +34,7 @@ import speiger.src.collections.PACKAGE.utils.ARRAYS;
 * This implementation does not shrink the backing array
 * @Type(T)
 */
-public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing Array */
 	protected transient KEY_TYPE[] data;
@@ -510,31 +508,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		throw new NoSuchElementException();
 	}
 	
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	/**
-	 * Unsupported for now. Implementation is buggy and does not support the Java Standard with these functions.
-	 * It is a Unsorted Sorted Set. Thats why the SubSet implementation will be disabled until a better solution is found.
-	 * To give a simple reason: LinkedHashSets are also not SortedSets even so they could be.
-	 * @throws UnsupportedOperationException because it is not supported
-	 */
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	public ARRAY_SET KEY_GENERIC_TYPE copy() {
 		ARRAY_SET KEY_GENERIC_TYPE set = new ARRAY_SETBRACES();
 		set.data = Arrays.copyOf(data, data.length);
@@ -542,11 +515,6 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() {
-		return null;
-	}
-	
 	@Override
 	public void clear() {
 		size = 0;
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.sets;

 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -15,7 +14,6 @@ import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -34,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks;
 * Extra to that there is a couple quality of life functions provided
 * @Type(T)
 */
-public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
+public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing keys array */
 	protected transient KEY_TYPE[] keys;
@@ -459,18 +457,6 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	@Override
 	public void clear() { throw new UnsupportedOperationException(); }
 	
@@ -1,7 +1,6 @@
 package speiger.src.collections.PACKAGE.sets;

 #if TYPE_OBJECT
-import java.util.Comparator;
 import java.util.function.Consumer;
 import java.util.function.BiFunction;
 #endif
@@ -16,9 +15,6 @@ import speiger.src.collections.PACKAGE.collections.COLLECTION;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
-#if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
-#endif
 import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
 #if !TYPE_OBJECT
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
@@ -37,7 +33,7 @@ import speiger.src.collections.utils.SanityChecks;
 * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
 * @Type(T)
 */
-public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -672,18 +668,6 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int previous = -1;
 		int next = -1;
@@ -1,8 +1,5 @@
 package speiger.src.collections.PACKAGE.sets;

-#if TYPE_OBJECT
-import java.util.Comparator;
-#endif
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
@@ -19,7 +16,6 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
 #if !TYPE_OBJECT
-import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
@@ -38,7 +34,7 @@ import speiger.src.collections.utils.SanityChecks;
 * This implementation of SortedSet does not support SubSet of any kind. It implements the interface due to sortability and first/last access
 * @Type(T)
 */
-public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE, ORDERED_SET KEY_GENERIC_TYPE
+public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE
 {
 	/** The Backing array for links between nodes. Left 32 Bits => Previous Entry, Right 32 Bits => Next Entry */
 	protected transient long[] links;
@@ -643,18 +639,6 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
 		return set;
 	}
 	
-	@Override
-	public COMPARATOR KEY_GENERIC_TYPE comparator() { return null; }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { throw new UnsupportedOperationException(); }
-	
 	private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
 		int previous = -1;
 		int next = -1;
@@ -295,18 +295,6 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 	}
 	
 #endif
-	@Override
-	public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-	
-	@Override
-	public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-
 	@Override
 	public KEY_TYPE lower(KEY_TYPE e) {
 		Entry KEY_GENERIC_TYPE node = findLowerNode(e);
@@ -1264,15 +1252,6 @@ public class RB_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
 			return entry.key;
 		}
 		
-		@Override
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		
 		@Override
 		public SubSet KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
 		
@@ -19,47 +19,8 @@ import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 * @note ORDERED_SET is only extended until 0.6.0 for Compat reasons.
 * The supported classes already implement ORDERED_SET directly and will remove SORTED_SET implementations in favor of ORDERED_SET instead
 */
-public interface SORTED_SET KEY_GENERIC_TYPE extends ORDERED_SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
+public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SortedSet<CLASS_TYPE>
 {
-	
-	/**
-	 * A customized add method that allows you to insert into the first index.
-	 * @param o the element that should be inserted
-	 * @return true if it was added
-	 * @see java.util.Set#add(Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#addAndMoveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean addAndMoveToFirst(KEY_TYPE o);
-	/**
-	 * A customized add method that allows you to insert into the last index.
-	 * @param o the element that should be inserted
-	 * @return true if it was added
-	 * @see java.util.Set#add(Object)
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#addAndMoveToLast instead (removed in 0.6.0)
-	 */
-	public boolean addAndMoveToLast(KEY_TYPE o);
-	
-	/**
-	 * A specific move method to move a given key to the first index.
-	 * @param o that should be moved to the first index
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#moveToFirst instead (removed in 0.6.0)
-	 */
-	public boolean moveToFirst(KEY_TYPE o);
-	/**
-	 * A specific move method to move a given key to the last index.
-	 * @param o that should be moved to the first last
-	 * @return true if the value was moved.
-	 * @note returns false if the value was not present in the first place
-	 * @note some implementations do not support this method
-	 * @deprecated use ORDERED_SET#moveToLast instead (removed in 0.6.0)
-	 */
-	public boolean moveToLast(KEY_TYPE o);
-	
 	/**
 	 * A Type Specific Comparator method
 	 * @return the type specific comparator
@@ -7,15 +7,13 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.LockSupport;
 import java.util.function.Consumer;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 #if !TYPE_OBJECT

 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #else
 import java.util.function.BiFunction;
+import java.util.Comparator;

 #endif
 import speiger.src.collections.PACKAGE.collections.ITERABLE;
@@ -71,15 +69,15 @@ import speiger.src.collections.utils.SanityChecks;
 * The Task Object is also pause-able/Interruptable at any moment during the Processing. <br>
 * 
 * A small example
- * <pre>
- * public void processFiles(ObjectCollection<String> potentialFiles) {
+ * <pre><code>
+ * public void processFiles(ObjectCollection&#60;String&#62; potentialFiles) {
 * 	potentialFiles.asAsync()
 * 		.map(Paths::get).filter(Files::exists) //Modifies the collection (Optional)
 * 		.forEach(Files::delete) //Creates the action (Required)
- * 		.callback(T -> {}} //Callback on completion (Optional)
+ * 		.onCompletion(T -&#62; {}} //Callback on completion (Optional)
 * 		.execute() //Starts the task. (Required)
 * }
- * </pre>
+ * </code></pre>
 * @author Speiger
 * 
 * @Type(T)
@@ -91,7 +89,7 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	
 	/**
 	 * Main Constructor that uses a Iterable to build a Offthread Task.
-	 * @param iterable
+	 * @param iterable that should be processed
 	 */
 	public ASYNC_BUILDER(ITERABLE KEY_GENERIC_TYPE iterable) {
 		this.iterable = iterable;
@@ -99,12 +97,22 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	
 	/**
 	 * Helper constructor.
-	 * @param task
+	 * @param task that had been build
 	 */
 	public ASYNC_BUILDER(BASE_TASK KEY_GENERIC_TYPE task) {
 		this.task = task;
 	}
 	
+	/**
+	 * Helper function that automatically wraps a Iterable into a AsyncBuilder since it forces this collections Iterable.
+	 * @param iterable that should be wrapped
+	 * @Type(T)
+	 * @return a AsyncBuilder with the iterable wrapped
+	 */
+	public static GENERIC_KEY_BRACES ASYNC_BUILDER KEY_GENERIC_TYPE of(Iterable<CLASS_TYPE> iterable) {
+		return new ASYNC_BUILDERBRACES(ITERABLES.wrap(iterable));
+	}
+	
 	/**
 	 * Maps the elements to something else
 	 * @param mapper the mapping function
@@ -165,6 +173,17 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return this;
 	}
 	
+	/**
+	 * Sorts the elements inside of the Iterable.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it, and this will affect the pausing feature.
+	 * @param sorter that sorts the elements.
+	 * @return self with a sorter applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
+		iterable = ITERABLES.sorted(iterable, sorter);
+		return this;
+	}
+	
 	/**
 	 * Allows to preview elements before they are processed
 	 * @param action the action that should be applied
@@ -298,8 +317,9 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * Can only be set after the action was decided on.
 	 * @param executor that executes the task, defaults to {@link SanityChecks#invokeAsyncTask(Runnable) }
 	 * @return self with the executor set
+	 * @note has to be NonNull
 	 */
-	public ASYNC_BUILDER KEY_GENERIC_TYPE executor(@Nonnull Executor executor) {
+	public ASYNC_BUILDER KEY_GENERIC_TYPE executor(Executor executor) {
 		if(task == null) throw new IllegalStateException("Action is missing");
 		task.withExecutor(executor);
 		return this;
@@ -310,8 +330,9 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 	 * The state of the task has to be validated by the callback.
 	 * @param callback that should be notified after completion of the task
 	 * @return self with the callback set
+	 * @note can be null
 	 */
-	public ASYNC_BUILDER KEY_GENERIC_TYPE callback(@Nullable Consumer<TASK KEY_GENERIC_TYPE> callback) {
+	public ASYNC_BUILDER KEY_GENERIC_TYPE onCompletion(Consumer<TASK KEY_GENERIC_TYPE> callback) {
 		if(task == null) throw new IllegalStateException("Action is missing");
 		task.withCallback(callback);
 		return this;
@@ -3,6 +3,8 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Objects;
 #if TYPE_BOOLEAN
 import java.util.concurrent.atomic.AtomicInteger;
+#else if TYPE_OBJECT
+import java.util.Comparator;
 #endif
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
@@ -12,8 +14,11 @@ import speiger.src.collections.PACKAGE.collections.ITERABLE;
 import speiger.src.collections.objects.collections.ObjectIterable;
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 #if !TYPE_BOOLEAN
@@ -164,6 +169,30 @@ public class ITERABLES
 		return new LimitedIterableBRACES(wrap(iterable), limit);
 	}
 	
+	/**
+	 * A Helper function that sorts the Iterable.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterable that should be sorted
+	 * @param sorter that sorts the iterable. Can be null.
+	 * @Type(T)
+	 * @return a sorted iterable.
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE sorted(ITERABLE KEY_GENERIC_TYPE iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIterableBRACES(iterable, sorter);
+	}
+	
+	/**
+	 * A Helper function that sorts the Iterable from a Java Iterable
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterable that should be sorted
+	 * @param sorter that sorts the iterable. Can be null.
+	 * @Type(T)
+	 * @return a sorted iterable.
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE sorted(Iterable<? extends CLASS_TYPE> iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIterableBRACES(wrap(iterable), sorter);
+	}
+	
 	/**
 	 * A Helper function that allows to preview the result of a Iterable.
 	 * @param iterable that should be peeked at
@@ -359,6 +388,42 @@ public class ITERABLES
 #endif
 	}
 	
+	private static class SortedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		COMPARATOR KEY_GENERIC_TYPE sorter;
+		
+		public SortedIterable(ITERABLE KEY_GENERIC_TYPE iterable, COMPARATOR KEY_GENERIC_TYPE sorter) {
+			this.iterable = iterable;
+			this.sorter = sorter;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.sorted(iterable.iterator(), sorter);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(list::add);
+			list.unstableSort(sorter);
+			list.forEach(action);
+		}
+#else
+		@Override
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(list::add);
+			list.unstableSort(sorter);
+			list.forEach(action);
+		}
+#endif
+	}
+	
 	private static class DistinctIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;
@@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.utils;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 #if TYPE_OBJECT
+import java.util.Comparator;
 import java.util.function.CONSUMER;
 #endif

@@ -11,6 +12,7 @@ import speiger.src.collections.PACKAGE.collections.ITERATOR;
 import speiger.src.collections.objects.collections.ObjectIterator;
 import speiger.src.collections.objects.utils.ObjectIterators;
 import speiger.src.collections.PACKAGE.functions.CONSUMER;
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
 import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
@@ -235,6 +237,30 @@ public class ITERATORS
 		return new LimitedIteratorBRACES(wrap(iterator), limit);
 	}
 	
+	/**
+	 * A Helper function that sorts the Iterator beforehand.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterator that should be sorted.
+	 * @param sorter the sorter of the iterator. Can be null.
+	 * @Type(T)
+	 * @return a new sorted iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE sorted(ITERATOR KEY_GENERIC_TYPE iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIteratorBRACES(iterator, sorter);
+	}
+	
+	/**
+	 * A Helper function that sorts the Iterator beforehand from a Java Iterator.
+	 * This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it.
+	 * @param iterator that should be sorted.
+	 * @param sorter the sorter of the iterator. Can be null.
+	 * @Type(T)
+	 * @return a new sorted iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE sorted(Iterator<? extends CLASS_TYPE> iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+		return new SortedIteratorBRACES(wrap(iterator), sorter);
+	}
+	
 	/**
 	 * A Helper function that allows to preview the result of a Iterator.
 	 * @param iterator that should be peeked at
@@ -871,6 +897,35 @@ public class ITERATORS
 		}
 	}
 	
+	private static class SortedIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		ITERATOR KEY_GENERIC_TYPE iterator;
+		COMPARATOR KEY_GENERIC_TYPE sorter;
+		LIST KEY_GENERIC_TYPE sortedElements = null;
+		int index = 0;
+		
+		public SortedIterator(ITERATOR KEY_GENERIC_TYPE iterator, COMPARATOR KEY_GENERIC_TYPE sorter) {
+			this.iterator = iterator;
+			this.sorter = sorter;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			if(sortedElements == null) {
+				boolean hasNext = iterator.hasNext();
+				sortedElements = hasNext ? pour(iterator) : LISTS.empty();
+				if(hasNext) sortedElements.unstableSort(sorter);
+			}
+			return index < sortedElements.size();
+		}
+		
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new IllegalStateException("End of Iterator");
+			return sortedElements.GET_KEY(index++);
+		}
+	}
+	
 	private static class DistinctIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iterator;
@@ -360,18 +360,6 @@ public class SETS
 			s = c;
 		}
 		
-		@Override
-		@Deprecated
-		public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return s.comparator(); }
 		@Override
@@ -557,18 +545,6 @@ public class SETS
 			s = c;
 		}
 		
-		@Override
-		@Deprecated
-		public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
-		@Override
-		@Deprecated
-		public boolean addAndMoveToLast(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToLast(o); } }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.moveToFirst(o); } }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE o) { synchronized(mutex) { return s.moveToLast(o); } }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator(){ synchronized(mutex) { return s.comparator(); } }
 		@Override
@@ -517,24 +517,6 @@ public class MAPS
 			this.map = map;
 		}
 		
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { return map.comparator(); }
 		@Override
@@ -833,24 +815,6 @@ public class MAPS
 			this.map = map;
 		}
 		
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToFirst(key, value); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
-		@Override
-		@Deprecated
-		public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
-		@Override
-		@Deprecated
-		public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToFirst(key); } }
-		@Override
-		@Deprecated
-		public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { synchronized(mutex) { return map.getAndMoveToLast(key); } }
 		@Override
 		public COMPARATOR KEY_GENERIC_TYPE comparator() { synchronized(mutex) { return map.comparator(); } }
 		@Override
@@ -7,6 +7,8 @@ public class HashUtil
 {
 	/** Minimum HashMap Capacity */
 	public static final int DEFAULT_MIN_CAPACITY = 16;
+	/** Minimum ConcurrentHashMap Concurrency */
+	public static final int DEFAULT_MIN_CONCURRENCY = 4;
 	/** Default HashMap Load Factor */
 	public static final float DEFAULT_LOAD_FACTOR = 0.75F;
 	/** HashMap Load Factor with reduced hash collisions but more memory usage */
@@ -123,8 +123,8 @@ public abstract class BaseIntIterableTest
 	@Test
 	public void testStreamMap() {
 		if(getValidIterableTests().contains(IterableTest.STREAM_MAP)) {
-			Integer[] expected = IntStream.of(TEST_ARRAY).mapToObj(Integer::new).toArray(Integer[]::new);
-			Integer[] actual = ObjectIterators.pour(create(TEST_ARRAY).map(Integer::new).iterator()).toArray(Integer[]::new);
+			Integer[] expected = IntStream.of(TEST_ARRAY).mapToObj(Integer::valueOf).toArray(Integer[]::new);
+			Integer[] actual = ObjectIterators.pour(create(TEST_ARRAY).map(Integer::valueOf).iterator()).toArray(Integer[]::new);
 			ObjectArrays.stableSort(actual);
 			Assert.assertArrayEquals(expected, actual);
 		}
@@ -1,5 +1,8 @@
 package speiger.src.collections.objects.list;

+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.function.Function;

@@ -8,14 +11,18 @@ import com.google.common.collect.testing.TestStringListGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.ListFeature;
+import com.google.common.collect.testing.testers.ListListIteratorTester;
+import com.google.common.collect.testing.testers.ListSubListTester;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.ints.lists.CopyOnWriteIntArrayList;
 import speiger.src.collections.ints.lists.ImmutableIntList;
 import speiger.src.collections.ints.lists.IntArrayList;
 import speiger.src.collections.ints.lists.IntLinkedList;
 import speiger.src.collections.ints.lists.IntList;
+import speiger.src.collections.objects.lists.CopyOnWriteObjectArrayList;
 import speiger.src.collections.objects.lists.ImmutableObjectList;
 import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectLinkedList;
@@ -28,9 +35,11 @@ public class ObjectListTests extends TestCase
 		TestSuite suite = new TestSuite("Lists");
 		suite.addTest(suite("ArrayList", T -> new ObjectArrayList<>(T)));
 		suite.addTest(suite("LinkedList", T -> new ObjectLinkedList<>(T)));
+		suite.addTest(copyOnWriteSuite("CopyOnWriteArrayList", T -> new CopyOnWriteObjectArrayList<>(T)));
 		suite.addTest(immutableSuite("ImmutableList", T -> new ImmutableObjectList<>(T)));
 		suite.addTest(intSuite("IntArrayList", IntArrayList::new));
 		suite.addTest(intSuite("IntLinkedList", IntLinkedList::new));
+		suite.addTest(intCopyOnWriteSuite("CopyOnWriteArrayList", CopyOnWriteIntArrayList::new));
 		suite.addTest(intImmutableSuite("IntImmutableList", ImmutableIntList::new));
 		return suite;
 	}
@@ -39,6 +48,10 @@ public class ObjectListTests extends TestCase
 		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionSize.ANY).createTestSuite();
 	}
 	
+	public static Test intCopyOnWriteSuite(String name, Function<int[], IntList> factory) {
+		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).suppressing(suppressForCopyOnWriteArrayList()).withFeatures(ListFeature.SUPPORTS_SET, ListFeature.SUPPORTS_ADD_WITH_INDEX, ListFeature.SUPPORTS_REMOVE_WITH_INDEX, CollectionFeature.SUPPORTS_ADD, CollectionFeature.SUPPORTS_REMOVE, CollectionSize.ANY).createTestSuite();
+	}
+	
 	public static Test intImmutableSuite(String name, Function<int[], IntList> factory) {
 		return ListTestSuiteBuilder.using(new TestIntListGenerator(factory)).named(name).withFeatures(CollectionSize.ANY).createTestSuite();
 	}
@@ -50,10 +63,21 @@ public class ObjectListTests extends TestCase
 		}).named(name).withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
 	}
 	
+	public static Test copyOnWriteSuite(String name, Function<String[], List<String>> factory) {
+		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
+			@Override
+			protected List<String> create(String[] elements) { return factory.apply(elements); }
+		}).named(name).suppressing(suppressForCopyOnWriteArrayList()).withFeatures(ListFeature.SUPPORTS_SET, ListFeature.SUPPORTS_ADD_WITH_INDEX, ListFeature.SUPPORTS_REMOVE_WITH_INDEX, CollectionFeature.SUPPORTS_ADD, CollectionFeature.SUPPORTS_REMOVE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
+	}
+	
 	public static Test immutableSuite(String name, Function<String[], List<String>> factory) {
 		return ListTestSuiteBuilder.using(new TestStringListGenerator() {
 			@Override
 			protected List<String> create(String[] elements) { return factory.apply(elements); }
 		}).named(name).withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionSize.ANY).createTestSuite();
 	}
+	
+	public static Collection<Method> suppressForCopyOnWriteArrayList() {
+		return Arrays.asList(ListSubListTester.getSubListSubListRemoveAffectsOriginalLargeListMethod(), ListListIteratorTester.getListIteratorFullyModifiableMethod());
+	}
 }
@@ -20,6 +20,7 @@ import com.google.common.collect.testing.features.MapFeature;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
+import speiger.src.collections.objects.maps.impl.concurrent.Object2ObjectConcurrentOpenHashMap;
 import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectLinkedOpenCustomHashMap;
 import speiger.src.collections.objects.maps.impl.customHash.Object2ObjectOpenCustomHashMap;
 import speiger.src.collections.objects.maps.impl.hash.Object2ObjectLinkedOpenHashMap;
@@ -42,6 +43,7 @@ public class ObjectMapTests extends TestCase
 		suite.addTest(suite("LinkedHashMap", Object2ObjectLinkedOpenHashMap::new, true));
 		suite.addTest(suite("CustomHashMap", () -> new Object2ObjectOpenCustomHashMap<>(Strategy.INSTANCE), true));
 		suite.addTest(suite("LinkedCustomHashMap", () -> new Object2ObjectLinkedOpenCustomHashMap<>(Strategy.INSTANCE), true));
+		suite.addTest(suite("ConcurrentHashMap", Object2ObjectConcurrentOpenHashMap::new, true));
 		suite.addTest(navigableSuite("RBTreeMap_NonNull", Object2ObjectRBTreeMap::new, false));
 		suite.addTest(navigableSuite("AVLTreeMap_NonNull", Object2ObjectAVLTreeMap::new, false));
 		suite.addTest(navigableSuite("RBTreeMap_Null", () -> new Object2ObjectRBTreeMap<>(new NullFriendlyComparator()), true));
Author	SHA1	Message	Date
Speiger	04f628fcc1	Pushing release	2022-04-21 17:41:50 +02:00
Speiger	5fa26bfbf3	New Stuff -Fixed: Crash with FIFOQueues peek function when loops were applied. -Fixed: FIFOQueues clean function was doing unessesary extra work. -Added: Stream Overrides functions now support sorted. -Updated: Changelog. -Added: A couple more badges because why not.	2022-04-21 17:25:23 +02:00
Speiger	4d3eaaf604	removing SolarCloud code	2022-04-19 17:16:53 +02:00
Speiger	33ab7c48bf	hopefully doesn't filter anything. Last attempt	2022-04-19 17:10:57 +02:00
Speiger	1f4784c75e	Testing single task requirement	2022-04-19 16:58:22 +02:00
Speiger	ae5a4ea818	Readded caching	2022-04-19 16:33:16 +02:00
Speiger	5d66f7b453	Update Code compare	2022-04-19 16:11:20 +02:00
Speiger	12af656150	Updated Task Name	2022-04-19 16:04:20 +02:00
Speiger	603ff3df0f	Fixed code compare	2022-04-19 15:52:41 +02:00
Speiger	b712981718	Code quality test	2022-04-19 15:51:01 +02:00
Speiger	863d1a1027	Updated Readme.	2022-04-18 21:41:55 +02:00
Speiger	6287da8efe	ReadMe restructuring.	2022-04-18 09:06:32 +02:00
Speiger	c27e852ccb	typo missed by the spellchecker...	2022-04-17 20:39:06 +02:00
Speiger	0157765628	Hotfix.	2022-04-17 20:24:31 +02:00
Speiger	8689037ceb	Documentation update	2022-04-17 20:21:48 +02:00
Speiger	03a8914986	Completion Jitpack Integration	2022-04-14 09:51:36 +02:00
Speiger	26b9d6706d	Fixed Classification	2022-04-14 09:34:16 +02:00
Speiger	a21d4a9eb6	Fixing Jitpack Publishing	2022-04-14 09:24:13 +02:00
Speiger	212d614ebd	Trying switching Jitpack Java version.	2022-04-14 09:19:27 +02:00
Speiger	bcba3ccde0	Another try	2022-04-14 09:13:53 +02:00
Speiger	b42ad76372	Jitpack Test	2022-04-14 09:12:03 +02:00
Speiger	f95565771a	0.6.0 Release Commit	2022-04-14 07:56:39 +02:00
Speiger	3d6cbf5ac1	Finishing touches for the 0.6.0 release.	2022-04-14 07:29:32 +02:00
Speiger	fc5d43e14b	Updated Changelog.	2022-04-14 06:06:35 +02:00
Speiger	b3264748cd	Added Author to module Info.	2022-04-14 05:47:19 +02:00
Speiger	ede40f06d0	Small fixes. -Fixed: Some imports. -Fixed: containsValue for OpenHashMap was not checking nullEntry properly	2022-04-14 05:37:41 +02:00
Speiger	e69c675f82	Fixed bug with linux & cleanup of the java version detector	2022-04-13 02:58:35 +02:00
Speiger	17c1c90957	Added Module-Info support	2022-04-13 02:54:03 +02:00
Speiger	c6f2f71f6c	Switching to a new lock to make read operations actually concurrent.	2022-04-13 02:00:52 +02:00
Speiger	d2c7c151bc	Implemented tests. -Added: ConcurrentHashMap test suite -Fixed: Bugs found in ConcurrentHashMaps with the iterator and clear function.	2022-04-12 08:08:17 +02:00
Speiger	4448eca787	Finishing ConcurrentHashMap implementation, next tests	2022-04-12 06:06:18 +02:00
Speiger	0350a77dff	Finishing the ConcurrentMap implementation This though isn't finishing the rest because the interface still needs to be implemented. -Added: Rest of the ConcurrentMap implementation -Fixed: LinkedOpenHashMap Count method was returning prematurely.	2022-04-11 03:20:28 +02:00
Speiger	4f98c599df	New Features. -Added: ArrayList.of(CLASS, size) function that allows to preallocate the size of the generic list. -Updated: ListTests suppressors only suprres what they need to. -Added: Start of the ConcurrentHashMap implementation (based on Guavas implementation) Note that the ConcurrentHashMap implementation is just started not finished and still needs a lot of work, but the base code - any subclasses is technically finished. The implementation is also using linkedMaps to have faster iteration performance.	2022-04-10 15:49:16 +02:00
Speiger	103b2407d2	Updated Changelog	2022-04-09 04:23:57 +02:00
Speiger	059da9be12	New Features -Added: CopyOnWriteArrayList -Added: UnitTests for CopyOnWriteArrayLists	2022-04-09 03:56:54 +02:00
Speiger	3cac3a997e	And hopefully the last javaDoc fixes	2022-04-08 00:24:37 +02:00
Speiger	3ffb001c73	More fixes -Fixed: More javadoc fixes -Fixed: BaseIntIterableTest no longer uses a deprecated function	2022-04-08 00:13:51 +02:00
Speiger	2810a6f952	Small fixes -Fixed: JavaDoc -Changed: callback is now called onCompletion	2022-04-08 00:00:45 +02:00
Speiger	166362334b	Added gradle now uses the java version it runs on.	2022-04-07 20:26:53 +02:00
Speiger	d3f9103ebf	Adding Logger for testings	2022-04-07 20:19:47 +02:00
Speiger	1c5507d4a5	Switching to local properties	2022-04-07 20:16:59 +02:00
Speiger	5e3cd9f484	Trying out something with github actions	2022-04-07 20:14:23 +02:00
Speiger	f27b884b6a	Moving to a more up to date system. -Changed: Moved to gradle 7.3 for java17 support of the project. -Changed: Moved to maven-publish plugin and added a bit more info to the poms.	2022-04-07 16:00:58 +02:00
Speiger	769a9d8ea5	Upgraded gradle version to 6.3 for a test	2022-04-07 13:32:04 +02:00
Speiger	9499a7f0e0	Setup matrix so multiple java versions are tested.	2022-04-07 13:27:12 +02:00
Speiger	ca38583f96	Fixed Java11 Incompat	2022-04-07 00:14:09 +02:00