ObjectHeapPriorityQueue (Primitive-Collections 0.7.0 API)

java.lang.Object
- speiger.src.collections.objects.queues.AbstractObjectPriorityQueue<T>
- - speiger.src.collections.objects.queues.ObjectHeapPriorityQueue<T>

Type Parameters:

T - the type of elements maintained by this Collection

All Implemented Interfaces:

java.lang.Iterable<T>, ObjectIterable<T>, ObjectPriorityQueue<T>
```
public class ObjectHeapPriorityQueue<T>
extends AbstractObjectPriorityQueue<T>
```
A Simple Heap base Priority Queue implementation It is a ArrayBased Alternative to TreeSets that has less object allocations

Constructor Summary

Constructors
Constructor and Description
`ObjectHeapPriorityQueue()` Default Constructor
`ObjectHeapPriorityQueue(java.util.Comparator<? super T> comp)` Constructor using custom sorter
`ObjectHeapPriorityQueue(int size)` Constructor with a Min Capacity
`ObjectHeapPriorityQueue(int size, java.util.Comparator<? super T> comp)` Constructor with a Min Capacity and custom Sorter
`ObjectHeapPriorityQueue(ObjectCollection<T> c)` Constructor using a Collection
`ObjectHeapPriorityQueue(ObjectCollection<T> c, java.util.Comparator<? super T> comp)` Constructor using a Collection and a custom sorter
`ObjectHeapPriorityQueue(T[] array)` Constructor using a initial array
`ObjectHeapPriorityQueue(T[] array, java.util.Comparator<? super T> comp)` Constructor using a initial array and a custom sorter
`ObjectHeapPriorityQueue(T[] array, int size)` Constructor using a initial array
`ObjectHeapPriorityQueue(T[] array, int size, java.util.Comparator<? super T> comp)` Constructor using a initial array and a custom sorter

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` clears all elements within the PriorityQueue, this does not resize the backing arrays
`java.util.Comparator<? super T>`	`comparator()`
`ObjectHeapPriorityQueue<T>`	`copy()` A Function that does a shallow clone of the PriorityQueue itself.
`int`	`count(Object2BooleanFunction<T> filter)` Helper function to reduce stream usage that allows to count the valid elements.
`T`	`dequeue()` Method to extract a element from the PriorityQueue
`void`	`enqueue(T e)` Method to insert a element into the PriorityQueue
`T`	`findFirst(Object2BooleanFunction<T> filter)` Helper function to reduce stream usage that allows to filter for the first match.
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`<E> void`	`forEach(E input, ObjectObjectConsumer<E,T> action)` Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
`ObjectIterator<T>`	`iterator()` Returns an iterator over elements of type `T`.
`boolean`	`matchesAll(Object2BooleanFunction<T> filter)` Helper function to reduce stream usage that allows to filter for all matches.
`boolean`	`matchesAny(Object2BooleanFunction<T> filter)` Helper function to reduce stream usage that allows to filter for any matches.
`boolean`	`matchesNone(Object2BooleanFunction<T> filter)` Helper function to reduce stream usage that allows to filter for no matches.
`void`	`onChanged()` Allows to notify the Queue to be revalidate its data
`T`	`peek(int index)` Peeking function to see whats inside the queue.
`<E> E`	`reduce(E identity, java.util.function.BiFunction<E,T,E> operator)` Performs a reduction on the elements of this Iterable
`T`	`reduce(ObjectObjectUnaryOperator<T,T> operator)` Performs a reduction on the elements of this Iterable
`boolean`	`removeFirst(T e)` Removes the first found element in the queue
`boolean`	`removeLast(T e)` Removes the last found element in the queue
`int`	`size()`
`<E> E[]`	`toArray(E[] input)` A method to drop the contents of the Queue without clearing the queue
`static <T> ObjectHeapPriorityQueue<T>`	`wrap(T[] array)` Wrapping method to help serialization
`static <T> ObjectHeapPriorityQueue<T>`	`wrap(T[] array, java.util.Comparator<? super T> comp)` Wrapping method to help serialization, using a custom sorter
`static <T> ObjectHeapPriorityQueue<T>`	`wrap(T[] array, int size)` Wrapping method to help serialization
`static <T> ObjectHeapPriorityQueue<T>`	`wrap(T[] array, int size, java.util.Comparator<? super T> comp)` Wrapping method to help serialization, using a custom sorter

Methods inherited from class speiger.src.collections.objects.queues.AbstractObjectPriorityQueue
equals, hashCode, toString

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

Methods inherited from interface speiger.src.collections.objects.queues.ObjectPriorityQueue
enqueueAll, enqueueAll, enqueueAll, enqueueAll, enqueueAll, first, isEmpty, synchronizeQueue, synchronizeQueue, toArray, toArray

Methods inherited from interface speiger.src.collections.objects.collections.ObjectIterable
arrayflatMap, asAsync, distinct, filter, flatMap, limit, map, peek, pour, pourAsList, pourAsSet, sorted, spliterator

- Constructor Detail
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue()
```
    Default Constructor
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(java.util.Comparator<? super T> comp)
```
    Constructor using custom sorter
    
    Parameters:
    
    comp - Comparator to sort the Array. Can be null
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(int size)
```
    Constructor with a Min Capacity
    
    Parameters:
    
    size - the initial capacity of the backing array
    
    Throws:
    
    java.lang.IllegalStateException - if the initial size is smaller 0
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(int size,
                               java.util.Comparator<? super T> comp)
