ObjectOpenCustomHashSet (Primitive-Collections 0.8.0 API)

java.lang.Object
- java.util.AbstractCollection<T>
- - speiger.src.collections.objects.collections.AbstractObjectCollection<T>
  - - speiger.src.collections.objects.sets.AbstractObjectSet<T>
    - - speiger.src.collections.objects.sets.ObjectOpenCustomHashSet<T>

Type Parameters:

T - the keyType of elements maintained by this Collection

All Implemented Interfaces:

java.lang.Iterable<T>, java.util.Collection<T>, java.util.Set<T>, ObjectCollection<T>, ObjectIterable<T>, ObjectSet<T>, ISizeProvider, ITrimmable

Direct Known Subclasses:

ObjectLinkedOpenCustomHashSet
```
public class ObjectOpenCustomHashSet<T>
extends AbstractObjectSet<T>
implements ITrimmable
```
A Type Specific HashSet that allows for custom HashControl. For cases where Objects/primitive do not allow hashcoding this can be really useful and provide a lot of control.

Nested Class Summary
- Nested classes/interfaces inherited from interface speiger.src.collections.utils.ISizeProvider
  ISizeProvider.CollectionSize

Constructor Summary

Constructors
Constructor and Description
`ObjectOpenCustomHashSet(java.util.Collection<? extends T> collection, float loadFactor, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
`ObjectOpenCustomHashSet(java.util.Collection<? extends T> collection, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
`ObjectOpenCustomHashSet(int minCapacity, float loadFactor, ObjectStrategy<? super T> strategy)` Constructor that defines the minimum capacity and load factor
`ObjectOpenCustomHashSet(int minCapacity, ObjectStrategy<? super T> strategy)` Constructor that defines the minimum capacity
`ObjectOpenCustomHashSet(java.util.Iterator<T> iterator, float loadFactor, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a set from a iterator of an unknown size
`ObjectOpenCustomHashSet(java.util.Iterator<T> iterator, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a set from a iterator of an unknown size
`ObjectOpenCustomHashSet(ObjectCollection<T> collection, float loadFactor, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
`ObjectOpenCustomHashSet(ObjectCollection<T> collection, ObjectStrategy<? super T> strategy)` A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
`ObjectOpenCustomHashSet(ObjectStrategy<? super T> strategy)` Default Contstructor
`ObjectOpenCustomHashSet(T[] array, float loadFactor, ObjectStrategy<? super T> strategy)` Helper constructor that allow to create a set from unboxed values
`ObjectOpenCustomHashSet(T[] array, int offset, int length, float loadFactor, ObjectStrategy<? super T> strategy)` Helper constructor that allow to create a set from unboxed values
`ObjectOpenCustomHashSet(T[] array, int offset, int length, ObjectStrategy<? super T> strategy)` Helper constructor that allow to create a set from unboxed values
`ObjectOpenCustomHashSet(T[] array, ObjectStrategy<? super T> strategy)` Helper constructor that allow to create a set from unboxed values

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(T o)`
`boolean`	`addAll(java.util.Collection<? extends T> c)`
`boolean`	`addAll(ObjectCollection<T> c)` A Type-Specific addAll function to reduce (un)boxing
`T`	`addOrGet(T o)` A Helper method that allows to add a element or getting the already present implement.
`void`	`clear()`
`void`	`clearAndTrim(int size)` Trims the collection down to the requested size and clears all elements while doing so
`boolean`	`contains(java.lang.Object o)`
`ObjectOpenCustomHashSet<T>`	`copy()` A Function that does a shallow clone of the Collection itself.
`int`	`count(java.util.function.Predicate<T> filter)` Helper function to reduce stream usage that allows to count the valid elements.
`T`	`findFirst(java.util.function.Predicate<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.
`void`	`forEachIndexed(IntObjectConsumer<T> action)` A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
`ObjectStrategy<? super T>`	`getStrategy()` Helper getter function to get the current strategy
`ObjectIterator<T>`	`iterator()` Returns a Type-Specific Iterator to reduce (un)boxing
`boolean`	`matchesAll(java.util.function.Predicate<T> filter)` Helper function to reduce stream usage that allows to filter for all matches.
`boolean`	`matchesAny(java.util.function.Predicate<T> filter)` Helper function to reduce stream usage that allows to filter for any matches.
`boolean`	`matchesNone(java.util.function.Predicate<T> filter)` Helper function to reduce stream usage that allows to filter for no matches.
`<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`	`remove(java.lang.Object o)`
`int`	`size()`
`boolean`	`trim(int size)` Trims the original collection down to the size of the current elements or the requested size depending which is bigger

Methods inherited from class speiger.src.collections.objects.sets.AbstractObjectSet
equals, hashCode

Methods inherited from class speiger.src.collections.objects.collections.AbstractObjectCollection
containsAll, containsAll, containsAny, containsAny, removeAll, removeAll, retainAll, retainAll

Methods inherited from class java.util.AbstractCollection
isEmpty, removeAll, retainAll, toArray, toArray, toString

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

Methods inherited from interface speiger.src.collections.utils.ITrimmable
clearAndTrim, trim

Methods inherited from interface speiger.src.collections.objects.sets.ObjectSet
spliterator, synchronize, synchronize, unmodifiable

Methods inherited from interface java.util.Set
containsAll, isEmpty, removeAll, retainAll, toArray, toArray

Methods inherited from interface speiger.src.collections.objects.collections.ObjectCollection
addAll, addAll, addAll, containsAll, containsAny, containsAny, pour, removeAll, removeAll, retainAll, retainAll, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

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

Methods inherited from interface speiger.src.collections.utils.ISizeProvider
of

- Constructor Detail
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(ObjectStrategy<? super T> strategy)
```
    Default Contstructor
    
    Parameters:
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(int minCapacity,
                               ObjectStrategy<? super T> strategy)
```
    Constructor that defines the minimum capacity
    
    Parameters:
    
    minCapacity - the minimum capacity the HashSet is allowed to be.
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the minimum capacity is negative
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(int minCapacity,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    Constructor that defines the minimum capacity and load factor
    
    Parameters:
    
    minCapacity - the minimum capacity the HashSet is allowed to be.
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the minimum capacity is negative
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(T[] array,
                               ObjectStrategy<? super T> strategy)
```
    Helper constructor that allow to create a set from unboxed values
    
    Parameters:
    
    array - the elements that should be put into the set
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(T[] array,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    Helper constructor that allow to create a set from unboxed values
    
    Parameters:
    
    array - the elements that should be put into the set
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(T[] array,
                               int offset,
                               int length,
                               ObjectStrategy<? super T> strategy)
```
    Helper constructor that allow to create a set from unboxed values
    
    Parameters:
    
    array - the elements that should be put into the set
    
    offset - the starting index within the array that should be used
    
    length - the amount of elements used from the array
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if offset and length causes to step outside of the arrays range
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(T[] array,
                               int offset,
                               int length,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    Helper constructor that allow to create a set from unboxed values
    
    Parameters:
    
    array - the elements that should be put into the set
    
    offset - the starting index within the array that should be used
    
    length - the amount of elements used from the array
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
    
    java.lang.IllegalStateException - if offset and length causes to step outside of the arrays range
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(java.util.Collection<? extends T> collection,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
    
    Parameters:
    
    collection - the set the elements should be added to the Set
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(java.util.Collection<? extends T> collection,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
    
    Parameters:
    
    collection - the set the elements should be added to the Set
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(ObjectCollection<T> collection,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
    
    Parameters:
    
    collection - the set the elements should be added to the Set
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(ObjectCollection<T> collection,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a Set with exactly the same values as the provided collection.
    
    Parameters:
    
    collection - the set the elements should be added to the Set
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(java.util.Iterator<T> iterator,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a set from a iterator of an unknown size
    
    Parameters:
    
    iterator - the elements that should be added to the set
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
  - ObjectOpenCustomHashSet
```
public ObjectOpenCustomHashSet(java.util.Iterator<T> iterator,
                               float loadFactor,
                               ObjectStrategy<? super T> strategy)
```
    A Helper constructor that allows to create a set from a iterator of an unknown size
    
    Parameters:
    
    iterator - the elements that should be added to the set
    
    loadFactor - the percentage of how full the backing array can be before they resize
    
    strategy - the strategy that allows hash control.
    
    Throws:
    
    java.lang.NullPointerException - if Strategy is null
    
    java.lang.IllegalStateException - if the loadfactor is either below/equal to 0 or above/equal to 1
- Method Detail
  - getStrategy
```
public ObjectStrategy<? super T> getStrategy()
```
    Helper getter function to get the current strategy
    
    Returns:
    
    the current strategy
  - add
```
public boolean add(T o)
```
    Specified by:
    
    add in interface java.util.Collection<T>
    
    Specified by:
    
    add in interface java.util.Set<T>
    
    Overrides:
    
    add in class java.util.AbstractCollection<T>
  - addOrGet
```
public T addOrGet(T o)
```
    Description copied from interface: ObjectSet
    
    A Helper method that allows to add a element or getting the already present implement. Allowing to make unique references reuseable.
    
    Specified by:
    
    addOrGet in interface ObjectSet<T>
    
    Overrides:
    
    addOrGet in class AbstractObjectSet<T>
    
    Parameters:
    
    o - the element to add
    
    Returns:
    
    either the inserted element or the present element.
  - addAll
```
public boolean addAll(java.util.Collection<? extends T> c)
```
    Specified by:
    
    addAll in interface java.util.Collection<T>
    
    Specified by:
    
    addAll in interface java.util.Set<T>
    
    Overrides:
    
    addAll in class java.util.AbstractCollection<T>
  - addAll
```
public boolean addAll(ObjectCollection<T> c)
```
    Description copied from interface: ObjectCollection
    
    A Type-Specific addAll function to reduce (un)boxing
    
    Specified by:
    
    addAll in interface ObjectCollection<T>
    
    Overrides:
    
    addAll in class AbstractObjectCollection<T>
    
    Parameters:
    
    c - the collection of elements that should be added
    
    Returns:
    
    true if elements were added into the collection
  - contains
```
public boolean contains(java.lang.Object o)
```
    Specified by:
    
    contains in interface java.util.Collection<T>
    
    Specified by:
    
    contains in interface java.util.Set<T>
    
    Overrides:
    
    contains in class java.util.AbstractCollection<T>
  - remove
```
public boolean remove(java.lang.Object o)
```
    Specified by:
    
    remove in interface java.util.Collection<T>
    
    Specified by:
    
    remove in interface java.util.Set<T>
    
    Overrides:
    
    remove in class java.util.AbstractCollection<T>
  - trim
```
public boolean trim(int size)
```
    Description copied from interface: ITrimmable
    
    Trims the original collection down to the size of the current elements or the requested size depending which is bigger
    
    Specified by:
    
    trim in interface ITrimmable
    
    Parameters:
    
    size - the requested trim size.
    
    Returns:
    
    if the internal array has been trimmed.
  - clearAndTrim
```
public void clearAndTrim(int size)
```
    Description copied from interface: ITrimmable
    
    Trims the collection down to the requested size and clears all elements while doing so
    
    Specified by:
    
    clearAndTrim in interface ITrimmable
    
    Parameters:
    
    size - the amount of elements that should be allowed
  - iterator
```
public ObjectIterator<T> iterator()
```
    Description copied from interface: ObjectCollection
    
    Returns a Type-Specific Iterator to reduce (un)boxing
    
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
    
    Specified by:
    
    iterator in interface java.util.Collection<T>
    
    Specified by:
    
    iterator in interface java.util.Set<T>
    
    Specified by:
    
    iterator in interface ObjectCollection<T>
    
    Specified by:
    
    iterator in interface ObjectIterable<T>
    
    Specified by:
    
    iterator in interface ObjectSet<T>
    
    Specified by:
    
    iterator in class AbstractObjectSet<T>
    
    Returns:
    
    a iterator of the collection
    
    See Also:
    
    Collection.iterator()
  - copy
```
public ObjectOpenCustomHashSet<T> copy()
```
    Description copied from interface: ObjectCollection
    
    A Function that does a shallow clone of the Collection itself. This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted. It can be compared to Cloneable but with less exception risk
    
    Specified by:
    
    copy in interface ObjectCollection<T>
    
    Specified by:
    
    copy in interface ObjectSet<T>
    
    Overrides:
    
    copy in class AbstractObjectSet<T>
    
    Returns:
    
    a Shallow Copy of the collection
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<T>
    
    Specified by:
    
    clear in interface java.util.Set<T>
    
    Overrides:
    
    clear in class java.util.AbstractCollection<T>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<T>
    
    Specified by:
    
    size in interface java.util.Set<T>
    
    Specified by:
    
    size in interface ISizeProvider
    
    Specified by:
    
    size in class java.util.AbstractCollection<T>
    
    Returns:
    
    the size of the implementing Collection
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
    Specified by:
    
    forEach in interface java.lang.Iterable<T>
  - forEachIndexed
```
public void forEachIndexed(IntObjectConsumer<T> action)
```
    Description copied from interface: ObjectIterable
    
    A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
    
    Specified by:
    
    forEachIndexed in interface ObjectIterable<T>
    
    Parameters:
    
    action - The action to be performed for each element
  - 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.
    
    Specified by:
    
    forEach in interface ObjectIterable<T>
    
    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(java.util.function.Predicate<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for any matches.
    
    Specified by:
    
    matchesAny in interface ObjectIterable<T>
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    true if any matches were found
  - matchesNone
```
public boolean matchesNone(java.util.function.Predicate<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for no matches.
    
    Specified by:
    
    matchesNone in interface ObjectIterable<T>
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    true if no matches were found
  - matchesAll
```
public boolean matchesAll(java.util.function.Predicate<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for all matches.
    
    Specified by:
    
    matchesAll in interface ObjectIterable<T>
    
    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
    
    Specified by:
    
    reduce in interface ObjectIterable<T>
    
    Type Parameters:
    
    E - the keyType 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
    
    Specified by:
    
    reduce in interface ObjectIterable<T>
    
    Parameters:
    
    operator - the operation that should be applied
    
    Returns:
    
    the reduction result, returns null value if nothing was found
  - findFirst
```
public T findFirst(java.util.function.Predicate<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to filter for the first match.
    
    Specified by:
    
    findFirst in interface ObjectIterable<T>
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    the found value or the null equivalent variant.
  - count
```
public int count(java.util.function.Predicate<T> filter)
```
    Description copied from interface: ObjectIterable
    
    Helper function to reduce stream usage that allows to count the valid elements.
    
    Specified by:
    
    count in interface ObjectIterable<T>
    
    Parameters:
    
    filter - that should be applied
    
    Returns:
    
    the amount of Valid Elements

Class ObjectOpenCustomHashSet<T>

Nested Class Summary

Nested classes/interfaces inherited from interface speiger.src.collections.utils.ISizeProvider

Constructor Summary

Method Summary

Methods inherited from class speiger.src.collections.objects.sets.AbstractObjectSet

Methods inherited from class speiger.src.collections.objects.collections.AbstractObjectCollection

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface speiger.src.collections.utils.ITrimmable

Methods inherited from interface speiger.src.collections.objects.sets.ObjectSet

Methods inherited from interface java.util.Set

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

Methods inherited from interface java.util.Collection

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

Methods inherited from interface speiger.src.collections.utils.ISizeProvider

Constructor Detail

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

ObjectOpenCustomHashSet

Method Detail

getStrategy

add

addOrGet

addAll

addAll

contains

remove

trim

clearAndTrim

iterator

copy

clear

size

forEach

forEachIndexed

forEach

matchesAny

matchesNone

matchesAll

reduce

reduce

findFirst

count