BooleanArrayPriorityQueue (Primitive-Collections 0.8.0 API)

java.lang.Object
- speiger.src.collections.booleans.queues.AbstractBooleanPriorityQueue
- - speiger.src.collections.booleans.queues.BooleanArrayPriorityQueue

All Implemented Interfaces:

java.lang.Iterable<java.lang.Boolean>, BooleanIterable, BooleanPriorityQueue
```
public class BooleanArrayPriorityQueue
extends AbstractBooleanPriorityQueue
```
A Array Priority Queue, this is a very unoptimized implementation of the PriorityQueue for very specific usecases. It allows for duplicated entries and works like List.indexOf(Object) search. It is highly suggested to use HeapPriorityQueue otherwise, unless you know why you need this specific implementation

Constructor Summary

Constructors
Constructor and Description
`BooleanArrayPriorityQueue()` Default Constructor
`BooleanArrayPriorityQueue(boolean[] array)` Constructor using a initial array
`BooleanArrayPriorityQueue(boolean[] array, BooleanComparator comp)` Constructor using a initial array and a custom sorter
`BooleanArrayPriorityQueue(boolean[] array, int size)` Constructor using a initial array
`BooleanArrayPriorityQueue(boolean[] array, int size, BooleanComparator comp)` Constructor using a initial array and a custom sorter
`BooleanArrayPriorityQueue(BooleanCollection c)` Constructor using a Collection
`BooleanArrayPriorityQueue(BooleanCollection c, BooleanComparator comp)` Constructor using a Collection and a custom sorter
`BooleanArrayPriorityQueue(BooleanComparator comp)` Constructor using custom sorter
`BooleanArrayPriorityQueue(int size)` Constructor with a Min Capacity
`BooleanArrayPriorityQueue(int size, BooleanComparator comp)` Constructor with a Min Capacity and 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
`BooleanComparator`	`comparator()`
`BooleanArrayPriorityQueue`	`copy()` A Function that does a shallow clone of the PriorityQueue itself.
`int`	`count(BooleanPredicate filter)` Helper function to reduce stream usage that allows to count the valid elements.
`boolean`	`dequeue()` Method to extract a element from the PriorityQueue
`void`	`enqueue(boolean e)` Method to insert a element into the PriorityQueue
`boolean`	`findFirst(BooleanPredicate filter)` Helper function to reduce stream usage that allows to filter for the first match.
`boolean`	`first()` Shows the element that is to be returned next
`void`	`forEach(BooleanConsumer action)` A Type Specific foreach function that reduces (un)boxing
`<E> void`	`forEach(E input, ObjectBooleanConsumer<E> action)` Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
`void`	`forEachIndexed(IntBooleanConsumer action)` A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
`BooleanIterator`	`iterator()` Returns an iterator over elements of type `T`.
`boolean`	`matchesAll(BooleanPredicate filter)` Helper function to reduce stream usage that allows to filter for all matches.
`boolean`	`matchesAny(BooleanPredicate filter)` Helper function to reduce stream usage that allows to filter for any matches.
`boolean`	`matchesNone(BooleanPredicate 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
`boolean`	`peek(int index)` Peeking function to see whats inside the queue.
`boolean`	`reduce(boolean identity, BooleanBooleanUnaryOperator operator)` Performs a reduction on the elements of this Iterable
`boolean`	`reduce(BooleanBooleanUnaryOperator operator)` Performs a reduction on the elements of this Iterable
`boolean`	`removeFirst(boolean e)` Removes the first found element in the queue
`boolean`	`removeLast(boolean e)` Removes the last found element in the queue
`int`	`size()`
`boolean[]`	`toBooleanArray(boolean[] input)` A method to drop the contents of the Queue without clearing the queue
`static BooleanArrayPriorityQueue`	`wrap(boolean[] array)` Wrapping method to help serialization
`static BooleanArrayPriorityQueue`	`wrap(boolean[] array, BooleanComparator comp)` Wrapping method to help serialization, using a custom sorter
`static BooleanArrayPriorityQueue`	`wrap(boolean[] array, int size)` Wrapping method to help serialization
`static BooleanArrayPriorityQueue`	`wrap(boolean[] array, int size, BooleanComparator comp)` Wrapping method to help serialization, using a custom sorter

Methods inherited from class speiger.src.collections.booleans.queues.AbstractBooleanPriorityQueue
equals, hashCode, toString

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

Methods inherited from interface speiger.src.collections.booleans.queues.BooleanPriorityQueue
enqueueAll, enqueueAll, enqueueAll, enqueueAll, isEmpty, synchronizeQueue, synchronizeQueue, toBooleanArray

Methods inherited from interface speiger.src.collections.booleans.collections.BooleanIterable
arrayflatMap, asAsync, distinct, filter, flatMap, forEach, limit, map, peek, pour, pourAsList, repeat, sorted, spliterator

- Constructor Detail
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue()
```
    Default Constructor
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(BooleanComparator comp)
```
    Constructor using custom sorter
    
    Parameters:
    
    comp - Comparator to sort the Array. Can be null
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(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
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(int size,
                                 BooleanComparator 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
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(boolean[] array)
```
    Constructor using a initial array
    
    Parameters:
    
    array - the Array that should be used
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(boolean[] 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
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(boolean[] array,
                                 BooleanComparator 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
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(boolean[] array,
                                 int size,
                                 BooleanComparator 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
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(BooleanCollection c)
```
    Constructor using a Collection
    
    Parameters:
    
    c - the Collection that should be used
  - BooleanArrayPriorityQueue
```
public BooleanArrayPriorityQueue(BooleanCollection c,
                                 BooleanComparator 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 BooleanArrayPriorityQueue wrap(boolean[] array)
```
    Wrapping method to help serialization
    
    Parameters:
    
    array - the array that should be used
    
    Returns:
    
    a ArrayPriorityQueue containing the original input array
  - wrap
```
public static BooleanArrayPriorityQueue wrap(boolean[] array,
                                             int size)
```
    Wrapping method to help serialization
    
    Parameters:
    
    array - the array that should be used
    
    size - the amount of elements within the array
    
    Returns:
    
    a ArrayPriorityQueue containing the original input array
  - wrap
```
public static BooleanArrayPriorityQueue wrap(boolean[] array,
                                             BooleanComparator comp)
```
    Wrapping method to help serialization, using a custom sorter
    
    Parameters:
    
    array - the array that should be used
    
    comp - Comparator to sort the Array. Can be null
    
    Returns:
    
    a ArrayPriorityQueue containing the original input array
  - wrap
```
public static BooleanArrayPriorityQueue wrap(boolean[] array,
                                             int size,
                                             BooleanComparator comp)
```
    Wrapping method to help serialization, using a custom sorter
    
    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 ArrayPriorityQueue containing the original input array
  - enqueue
```
public void enqueue(boolean e)
```
    Description copied from interface: BooleanPriorityQueue
    
    Method to insert a element into the PriorityQueue
    
    Parameters:
    
    e - the element that should be inserted
  - dequeue
```
public boolean dequeue()
```
    Description copied from interface: BooleanPriorityQueue
    
    Method to extract a element from the PriorityQueue
    
    Returns:
    
    a element from the Queue
  - first
```
public boolean first()
```
    Description copied from interface: BooleanPriorityQueue
    
    Shows the element that is to be returned next
    
    Returns:
    
    the first element in the Queue
  - peek
```
public boolean peek(int index)
```
    Description copied from interface: BooleanPriorityQueue
    
    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(boolean e)
```
    Description copied from interface: BooleanPriorityQueue
    
    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(boolean e)
```
    Description copied from interface: BooleanPriorityQueue
    
    Removes the last found element in the queue
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    if a searched element was removed
  - onChanged
```
public void onChanged()
```
    Description copied from interface: BooleanPriorityQueue
    
    Allows to notify the Queue to be revalidate its data
  - size
```
public int size()
```
    Returns:
    
    the amount of elements that are stored in the PriorityQueue
  - clear
```
public void clear()
```
    Description copied from interface: BooleanPriorityQueue
    
    clears all elements within the PriorityQueue, this does not resize the backing arrays
  - forEach
```
public void forEach(BooleanConsumer action)
```
    Description copied from interface: BooleanIterable
    
    A Type Specific foreach function that reduces (un)boxing
    
    Parameters:
    
    action - The action to be performed for each element
    
    See Also:
    
    Iterable.forEach(Consumer)
  - forEachIndexed
```
public void forEachIndexed(IntBooleanConsumer action)
```
    Description copied from interface: BooleanIterable
    
    A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
    
    Parameters:
    
    action - The action to be performed for each element
  - forEach
```
public <E> void forEach(E input,
                        ObjectBooleanConsumer<E> action)
```
    Description copied from interface: BooleanIterable
    
    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(BooleanPredicate filter)
```
    Description copied from interface: BooleanIterable
    
    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(BooleanPredicate filter)
```
    Description copied from interface: BooleanIterable
    
    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(BooleanPredicate filter)
```
    Description copied from interface: BooleanIterable
    
    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 boolean reduce(boolean identity,
                      BooleanBooleanUnaryOperator operator)
```
    Description copied from interface: BooleanIterable
    
    Performs a reduction on the elements of this Iterable
    
    Parameters:
    
    identity - the start value
    
    operator - the operation that should be applied
    
    Returns:
    
    the reduction result, returns identity if nothing was found
  - reduce
```
public boolean reduce(BooleanBooleanUnaryOperator operator)
```
    Description copied from interface: BooleanIterable
    
    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 boolean findFirst(BooleanPredicate filter)
```
    Description copied from interface: BooleanIterable
    
    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(BooleanPredicate filter)
```
    Description copied from interface: BooleanIterable
    
    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
  - iterator
```
public BooleanIterator iterator()
```
    Description copied from interface: BooleanIterable
    
    Returns an iterator over elements of type T.
    
    Returns:
    
    an Iterator.
  - copy
```
public BooleanArrayPriorityQueue copy()
```
    Description copied from interface: BooleanPriorityQueue
    
    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 BooleanComparator comparator()
```
    Returns:
    
    the sorter of the Queue, can be null
  - toBooleanArray
```
public boolean[] toBooleanArray(boolean[] input)
```
    Description copied from interface: BooleanPriorityQueue
    
    A method to drop the contents of the Queue without clearing the queue
    
    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 BooleanArrayPriorityQueue

Constructor Summary

Method Summary

Methods inherited from class speiger.src.collections.booleans.queues.AbstractBooleanPriorityQueue

Methods inherited from class java.lang.Object

Methods inherited from interface speiger.src.collections.booleans.queues.BooleanPriorityQueue

Methods inherited from interface speiger.src.collections.booleans.collections.BooleanIterable

Constructor Detail

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

BooleanArrayPriorityQueue

Method Detail

wrap

wrap

wrap

wrap

enqueue

dequeue

first

peek

removeFirst

removeLast

onChanged

size

clear

forEach

forEachIndexed

forEach

matchesAny

matchesNone

matchesAll

reduce

reduce

findFirst

count

iterator

copy

comparator

toBooleanArray