```
    Constructor with a Min Capacity and custom Sorter
    
    Parameters:
    
    size - the initial capacity of the backing array
    
    comp - Comparator to sort the Array. Can be null
    
    Throws:
    
    java.lang.IllegalStateException - if the initial size is smaller 0
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(T[] array)
```
    Constructor using a initial array
    
    Parameters:
    
    array - the Array that should be used
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(T[] array,
                               int size)
```
    Constructor using a initial array
    
    Parameters:
    
    array - the Array that should be used
    
    size - the amount of elements found within the array
    
    Throws:
    
    java.lang.NegativeArraySizeException - if size is smaller then 0
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(T[] array,
                               java.util.Comparator<? super T> comp)
```
    Constructor using a initial array and a custom sorter
    
    Parameters:
    
    array - the Array that should be used
    
    comp - Comparator to sort the Array. Can be null
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(T[] array,
                               int size,
                               java.util.Comparator<? super T> comp)
```
    Constructor using a initial array and a custom sorter
    
    Parameters:
    
    array - the Array that should be used
    
    size - the amount of elements found within the array
    
    comp - Comparator to sort the Array. Can be null
    
    Throws:
    
    java.lang.NegativeArraySizeException - if size is smaller then 0
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(ObjectCollection<T> c)
```
    Constructor using a Collection
    
    Parameters:
    
    c - the Collection that should be used
  - ObjectHeapPriorityQueue
```
public ObjectHeapPriorityQueue(ObjectCollection<T> c,
                               java.util.Comparator<? super T> comp)
```
    Constructor using a Collection and a custom sorter
    
    Parameters:
    
    c - the Collection that should be used
    
    comp - Comparator to sort the Array. Can be null
- Method Detail
  - wrap
```
public static <T> ObjectHeapPriorityQueue<T> wrap(T[] array)
```
    Wrapping method to help serialization
    
    Type Parameters:
    
    T - the type of elements maintained by this Collection
    
    Parameters:
    
    array - the array that should be used
    
    Returns:
    
    a HeapPriorityQueue containing the original input array
  - wrap
```
public static <T> ObjectHeapPriorityQueue<T> wrap(T[] array,
                                                  int size)
```
    Wrapping method to help serialization
    
    Type Parameters:
    
    T - the type of elements maintained by this Collection
    
    Parameters:
    
    array - the array that should be used
    
    size - the amount of elements within the array
    
    Returns:
    
    a HeapPriorityQueue containing the original input array
  - wrap
```
public static <T> ObjectHeapPriorityQueue<T> wrap(T[] array,
                                                  java.util.Comparator<? super T> comp)
```
    Wrapping method to help serialization, using a custom sorter
    
    Type Parameters:
    
    T - the type of elements maintained by this Collection
    
    Parameters:
    
    array - the array that should be used
    
    comp - Comparator to sort the Array. Can be null
    
    Returns:
    
    a HeapPriorityQueue containing the original input array
  - wrap
```
public static <T> ObjectHeapPriorityQueue<T> wrap(T[] array,
                                                  int size,
                                                  java.util.Comparator<? super T> comp)
```
    Wrapping method to help serialization, using a custom sorter
    
    Type Parameters:
    
    T - the type of elements maintained by this Collection
    
    Parameters:
    
    array - the array that should be used
    
    size - the amount of elements within the array
    
    comp - Comparator to sort the Array. Can be null
    
    Returns:
    
    a HeapPriorityQueue containing the original input array
  - size
```
public int size()
```
    Returns:
    
    the amount of elements that are stored in the PriorityQueue
  - clear
```
public void clear()
```
    Description copied from interface: ObjectPriorityQueue
    
    clears all elements within the PriorityQueue, this does not resize the backing arrays
  - iterator
