ObjectList (Primitive-Collections 0.8.0 API)

Type Parameters:

T - the keyType of elements maintained by this Collection

All Superinterfaces:

java.util.Collection<T>, ISizeProvider, java.lang.Iterable<T>, java.util.List<T>, ObjectCollection<T>, ObjectIterable<T>

All Known Implementing Classes:

AbstractObjectList, CopyOnWriteObjectArrayList, ImmutableObjectList, ObjectArrayList, ObjectLinkedList
```
public interface ObjectList<T>
extends ObjectCollection<T>, java.util.List<T>
```
A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features

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

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`boolean`	`addAll(int index, ObjectCollection<T> c)` A Type-Specific addAll Function to reduce (un)boxing
`boolean`	`addAll(int index, ObjectList<T> c)` A Type-Specific and optimized addAll function that allows a faster transfer of elements
`boolean`	`addAll(ObjectList<T> c)` A Type-Specific and optimized addAll function that allows a faster transfer of elements
`default void`	`addElements(int from, T... a)` A function to fast add elements to the list
`void`	`addElements(int from, T[] a, int offset, int length)` A function to fast add elements to the list
`default void`	`addElements(T... a)` A function to fast add elements to the list
`default boolean`	`addIfAbsent(T e)` A Helper function that will only add elements if it is not present.
`default boolean`	`addIfPresent(T e)` A Helper function that will only add elements if it is present.
`ObjectList<T>`	`copy()` A Function that does a shallow clone of the Collection itself.
`<K> K[]`	`extractElements(int from, int to, java.lang.Class<K> type)` A function to fast extract elements out of the list, this removes the elements that were fetched.
`default void`	`forEachIndexed(IntObjectConsumer<T> action)` A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
`default T[]`	`getElements(int from, T[] a)` A function to fast fetch elements from the list
`T[]`	`getElements(int from, T[] a, int offset, int length)` A function to fast fetch elements from the list
`ObjectListIterator<T>`	`listIterator()` A Type-Specific Iterator of listIterator
`ObjectListIterator<T>`	`listIterator(int index)` A Type-Specific Iterator of listIterator
`void`	`removeElements(int from, int to)` a function to fast remove elements from the list.
`default void`	`replaceAll(java.util.function.UnaryOperator<T> o)` A function to replace all values in the list
`void`	`size(int size)` A function to ensure the elements are within the requested size.
`default void`	`sort(java.util.Comparator<? super T> c)` Sorts the elements specified by the Natural order either by using the Comparator or the elements
`default ObjectSplititerator<T>`	`spliterator()` A Type Specific Type Splititerator to reduce boxing/unboxing
`ObjectList<T>`	`subList(int from, int to)` A Type-Specific List of subList
`T`	`swapRemove(int index)` A Highly Optimized remove function that removes the desired element.
`boolean`	`swapRemove(T e)` A Highly Optimized remove function that removes the desired element.
`default ObjectList<T>`	`synchronize()` Creates a Wrapped List that is Synchronized
`default ObjectList<T>`	`synchronize(java.lang.Object mutex)` Creates a Wrapped List that is Synchronized
`default ObjectList<T>`	`unmodifiable()` Creates a Wrapped List that is unmodifiable
`default void`	`unstableSort(java.util.Comparator<? super T> c)` Sorts the elements specified by the Natural order either by using the Comparator or the elements using a unstable sort

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

Methods inherited from interface speiger.src.collections.objects.collections.ObjectIterable
arrayflatMap, asAsync, count, distinct, filter, findFirst, flatMap, forEach, limit, map, matchesAll, matchesAny, matchesNone, peek, pourAsList, pourAsSet, reduce, reduce, repeat, sorted

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

Methods inherited from interface java.util.List
add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, remove, remove, removeAll, retainAll, set, size, toArray, toArray

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

Methods inherited from interface java.lang.Iterable
forEach

- Method Detail
  - addIfAbsent
```
default boolean addIfAbsent(T e)
```
    A Helper function that will only add elements if it is not present.
    
    Parameters:
    
    e - the element to add
    
    Returns:
    
    true if the list was modified
  - addIfPresent
```
default boolean addIfPresent(T e)
```
    A Helper function that will only add elements if it is present.
    
    Parameters:
    
    e - the element to add
    
    Returns:
    
    true if the list was modified
  - addAll
