ObjectArrays (Primitive-Collections 0.8.0 API)

java.lang.Object
- speiger.src.collections.objects.utils.ObjectArrays

public class ObjectArrays
extends java.lang.Object

A Helper class for Arrays

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BASE_THRESHOLD` Default Limit for Insertion/Selection Sort
`static java.lang.Object[]`	`EMPTY_ARRAY` Empty Array Reference used for Uninitialized Collections
`static int`	`PARALLEL_THRESHOLD` Default Threshold for Multithreaded Sorting Algorythm options

Constructor Summary

Constructors
Constructor and Description

ObjectArrays()

Constructors
Constructor and Description
`ObjectArrays()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> T[]`	`heapify(T[] data, int size, java.util.Comparator<? super T> comp)` Helper function to create a Heap out of an array.
`static <T> T[]`	`insertionSort(T[] array)` Sorts an array according to the natural ascending order using InsertionSort,
`static <T> T[]`	`insertionSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
`static <T> void`	`insertionSort(T[] array, int length)` Sorts an array according to the natural ascending order using InsertionSort,
`static <T> void`	`insertionSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
`static <T> void`	`insertionSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using InsertionSort,
`static <T> void`	`insertionSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
`static <T> T[]`	`memFreeMergeSort(T[] array)` Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`memFreeMergeSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`memFreeMergeSort(T[] array, int length)` Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`memFreeMergeSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`memFreeMergeSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`memFreeMergeSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> T[]`	`mergeSort(T[] array)` Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> T[]`	`mergeSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`mergeSort(T[] array, int length)` Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`mergeSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`mergeSort(T[] array, T[] supp, int from, int to)` Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`mergeSort(T[] array, T[] supp, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> T[]`	`newArray(java.lang.Class<T> clz, int length)` Function to create a new Array of a given size
`static <T> void`	`parallelMemFreeMergeSort(T[] array)` Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMemFreeMergeSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMemFreeMergeSort(T[] array, int length)` Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMemFreeMergeSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMemFreeMergeSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMemFreeMergeSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
`static <T> void`	`parallelMergeSort(T[] array)` Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelMergeSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelMergeSort(T[] array, int length)` Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelMergeSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelMergeSort(T[] array, T[] supp, int from, int to)` Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelMergeSort(T[] array, T[] supp, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
`static <T> void`	`parallelQuickSort(T[] array)` Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`parallelQuickSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`parallelQuickSort(T[] array, int length)` Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`parallelQuickSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`parallelQuickSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`parallelQuickSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> T[]`	`pour(ObjectIterator<T> iter)` A Helper function that pours all elements of a iterator into a Array
`static <T> T[]`	`pour(ObjectIterator<T> iter, int max)` A Helper function that pours all elements of a iterator into a Array
`static <T,E> E[]`	`pour(ObjectIterator<T> iter, java.util.function.IntFunction<E[]> action)` A Helper function that pours all elements of a iterator into a Array
`static <T,E> E[]`	`pour(ObjectIterator<T> iter, int max, java.util.function.IntFunction<E[]> action)` A Helper function that pours all elements of a iterator into a Array
`static <T> T[]`	`quickSort(T[] array)` Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> T[]`	`quickSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`quickSort(T[] array, int length)` Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`quickSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`quickSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> void`	`quickSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
`static <T> T[]`	`reverse(T[] array)` Simple Array Reversal method
`static <T> T[]`	`reverse(T[] array, int length)` Simple Array Reversal method
`static <T> T[]`	`reverse(T[] array, int offset, int length)` Simple Array Reversal method
`static <T> T[]`	`selectionSort(T[] array)` Sorts an array according to the natural ascending order using Selection Sort,
`static <T> T[]`	`selectionSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
`static <T> void`	`selectionSort(T[] array, int length)` Sorts an array according to the natural ascending order using Selection Sort,
`static <T> void`	`selectionSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
`static <T> void`	`selectionSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order using Selection Sort,
`static <T> void`	`selectionSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
`static <T> int`	`shiftDown(T[] data, int size, int index, java.util.Comparator<? super T> comp)` Method to validate if the current value is the lowest value in the heap
`static <T> int`	`shiftUp(T[] data, int index, java.util.Comparator<? super T> comp)` Method to sort a specific value into the heap.
`static <T> T[]`	`shuffle(T[] array)` Simple Shuffle method for Arrays.
`static <T> T[]`	`shuffle(T[] array, int length)` Simple Shuffle method for Arrays.
`static <T> T[]`	`shuffle(T[] array, int offset, int length)` Simple Shuffle method for Arrays.
`static <T> T[]`	`shuffle(T[] array, int offset, int length, java.util.Random random)` Simple Shuffle method for Arrays.
`static <T> T[]`	`shuffle(T[] array, int length, java.util.Random random)` Simple Shuffle method for Arrays.
`static <T> T[]`	`shuffle(T[] array, java.util.Random random)` Simple Shuffle method for Arrays.
`static <T> T[]`	`stableSort(T[] array)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> T[]`	`stableSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`stableSort(T[] array, int length)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`stableSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`stableSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`stableSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> T[]`	`unstableSort(T[] array)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> T[]`	`unstableSort(T[] array, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`unstableSort(T[] array, int length)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`unstableSort(T[] array, int length, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`unstableSort(T[] array, int from, int to)` Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
`static <T> void`	`unstableSort(T[] array, int from, int to, java.util.Comparator<T> comp)` Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - BASE_THRESHOLD
```
public static final int BASE_THRESHOLD
```
    Default Limit for Insertion/Selection Sort
    
    See Also:
    
    Constant Field Values
  - PARALLEL_THRESHOLD
```
public static final int PARALLEL_THRESHOLD
```
    Default Threshold for Multithreaded Sorting Algorythm options
    
    See Also:
    
    Constant Field Values
  - EMPTY_ARRAY
```
public static final java.lang.Object[] EMPTY_ARRAY
```
    Empty Array Reference used for Uninitialized Collections
- Constructor Detail
  - ObjectArrays
```
public ObjectArrays()
```
- Method Detail
  - newArray
```
public static <T> T[] newArray(java.lang.Class<T> clz,
                               int length)
```
    Function to create a new Array of a given size
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    clz - the class type of array that is requested
    
    length - the lenght the array should be.
    
    Returns:
    
    a Array with the requested type and length
  - pour
```
public static <T> T[] pour(ObjectIterator<T> iter)
```
    A Helper function that pours all elements of a iterator into a Array
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    iter - the elements that should be gathered.
    
    Returns:
    
    array with all elements of the iterator
  - pour
```
public static <T> T[] pour(ObjectIterator<T> iter,
                           int max)
```
    A Helper function that pours all elements of a iterator into a Array
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    iter - the elements that should be gathered.
    
    max - how many elements should be added
    
    Returns:
    
    array with all requested elements of the iterator
  - pour
```
public static <T,E> E[] pour(ObjectIterator<T> iter,
                             java.util.function.IntFunction<E[]> action)
```
    A Helper function that pours all elements of a iterator into a Array
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    iter - the elements that should be gathered.
    
    action - that is creating the Array to be poured into
    
    Returns:
    
    array with all elements of the iterator
  - pour
```
public static <T,E> E[] pour(ObjectIterator<T> iter,
                             int max,
                             java.util.function.IntFunction<E[]> action)
```
    A Helper function that pours all elements of a iterator into a Array
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    iter - the elements that should be gathered.
    
    max - how many elements should be added
    
    action - that is creating the Array to be poured into
    
    Returns:
    
    array with all requested elements of the iterator
  - shiftDown
```
public static <T> int shiftDown(T[] data,
                                int size,
                                int index,
                                java.util.Comparator<? super T> comp)
```
    Method to validate if the current value is the lowest value in the heap
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    data - the current heap.
    
    size - the size of the heap
    
    index - the index that should be validated
    
    comp - the comparator to sort the heap. Can be null
    
    Returns:
    
    the index the element was shifted to
  - shiftUp
```
public static <T> int shiftUp(T[] data,
                              int index,
                              java.util.Comparator<? super T> comp)
```
    Method to sort a specific value into the heap.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    data - the heap itself.
    
    index - that should be heapified.
    
    comp - the comparator to sort the heap. Can be null
    
    Returns:
    
    the index the element was shifted to
  - heapify
```
public static <T> T[] heapify(T[] data,
                              int size,
                              java.util.Comparator<? super T> comp)
```
    Helper function to create a Heap out of an array.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    data - the array to heapify
    
    size - the current size of elements within the array.
    
    comp - the Comparator to sort the array. Can be null
    
    Returns:
    
    the input array
  - shuffle
```
public static <T> T[] shuffle(T[] array)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    Returns:
    
    the provided sorted array
    
    Note:
    
    This uses the SanityChecks#getRandom
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              int length)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    length - the length of the array
    
    Returns:
    
    the provided sorted array
    
    Note:
    
    This uses the SanityChecks#getRandom
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              int offset,
                              int length)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    offset - the start array
    
    length - the length of the array
    
    Returns:
    
    the provided sorted array
    
    Note:
    
    This uses the SanityChecks#getRandom
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              java.util.Random random)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    random - the Random Number Generator that should be used for the shuffling
    
    Returns:
    
    the provided sorted array
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              int length,
                              java.util.Random random)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    length - the length of the array
    
    random - the Random Number Generator that should be used for the shuffling
    
    Returns:
    
    the provided sorted array
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              int offset,
                              int length,
                              java.util.Random random)
```
    Simple Shuffle method for Arrays.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the elements that should be shuffled
    
    offset - the start array
    
    length - the length of the array
    
    random - the Random Number Generator that should be used for the shuffling
    
    Returns:
    
    the provided sorted array
  - reverse
```
public static <T> T[] reverse(T[] array)
```
    Simple Array Reversal method
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the Array that should flip
    
    Returns:
    
    the provided array
  - reverse
```
public static <T> T[] reverse(T[] array,
                              int length)
```
    Simple Array Reversal method
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the Array that should flip
    
    length - the length of the array
    
    Returns:
    
    the provided array
  - reverse
```
public static <T> T[] reverse(T[] array,
                              int offset,
                              int length)
```
    Simple Array Reversal method
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the Array that should flip
    
    length - the length of the array
    
    offset - the start of the array
    
    Returns:
    
    the provided array
  - stableSort
```
public static <T> T[] stableSort(T[] array,
                                 java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array.
  - stableSort
```
public static <T> void stableSort(T[] array,
                                  int length,
                                  java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - stableSort
```
public static <T> void stableSort(T[] array,
                                  int from,
                                  int to,
                                  java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - stableSort
```
public static <T> T[] stableSort(T[] array)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - stableSort
```
public static <T> void stableSort(T[] array,
                                  int length)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - stableSort
```
public static <T> void stableSort(T[] array,
                                  int from,
                                  int to)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - unstableSort
```
public static <T> T[] unstableSort(T[] array,
                                   java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array
  - unstableSort
```
public static <T> void unstableSort(T[] array,
                                    int length,
                                    java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - unstableSort
```
public static <T> void unstableSort(T[] array,
                                    int from,
                                    int to,
                                    java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - unstableSort
```
public static <T> T[] unstableSort(T[] array)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - unstableSort
```
public static <T> void unstableSort(T[] array,
                                    int length)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - unstableSort
```
public static <T> void unstableSort(T[] array,
                                    int from,
                                    int to)
```
    Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - insertionSort
```
public static <T> T[] insertionSort(T[] array,
                                    java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array
  - insertionSort
```
public static <T> void insertionSort(T[] array,
                                     int length,
                                     java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - insertionSort
```
public static <T> void insertionSort(T[] array,
                                     int from,
                                     int to,
                                     java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - insertionSort
```
public static <T> T[] insertionSort(T[] array)
```
    Sorts an array according to the natural ascending order using InsertionSort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - insertionSort
```
public static <T> void insertionSort(T[] array,
                                     int length)
```
    Sorts an array according to the natural ascending order using InsertionSort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - insertionSort
```
public static <T> void insertionSort(T[] array,
                                     int from,
                                     int to)
```
    Sorts an array according to the natural ascending order using InsertionSort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - selectionSort
```
public static <T> T[] selectionSort(T[] array,
                                    java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array
  - selectionSort
```
public static <T> void selectionSort(T[] array,
                                     int length,
                                     java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - selectionSort
```
public static <T> void selectionSort(T[] array,
                                     int from,
                                     int to,
                                     java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - selectionSort
```
public static <T> T[] selectionSort(T[] array)
```
    Sorts an array according to the natural ascending order using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - selectionSort
```
public static <T> void selectionSort(T[] array,
                                     int length)
```
    Sorts an array according to the natural ascending order using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - selectionSort
```
public static <T> void selectionSort(T[] array,
                                     int from,
                                     int to)
```
    Sorts an array according to the natural ascending order using Selection Sort,
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - mergeSort
```
public static <T> T[] mergeSort(T[] array,
                                java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array
  - mergeSort
```
public static <T> void mergeSort(T[] array,
                                 int length,
                                 java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - mergeSort
```
public static <T> void mergeSort(T[] array,
                                 T[] supp,
                                 int from,
                                 int to,
                                 java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    supp - the auxillary array that is used to simplify the sorting
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - mergeSort
```
public static <T> T[] mergeSort(T[] array)
```
    Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - mergeSort
```
public static <T> void mergeSort(T[] array,
                                 int length)
```
    Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - mergeSort
```
public static <T> void mergeSort(T[] array,
                                 T[] supp,
                                 int from,
                                 int to)
```
    Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    supp - the auxillary array that is used to simplify the sorting
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array,
                                         int length,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array,
                                         T[] supp,
                                         int from,
                                         int to,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    supp - the auxillary array that is used to simplify the sorting
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array)
```
    Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array,
                                         int length)
```
    Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMergeSort
```
public static <T> void parallelMergeSort(T[] array,
                                         T[] supp,
                                         int from,
                                         int to)
```
    Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    supp - the auxillary array that is used to simplify the sorting
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - memFreeMergeSort
```
public static <T> void memFreeMergeSort(T[] array,
                                        java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
  - memFreeMergeSort
```
public static <T> void memFreeMergeSort(T[] array,
                                        int length,
                                        java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - memFreeMergeSort
```
public static <T> void memFreeMergeSort(T[] array,
                                        int from,
                                        int to,
                                        java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - memFreeMergeSort
```
public static <T> T[] memFreeMergeSort(T[] array)
```
    Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - memFreeMergeSort
```
public static <T> void memFreeMergeSort(T[] array,
                                        int length)
```
    Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - memFreeMergeSort
```
public static <T> void memFreeMergeSort(T[] array,
                                        int from,
                                        int to)
```
    Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array,
                                                java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int length,
                                                java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int from,
                                                int to,
                                                java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array)
```
    Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int length)
```
    Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelMemFreeMergeSort
```
public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int from,
                                                int to)
```
    Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - quickSort
```
public static <T> T[] quickSort(T[] array,
                                java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Returns:
    
    input array
  - quickSort
```
public static <T> void quickSort(T[] array,
                                 int length,
                                 java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
  - quickSort
```
public static <T> void quickSort(T[] array,
                                 int from,
                                 int to,
                                 java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
  - quickSort
```
public static <T> T[] quickSort(T[] array)
```
    Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Returns:
    
    input array
  - quickSort
```
public static <T> void quickSort(T[] array,
                                 int length)
```
    Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
  - quickSort
```
public static <T> void quickSort(T[] array,
                                 int from,
                                 int to)
```
    Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array,
                                         int length,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array,
                                         int from,
                                         int to,
                                         java.util.Comparator<T> comp)
```
    Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    comp - the Comparator that decides the sorting order
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array)
```
    Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array,
                                         int length)
```
    Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    length - the maxmium size of the array to be sorted
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed
  - parallelQuickSort
```
public static <T> void parallelQuickSort(T[] array,
                                         int from,
                                         int to)
```
    Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.
    
    Type Parameters:
    
    T - the keyType of array that the operation should be applied
    
    Parameters:
    
    array - the array that needs to be sorted
    
    from - where the array should be sorted from
    
    to - where the array should be sorted to
    
    Note:
    
    This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

Class ObjectArrays

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BASE_THRESHOLD

PARALLEL_THRESHOLD

EMPTY_ARRAY

Constructor Detail

ObjectArrays

Method Detail

newArray

pour

pour

pour

pour

shiftDown

shiftUp

heapify

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

reverse

reverse

reverse

stableSort

stableSort

stableSort

stableSort

stableSort

stableSort

unstableSort

unstableSort

unstableSort

unstableSort

unstableSort

unstableSort

insertionSort

insertionSort

insertionSort

insertionSort

insertionSort

insertionSort

selectionSort

selectionSort

selectionSort

selectionSort

selectionSort

selectionSort

mergeSort

mergeSort

mergeSort

mergeSort

mergeSort

mergeSort

parallelMergeSort

parallelMergeSort

parallelMergeSort

parallelMergeSort

parallelMergeSort

parallelMergeSort

memFreeMergeSort

memFreeMergeSort

memFreeMergeSort

memFreeMergeSort

memFreeMergeSort

memFreeMergeSort

parallelMemFreeMergeSort

parallelMemFreeMergeSort

parallelMemFreeMergeSort

parallelMemFreeMergeSort

parallelMemFreeMergeSort

parallelMemFreeMergeSort

quickSort

quickSort

quickSort