```
public ObjectIterator<T> iterator()
```
    Description copied from interface: ObjectIterable
    
    Returns an iterator over elements of type T.
    
    Returns:
    
    draining iterator of the PriorityQueue
  - enqueue
```
public void enqueue(T e)
```
    Description copied from interface: ObjectPriorityQueue
    
    Method to insert a element into the PriorityQueue
    
    Parameters:
    
    e - the element that should be inserted
  - dequeue
```
public T dequeue()
```
    Description copied from interface: ObjectPriorityQueue
    
    Method to extract a element from the PriorityQueue
    
    Returns:
    
    a element from the Queue
  - peek
```
public T peek(int index)
```
    Description copied from interface: ObjectPriorityQueue
    
    Peeking function to see whats inside the queue.
    
    Parameters:
    
    index - of the element that is requested to be viewed.
    
    Returns:
    
    the element that is requested
  - removeFirst
```
public boolean removeFirst(T e)
```
    Description copied from interface: ObjectPriorityQueue
    
    Removes the first found element in the queue
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    if a searched element was removed
  - removeLast
```
public boolean removeLast(T e)
```
    Description copied from interface: ObjectPriorityQueue
    
    Removes the last found element in the queue
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    if a searched element was removed
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
  - forEach
```
public <E> void forEach(E input,
                        ObjectObjectConsumer<E,T> action)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
    
    Type Parameters:
    
    E - the generic type of the Object
    
    Parameters:
    
    input - the object that should be included
    
    action - The action to be performed for each element
  - matchesAny
```
public boolean matchesAny(Object2BooleanFunction<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for any matches.
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    true if any matches were found
  - matchesNone
```
public boolean matchesNone(Object2BooleanFunction<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for no matches.
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    true if no matches were found
  - matchesAll
```
public boolean matchesAll(Object2BooleanFunction<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for all matches.
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    true if all matches.
  - reduce
```
public <E> E reduce(E identity,
                    java.util.function.BiFunction<E,T,E> operator)
```
    Description copied from interface: ObjectIterable
    
    Performs a reduction on the elements of this Iterable
    
    Type Parameters:
    
    E - the type of elements maintained by this Collection
    
    Parameters:
    
    identity - the start value
    
    operator - the operation that should be applied
    
    Returns:
    
    the reduction result, returns identity if nothing was found
  - reduce
```
public T reduce(ObjectObjectUnaryOperator<T,T> operator)
```
    Description copied from interface: ObjectIterable
    
    Performs a reduction on the elements of this Iterable
    
    Parameters:
    
    operator - the operation that should be applied
    
    Returns:
    
    the reduction result, returns null value if nothing was found
  - findFirst
```
public T findFirst(Object2BooleanFunction<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for the first match.
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    the found value or the null equivalent variant.
  - count
```
public int count(Object2BooleanFunction<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to count the valid elements.
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    the amount of Valid Elements
  - onChanged
```
public void onChanged()
```
    Description copied from interface: ObjectPriorityQueue
    
    Allows to notify the Queue to be revalidate its data
  - copy
```
public ObjectHeapPriorityQueue<T> copy()
```
    Description copied from interface: ObjectPriorityQueue
    
    A Function that does a shallow clone of the PriorityQueue itself. This function is more optimized then a copy constructor since the PriorityQueue does not have to be unsorted/resorted. It can be compared to Cloneable but with less exception risk
    
    Returns:
    
    a Shallow Copy of the PriorityQueue
  - comparator
```
public java.util.Comparator<? super T> comparator()
```
    Returns:
    
    the sorter of the Queue, can be null
  - toArray
```
public <E> E[] toArray(E[] input)
```
    Description copied from interface: ObjectPriorityQueue
    
    A method to drop the contents of the Queue without clearing the queue
    
    Type Parameters:
    
    E - the type of elements maintained by this Collection
    
    Parameters:
    
    input - where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
    
    Returns:
    
    the contents of the queue into a seperate array.

Class ObjectHeapPriorityQueue<T>

Constructor Summary

Method Summary

Methods inherited from class speiger.src.collections.objects.queues.AbstractObjectPriorityQueue

Methods inherited from class java.lang.Object

Methods inherited from interface speiger.src.collections.objects.queues.ObjectPriorityQueue

Methods inherited from interface speiger.src.collections.objects.collections.ObjectIterable

Constructor Detail

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

ObjectHeapPriorityQueue

Method Detail

wrap

wrap

wrap

wrap

size

clear

iterator

enqueue

dequeue

peek

removeFirst

removeLast

forEach

forEach

matchesAny

matchesNone

matchesAll

reduce

reduce

findFirst

count

onChanged

copy

comparator

toArray