```
boolean addAll(int index,
               ObjectCollection<T> c)
```
    A Type-Specific addAll Function to reduce (un)boxing
    
    Parameters:
    
    c - the elements that need to be added
    
    index - index at which the specified elements is to be inserted
    
    Returns:
    
    true if the list was modified
    
    See Also:
    
    List.addAll(int, java.util.Collection)
  - addAll
```
boolean addAll(ObjectList<T> c)
```
    A Type-Specific and optimized addAll function that allows a faster transfer of elements
    
    Parameters:
    
    c - the elements that need to be added
    
    Returns:
    
    true if the list was modified
  - addAll
```
boolean addAll(int index,
               ObjectList<T> c)
```
    A Type-Specific and optimized addAll function that allows a faster transfer of elements
    
    Parameters:
    
    c - the elements that need to be added
    
    index - index at which the specified elements is to be inserted
    
    Returns:
    
    true if the list was modified
  - replaceAll
```
default void replaceAll(java.util.function.UnaryOperator<T> o)
```
    A function to replace all values in the list
    
    Specified by:
    
    replaceAll in interface java.util.List<T>
    
    Parameters:
    
    o - the action to replace the values
    
    Throws:
    
    java.lang.NullPointerException - if o is null
  - addElements
```
default void addElements(T... a)
```
    A function to fast add elements to the list
    
    Parameters:
    
    a - the elements that should be added
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if from is outside of the lists range
  - addElements
```
default void addElements(int from,
                         T... a)
```
    A function to fast add elements to the list
    
    Parameters:
    
    from - the index where the elements should be added into the list
    
    a - the elements that should be added
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if from is outside of the lists range
  - addElements
```
void addElements(int from,
                 T[] a,
                 int offset,
                 int length)
```
    A function to fast add elements to the list
    
    Parameters:
    
    from - the index where the elements should be added into the list
    
    a - the elements that should be added
    
    offset - the start index of the array should be read from
    
    length - how many elements should be read from
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if from is outside of the lists range
  - getElements
```
default T[] getElements(int from,
                        T[] a)
```
    A function to fast fetch elements from the list
    
    Parameters:
    
    from - index where the list should be fetching elements from
    
    a - the array where the values should be inserted to
    
    Returns:
    
    the inputArray
    
    Throws:
    
    java.lang.NullPointerException - if the array is null
    
    java.lang.IndexOutOfBoundsException - if from is outside of the lists range
    
    java.lang.IllegalStateException - if offset or length are smaller then 0 or exceed the array length
  - getElements
```
T[] getElements(int from,
                T[] a,
                int offset,
                int length)
```
    A function to fast fetch elements from the list
    
    Parameters:
    
    from - index where the list should be fetching elements from
    
    a - the array where the values should be inserted to
    
    offset - the startIndex of where the array should be written to
    
    length - the number of elements the values should be fetched from
    
    Returns:
    
    the inputArray
    
    Throws:
    
    java.lang.NullPointerException - if the array is null
    
    java.lang.IndexOutOfBoundsException - if from is outside of the lists range
    
    java.lang.IllegalStateException - if offset or length are smaller then 0 or exceed the array length
  - removeElements
```
void removeElements(int from,
                    int to)
```
    a function to fast remove elements from the list.
    
    Parameters:
    
    from - the start index of where the elements should be removed from (inclusive)
    
    to - the end index of where the elements should be removed to (exclusive)
  - swapRemove
```
T swapRemove(int index)
```
    A Highly Optimized remove function that removes the desired element. But instead of shifting the elements to the left it moves the last element to the removed space.
    
    Parameters:
    
    index - the index of the element to be removed
    
    Returns:
    
    the element previously at the specified position
  - swapRemove
```
boolean swapRemove(T e)
```
    A Highly Optimized remove function that removes the desired element. But instead of shifting the elements to the left it moves the last element to the removed space.
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    true if the element was removed
  - extractElements
```
<K> K[] extractElements(int from,
                        int to,
                        java.lang.Class<K> type)
```
    A function to fast extract elements out of the list, this removes the elements that were fetched.
    
    Type Parameters:
    
    K - the keyType of elements maintained by this Collection
    
    Parameters:
    
    from - the start index of where the elements should be fetched from (inclusive)
    
    to - the end index of where the elements should be fetched to (exclusive)
    
    type - the type of the OutputArray
    
    Returns:
    
    a array of the elements that were fetched
  - sort
```
default void sort(java.util.Comparator<? super T> c)
```
    Sorts the elements specified by the Natural order either by using the Comparator or the elements
    
    Specified by:
    
    sort in interface java.util.List<T>
    
    See Also:
    
    List.sort(Comparator)
  - unstableSort
```
default void unstableSort(java.util.Comparator<? super T> c)
```
    Sorts the elements specified by the Natural order either by using the Comparator or the elements using a unstable sort
    
    Parameters:
    
    c - the sorter of the elements, can be null
    
    See Also:
    
    List.sort(Comparator)
  - forEachIndexed
```
default void forEachIndexed(IntObjectConsumer<T> action)
```
    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
    
    Throws:
    
    java.lang.NullPointerException - if the specified action is null
  - listIterator
```
ObjectListIterator<T> listIterator()
```
    A Type-Specific Iterator of listIterator
    
    Specified by:
    
    listIterator in interface java.util.List<T>
    
    See Also:
    
    List.listIterator()
  - listIterator
```
ObjectListIterator<T> listIterator(int index)
```
    A Type-Specific Iterator of listIterator
    
    Specified by:
    
    listIterator in interface java.util.List<T>
    
    See Also:
    
    List.listIterator(int)
  - subList
```
ObjectList<T> subList(int from,
                      int to)
```
    A Type-Specific List of subList
    
    Specified by:
    
    subList in interface java.util.List<T>
    
    See Also:
    
    List.subList(int, int)
  - synchronize
```
default ObjectList<T> synchronize()
```
    Creates a Wrapped List that is Synchronized
    
    Specified by:
    
    synchronize in interface ObjectCollection<T>
    
    Returns:
    
    a new List that is synchronized
    
    See Also:
    
    ObjectLists.synchronize(speiger.src.collections.objects.lists.ObjectList<T>)
  - synchronize
```
default ObjectList<T> synchronize(java.lang.Object mutex)
```
    Creates a Wrapped List that is Synchronized
    
    Specified by:
    
    synchronize in interface ObjectCollection<T>
    
    Parameters:
    
    mutex - is the controller of the synchronization block
    
    Returns:
    
    a new List Wrapper that is synchronized
    
    See Also:
    
    ObjectLists.synchronize(speiger.src.collections.objects.lists.ObjectList<T>)
  - unmodifiable
```
default ObjectList<T> unmodifiable()
```
    Creates a Wrapped List that is unmodifiable
    
    Specified by:
    
    unmodifiable in interface ObjectCollection<T>
    
    Returns:
    
    a new List Wrapper that is unmodifiable
    
    See Also:
    
    ObjectLists.unmodifiable(speiger.src.collections.objects.lists.ObjectList<T>)
  - size
```
void size(int size)
```
    A function to ensure the elements are within the requested size. If smaller then the stored elements they get removed as needed. If bigger it is ensured that enough room is provided depending on the implementation
    
    Parameters:
    
    size - the requested amount of elements/room for elements
  - copy
```
ObjectList<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>
    
    Returns:
    
    a Shallow Copy of the collection
  - spliterator
```
default ObjectSplititerator<T> spliterator()
```
    A Type Specific Type Splititerator to reduce boxing/unboxing
    
    Specified by:
    
    spliterator in interface java.util.Collection<T>
    
    Specified by:
    
    spliterator in interface java.lang.Iterable<T>
    
    Specified by:
    
    spliterator in interface java.util.List<T>
    
    Specified by:
    
    spliterator in interface ObjectCollection<T>
    
    Specified by:
    
    spliterator in interface ObjectIterable<T>
    
    Returns:
    
    type specific splititerator

Interface ObjectList<T>

Nested Class Summary

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

Method Summary

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

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

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

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Method Detail

addIfAbsent

addIfPresent

addAll

addAll

addAll

replaceAll

addElements

addElements

addElements

getElements

getElements

removeElements

swapRemove

swapRemove

extractElements

sort

unstableSort

forEachIndexed

listIterator

listIterator

subList

synchronize

synchronize

unmodifiable

size

copy

spliterator