Class AbstractContainer<E>

java.lang.Object

ch.nolix.base.container.base.AbstractContainer<E>

Type Parameters:

E - is the type of the elements of a AbstractContainer.

All Implemented Interfaces:

Filterable<E>, Groupable<E>, IContainer<E>, IFilteringContainerViewProvider<E>, IIntervallContainerViewProvider<E>, IMappingContainerViewProvider<E>, Mappable<E>, AggregationRequestable<E>, ArrayMappable<E>, CountRequestable<E>, IndexRequestable<E>, IterableWithCopyableIterator<E>, SingleSearchable<E>, StoringRequestable<E>, StringMappable, EmptinessRequestable, MaterializationRequestable, Iterable<E>

Direct Known Subclasses:

AbstractExtendedContainer

public abstract class AbstractContainer<E>
extends Object
implements IContainer<E>

Author:

Silvan Wyss

Constructor Summary

Constructors

Constructor	Description
AbstractContainer()

Method Summary

Modifier and Type	Method	Description
final boolean	contains(Object object)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsAllOf(Iterable<?> objects)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsAllOf(Object... objects)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsAny(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsAnyOf(Iterable<?> objects)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsAnyOf(Object... objects)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsAsManyAs(Iterable<?> iterable)	The time complexity of this implementation is O(n) if the current container contains n elements.
final boolean	containsEqualing(Object element)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsExactlyEqualingInSameOrder(Iterable<?> iterable)	The time complexity of this implementation is O(m*n) if: The current AbstractContainer contains m elements.
final boolean	containsExactlyInSameOrder(Iterable<?> iterable)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsLessThan(Iterable<?> iterable)	The time complexity of this implementation is O(n) if the given iterable contains n elements.
final boolean	containsMoreThan(Iterable<?> iterable)	The time complexity of this implementation is O(n) if the given iterable contains n elements.
final boolean	containsNone(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsNoneOf(Iterable<?> elements)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsNoneOf(Object... objects)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final boolean	containsOnce(Object object)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsOne()	The time complexity of this implementation is O(1).
final boolean	containsOne(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsOneEqualing(E object)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final boolean	containsOnly(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getAverage(Function<E,Number> valueMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getAverageOrZero(Function<E,Number> mapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final int	getCount(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final int	getCountOf(Object element)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <C extends Comparable<C>> C	getMax(Function<E,C> comparableMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getMaxOrZero(Function<E,Number> numberMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getMedian(Function<E,Number> numberMapper)	The time complexity of this implementation is O(n*log(n)) if the current AbstractContainer contains n elements.
final double	getMedianOrZero(Function<E,Number> norm)	The time complexity of this implementation is O(n*log(n)) if the current AbstractContainer contains n elements.
final <C extends Comparable<C>> C	getMin(Function<E,C> comparableMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getMinOrZero(Function<E,Number> numberMapper)
final int	getOneBasedIndexOfFirst(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final int	getOneBasedIndexOfFirstEqualElement(Object object)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final int	getOneBasedIndexOfFirstOccurrenceOf(Object object)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final Optional<E>	getOptionalStoredFirst()	The time complexity of this implementation is O(1).
final Optional<E>	getOptionalStoredFirst(Predicate<? super E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getStandardDeviation(Function<E,Number> norm)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <C extends Comparable<C>> E	getStoredByMax(Function<E,C> comparableMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <C extends Comparable<C>> E	getStoredByMin(Function<E,C> comparableMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final E	getStoredFirst()	The time complexity of this implementation is O(1).
final E	getStoredFirst(Predicate<? super E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <T extends E> T	getStoredFirstOfType(Class<T> type)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<? extends IContainer<E>>	getStoredInGroups(Function<E,?> norm)	The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements.
final E	getStoredLast()	The time complexity of this implementation is O(1) or O(n) if the current AbstractContainer contains n elements.
final <T extends E> IContainer<T>	getStoredOfType(Class<T> type)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final E	getStoredOne()	The time complexity of this implementation is O(1).
final E	getStoredOne(Predicate<? super E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<E>	getStoredOthers(Predicate<E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<E>	getStoredSelected(Predicate<? super E> selector)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final BigDecimal	getSum(Function<E,Number> valueMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final BigInteger	getSumOfInts(ToIntFunction<E> intMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double	getVariance(Function<E,Number> numberMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<E>	getViewFromOneBasedStartIndex(int oneBasedStartIndex)	The time complexity of this implementation is O(1).
<T> IContainer<T>	getViewOf(Function<E,T> mapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<E>	getViewToOneBasedEndIndex(int oneBasedEndIndex)	The time complexity of this implementation is O(1).
final IContainer<E>	getViewWithoutFirst()	The time complexity of this implementation is O(1).
final IContainer<E>	getViewWithoutFirst(int n)	The time complexity of this implementation is O(1).
final IContainer<E>	getViewWithoutLast()	The time complexity of this implementation is O(1).
final IContainer<E>	getViewWithoutLast(int n)	The time complexity of this implementation is O(1).
final boolean	isEmpty()	The time complexity of this implementation is O(1) if the current Container does not contain null elements.
final <T> IContainer<T>	to(Function<E,T> mapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final Object[]	toArray()	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final byte[]	toByteArray(Function<E,Byte> byteMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final char[]	toCharArray(Function<E, Character> charMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final String	toConcatenatedString()	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final double[]	toDoubleArray(ToDoubleFunction<E> doubleMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final int[]	toIntArray(ToIntFunction<E> intMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final long[]	toLongArray(ToLongFunction<E> longMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <T> IContainer<T>	toMultiples(Function<E, IContainer<T>> multipleMapper)	The time complexity of this implementation is O(m*n) if: -The current * AbstractContainer contains m elements.
<N extends Number> IContainer<N>	toNumbers(Function<E,N> numberMapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<E>	toReversedList()	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final String[]	toStringArray()	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final IContainer<String>	toStrings()	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final String	toStringWithSeparator(char separator)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final String	toStringWithSeparator(String separator)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
final <T> IContainer<T>	toWithOneBasedIndex(BiFunction<Integer,E,T> mapper)	The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface CountRequestable

getCount

Methods inherited from interface EmptinessRequestable

containsAny

Methods inherited from interface IContainer

toOrderedList

Methods inherited from interface IFilteringContainerViewProvider

getViewOfStoredSelected

Methods inherited from interface IIntervallContainerViewProvider

getViewFromOneBasedStartIndexToOneBasedEndIndex

Methods inherited from interface Iterable

forEach, spliterator

Methods inherited from interface IterableWithCopyableIterator

iterator

Methods inherited from interface MaterializationRequestable

isMaterialized, isView

Methods inherited from interface SingleSearchable

getStoredAtOneBasedIndex

Constructor Details

AbstractContainer

public AbstractContainer()

Method Details

contains

public final boolean contains(Object object)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

contains in interface StoringRequestable<E>

Parameters:

object -

Returns:

true if the current StoringRequestable contains the given object, false otherwise.

containsAllOf

public final boolean containsAllOf(Object... objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsAllOf in interface StoringRequestable<E>

Parameters:

objects -

Returns:

true if the current StoringRequestable contains all of the given objects, false otherwise.

containsAllOf

public final boolean containsAllOf(Iterable<?> objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsAllOf in interface StoringRequestable<E>

Parameters:

objects -

Returns:

true if the current StoringRequestable contains all of the given objects, false otherwise.

containsAny

public final boolean containsAny(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsAny in interface StoringRequestable<E>

Parameters:

selector -

Returns:

true if the current StoringRequestable contains an element the given selector selects, false otherwise. Ignores null elements.

containsAnyOf

public final boolean containsAnyOf(Iterable<?> objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsAnyOf in interface StoringRequestable<E>

Parameters:

objects -

Returns:

true if the current StoringRequestable contains any of the given objects, false otherwise.

containsAnyOf

public final boolean containsAnyOf(Object... objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsAnyOf in interface StoringRequestable<E>

Parameters:

objects -

Returns:

true if the current StoringRequestable contains at least one of the given objects, false otherwise.

containsAsManyAs

public final boolean containsAsManyAs(Iterable<?> iterable)

The time complexity of this implementation is O(n) if the current container contains n elements.

Specified by:

containsAsManyAs in interface StoringRequestable<E>

Parameters:

iterable -

Returns:

true if the current StoringRequestable contains as many elements as the given container, false otherwise.

containsEqualing

public final boolean containsEqualing(Object element)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsEqualing in interface StoringRequestable<E>

Parameters:

element -

Returns:

true if the current StoringRequestable contains an element that equals the given given element, false otherwise.

containsExactlyEqualingInSameOrder

public final boolean containsExactlyEqualingInSameOrder(Iterable<?> iterable)

The time complexity of this implementation is O(m*n) if: The current AbstractContainer contains m elements. The given iterable contains n elements.

Specified by:

containsExactlyEqualingInSameOrder in interface StoringRequestable<E>

Parameters:

iterable -

Returns:

true if the current StoringRequestable contains exactly elements that equal the elements of given iterable in the same order, false otherwise.

containsExactlyInSameOrder

public final boolean containsExactlyInSameOrder(Iterable<?> iterable)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsExactlyInSameOrder in interface StoringRequestable<E>

Parameters:

iterable -

Returns:

true if the current StoringRequestable contains exactly the elements of the given iterable in the same order, false otherwise.

containsLessThan

public final boolean containsLessThan(Iterable<?> iterable)

The time complexity of this implementation is O(n) if the given iterable contains n elements.

Specified by:

containsLessThan in interface StoringRequestable<E>

Parameters:

iterable -

Returns:

true if the current StoringRequestable contains less elements than the given container, false otherwise

containsMoreThan

public final boolean containsMoreThan(Iterable<?> iterable)

The time complexity of this implementation is O(n) if the given iterable contains n elements.

Specified by:

containsMoreThan in interface StoringRequestable<E>

Parameters:

iterable -

Returns:

true if the current StoringRequestable contains more elements than the given container, false otherwise.

containsNone

public final boolean containsNone(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsNone in interface StoringRequestable<E>

Parameters:

selector -

Returns:

true if the current StoringRequestable does not contain an element the given selector selects, false otherwise. Ignores null elements.

containsNoneOf

public final boolean containsNoneOf(Iterable<?> elements)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsNoneOf in interface StoringRequestable<E>

Parameters:

elements -

Returns:

true if the current StoringRequestable does not contain any of the given objects, false otherwise.

containsNoneOf

public final boolean containsNoneOf(Object... objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.

Specified by:

containsNoneOf in interface StoringRequestable<E>

Parameters:

objects -

Returns:

true if the current StoringRequestable does not contain any of the given objects, false otherwise.

containsOnce

public final boolean containsOnce(Object object)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsOnce in interface StoringRequestable<E>

Parameters:

object -

Returns:

true if the current StoringRequestable contains the given object exactly 1 time, false otherwise.

containsOne

public final boolean containsOne()

The time complexity of this implementation is O(1).

Specified by:

containsOne in interface StoringRequestable<E>

Returns:

true if the current StoringRequestable contains exactly 1 element, false otherwise.

containsOne

public final boolean containsOne(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsOne in interface StoringRequestable<E>

Parameters:

selector -

Returns:

true if the current StoringRequestable contains exactly 1 element the given selector selects, false otherwise. Ignores null elements.

containsOneEqualing

public final boolean containsOneEqualing(E object)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsOneEqualing in interface StoringRequestable<E>

Parameters:

object -

Returns:

true if the current StoringRequestable contains exactly 1 element that equals the given object, false otherwise.

containsOnly

public final boolean containsOnly(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

containsOnly in interface StoringRequestable<E>

Parameters:

selector -

Returns:

true if the current StoringRequestable contains only elements the given selector selects, false otherwise.. Null element are regarded as unselectable.

getAverage

public final double getAverage(Function<E,Number> valueMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getAverage in interface AggregationRequestable<E>

Parameters:

valueMapper -

Returns:

the average of the values the given valueMapper maps from the elements of the current AggregationRequestable. Maps null elements to 0.0.

getAverageOrZero

public final double getAverageOrZero(Function<E,Number> mapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getAverageOrZero in interface AggregationRequestable<E>

Parameters:

mapper -

Returns:

the average of the values the given valueMapper maps from the elements of the current AggregationRequestable if the current AggregationRequestable contains any, 0.0 otherwise. Maps null elements to 0.0.

getCount

public final int getCount(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getCount in interface CountRequestable<E>

Parameters:

selector -

Returns:

the number of elements the given selector selects from the current CountRequestable. Ignores null elements.

getCountOf

public final int getCountOf(Object element)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getCountOf in interface CountRequestable<E>

Parameters:

element -

Returns:

the number how many times the current CountRequestable contains the given element.

getOneBasedIndexOfFirst

public final int getOneBasedIndexOfFirst(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getOneBasedIndexOfFirst in interface IndexRequestable<E>

Parameters:

selector -

Returns:

the 1-based index of the first element the given selector selects from the current IndexRequestable. Ignores null elements.

getOneBasedIndexOfFirstEqualElement

public final int getOneBasedIndexOfFirstEqualElement(Object object)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getOneBasedIndexOfFirstEqualElement in interface IndexRequestable<E>

Parameters:

object -

Returns:

the 1-based index of the first element of the current IndexRequestable that equals the given object.

getOneBasedIndexOfFirstOccurrenceOf

public final int getOneBasedIndexOfFirstOccurrenceOf(Object object)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getOneBasedIndexOfFirstOccurrenceOf in interface IndexRequestable<E>

Parameters:

object -

Returns:

the 1-based index of the first occurrence of the given object in the current IndexRequestable.

getMax

public final <C extends Comparable<C>> C getMax(Function<E,C> comparableMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getMax in interface AggregationRequestable<E>

Type Parameters:

C - is the type of the Comparables the given comparableMapper maps from the elements of the current AggregationRequestable.

Parameters:

comparableMapper -

Returns:

the biggest Comparable the given comparableMapper maps from the elements of the current AggregationRequestable. Ignores null elements.

getMaxOrZero

public final double getMaxOrZero(Function<E,Number> numberMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getMaxOrZero in interface AggregationRequestable<E>

Parameters:

numberMapper -

Returns:

the biggest number the given numberMapper maps from the non-null elements of the current AggregationRequestable if the current AggregationRequestable contains non-null elements, 0.0 otherwise.

getMedian

public final double getMedian(Function<E,Number> numberMapper)

The time complexity of this implementation is O(n*log(n)) if the current AbstractContainer contains n elements.

Specified by:

getMedian in interface AggregationRequestable<E>

Parameters:

numberMapper -

Returns:

the median of the numbers the given numberMapper maps from the elements of the current AggregationRequestable. Maps null elements to 0.0.

getMedianOrZero

public final double getMedianOrZero(Function<E,Number> norm)

The time complexity of this implementation is O(n*log(n)) if the current AbstractContainer contains n elements.

Specified by:

getMedianOrZero in interface AggregationRequestable<E>

Parameters:

norm -

Returns:

the median of the numbers the given numberMapper maps from the elements of the current AggregationRequestable if the current AggregationRequestable is not empty, 0.0 otherwise. Maps null elements to 0.0.

getMin

public final <C extends Comparable<C>> C getMin(Function<E,C> comparableMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getMin in interface AggregationRequestable<E>

Type Parameters:

C - is the type of the Comparables the given comparableMapper maps from the elements of the current AggregationRequestable.

Parameters:

comparableMapper -

Returns:

the smallest Comparable the given comparableMapper maps from the elements of the current AggregationRequestable. Ignores null elements.

getMinOrZero

public final double getMinOrZero(Function<E,Number> numberMapper)

Specified by:

getMinOrZero in interface AggregationRequestable<E>

Parameters:

numberMapper -

Returns:

the smallest number the given numberMapper maps from the non-null elements of the current AggregationRequestable if the current AggregationRequestable contains non-null elements, 0.0 otherwise.

getOptionalStoredFirst

public final Optional<E> getOptionalStoredFirst()

The time complexity of this implementation is O(1).

Specified by:

getOptionalStoredFirst in interface SingleSearchable<E>

Returns:

a Optional with the first element of the current SingleSearchable if the current SingleSearchable is not empty and if the first element of the current SingleSearchable is not null, an empty Optional otherwise.

getOptionalStoredFirst

public final Optional<E> getOptionalStoredFirst(Predicate<? super E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getOptionalStoredFirst in interface SingleSearchable<E>

Parameters:

selector -

Returns:

a new Optional with the first element the given selector selects from the current SingleSearchable if the current SingleSearchable contains an element the given selector selects, an empty Optional otherwise. Ignores null elements.

getStandardDeviation

public final double getStandardDeviation(Function<E,Number> norm)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStandardDeviation in interface AggregationRequestable<E>

Parameters:

norm -

Returns:

the standard deviation of the numbers the given numberMapper maps from the elements of the current AggregationRequestable.

getStoredByMax

public final <C extends Comparable<C>> E getStoredByMax(Function<E,C> comparableMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredByMax in interface SingleSearchable<E>

Type Parameters:

C - is the type of the Comparables the given comparableMapper maps from the elements of the current SingleSearchable.

Parameters:

comparableMapper -

Returns:

the element with the biggest Comparable the given comparableMapper maps from the elements of the current SingleSearchable. Ignores null elements.

getStoredByMin

public final <C extends Comparable<C>> E getStoredByMin(Function<E,C> comparableMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredByMin in interface SingleSearchable<E>

Type Parameters:

C - is the type of the Comparables the given comparableMapper maps from the elements of the current SingleSearchable.

Parameters:

comparableMapper -

Returns:

the element with the smallest Comparable the given comparableMapper maps from the elements of the current SingleSearchable. Ignores null elements.

getStoredFirst

public final E getStoredFirst()

The time complexity of this implementation is O(1).

Specified by:

getStoredFirst in interface SingleSearchable<E>

Returns:

the first element of the current SingleSearchable. The element can be null.

getStoredFirst

public final E getStoredFirst(Predicate<? super E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredFirst in interface SingleSearchable<E>

Parameters:

selector -

Returns:

the first element the given selector selects from the current SingleSearchable. Ignores null elements.

getStoredFirstOfType

public final <T extends E> T getStoredFirstOfType(Class<T> type)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredFirstOfType in interface SingleSearchable<E>

Type Parameters:

T - is the given type.

Parameters:

type -

Returns:

the first element from the current SingleSearchable that is of the given type.

getStoredInGroups

public final IContainer<? extends IContainer<E>> getStoredInGroups(Function<E,?> norm)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -The given norm assignes the elements of the current AbstractContainer in n groups.

Specified by:

getStoredInGroups in interface Groupable<E>

Parameters:

norm -

Returns:

a new IContainer with the elements of the current Groupable grouped by the given norm. Ignores null elements.

getStoredLast

public final E getStoredLast()

The time complexity of this implementation is O(1) or O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredLast in interface SingleSearchable<E>

Returns:

the last element of the current SingleSearchable. The element can be null.

getStoredOfType

public final <T extends E> IContainer<T> getStoredOfType(Class<T> type)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredOfType in interface Filterable<E>

Type Parameters:

T - is the type of the elements of the returned IContainer.

Parameters:

type -

Returns:

a new IContainer with the elements from the current Filterable that are of the given type. Ignores null elements.

getStoredOne

public final E getStoredOne()

The time complexity of this implementation is O(1).

Specified by:

getStoredOne in interface SingleSearchable<E>

Returns:

the one element of the current SingleSearchable. The element can be null.

getStoredOne

public final E getStoredOne(Predicate<? super E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredOne in interface SingleSearchable<E>

Parameters:

selector -

Returns:

the one element the given selector selects from the current SingleSearchable. Ignores null elements.

getStoredOthers

public final IContainer<E> getStoredOthers(Predicate<E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredOthers in interface Filterable<E>

Parameters:

selector -

Returns:

a new IContainer with the elements from the current Filterable the given selector skips. Ignores null elements.

getStoredSelected

public final IContainer<E> getStoredSelected(Predicate<? super E> selector)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getStoredSelected in interface Filterable<E>

Parameters:

selector -

Returns:

a new IContainer with the elements the given selector selects from the current Filterable. Ignores null elements.

getSum

public final BigDecimal getSum(Function<E,Number> valueMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getSum in interface AggregationRequestable<E>

Parameters:

valueMapper -

Returns:

the sum of the values the given valueMapper maps from the elements of the current AggregationRequestable. Maps null elements to 0.0.

getSumOfInts

public final BigInteger getSumOfInts(ToIntFunction<E> intMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getSumOfInts in interface AggregationRequestable<E>

Parameters:

intMapper -

Returns:

the sum of the ints the given intMapper maps from the elements of the current AggregationRequestable. Maps null elements to 0.0.

getVariance

public final double getVariance(Function<E,Number> numberMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getVariance in interface AggregationRequestable<E>

Parameters:

numberMapper -

Returns:

the variance of the numbers the given numberMapper maps from the elements of the current AggregationRequestable. Maps null elements to 0.0.

getViewOf

public <T> IContainer<T> getViewOf(Function<E,T> mapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

getViewOf in interface IMappingContainerViewProvider<E>

Type Parameters:

T - is the type of the elements the given mapper maps from the elements of the current IMappingContainerViewProvider.

Parameters:

mapper -

Returns:

a new IContainer with the elements the given mapper maps from the elements of the current IMappingContainerViewProvider.

getViewFromOneBasedStartIndex

public final IContainer<E> getViewFromOneBasedStartIndex(int oneBasedStartIndex)

The time complexity of this implementation is O(1).

Specified by:

getViewFromOneBasedStartIndex in interface IIntervallContainerViewProvider<E>

Parameters:

oneBasedStartIndex -

Returns:

a new view of the current IIntervallContainerViewProvider from the given oneBasedStartIndex.

getViewToOneBasedEndIndex

public final IContainer<E> getViewToOneBasedEndIndex(int oneBasedEndIndex)

The time complexity of this implementation is O(1).

Specified by:

getViewToOneBasedEndIndex in interface IIntervallContainerViewProvider<E>

Parameters:

oneBasedEndIndex -

Returns:

a new view IContainer of the current IIntervallContainerViewProvider to the given oneBasedEndIndex.

getViewWithoutFirst

public final IContainer<E> getViewWithoutFirst()

The time complexity of this implementation is O(1).

Specified by:

getViewWithoutFirst in interface IIntervallContainerViewProvider<E>

Returns:

a new view IContainer view of the current IIntervallContainerViewProvider without the first element.

getViewWithoutFirst

public final IContainer<E> getViewWithoutFirst(int n)

The time complexity of this implementation is O(1).

Specified by:

getViewWithoutFirst in interface IIntervallContainerViewProvider<E>

Parameters:

n -

Returns:

a new view IContainer view of the current IIntervallContainerViewProvider without the first n elements.

getViewWithoutLast

public final IContainer<E> getViewWithoutLast()

The time complexity of this implementation is O(1).

Specified by:

getViewWithoutLast in interface IIntervallContainerViewProvider<E>

Returns:

a new view IContainer view of the current IIntervallContainerViewProvider without the last element.

getViewWithoutLast

public final IContainer<E> getViewWithoutLast(int n)

The time complexity of this implementation is O(1).

Specified by:

getViewWithoutLast in interface IIntervallContainerViewProvider<E>

Parameters:

n -

Returns:

a new view IContainer of the current IIntervallContainerViewProvider without the last n elements.

isEmpty

public final boolean isEmpty()

The time complexity of this implementation is O(1) if the current Container does not contain null elements. The time complexity of this implementation is O(n) if the current Container contains null elements and if the current Container contains n elements.

Specified by:

isEmpty in interface EmptinessRequestable

Returns:

true if EmptinessRequestable does not contain an element, false otherwise.

to

public final <T> IContainer<T> to(Function<E,T> mapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

to in interface Mappable<E>

Type Parameters:

T - is the type of the elements the given mapper maps from the elements of the current Mappable.

Parameters:

mapper -

Returns:

a new IContainer with the elements the given mapper maps from the elements of the current Mappable.

toArray

public final Object[] toArray()

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toArray in interface ArrayMappable<E>

Returns:

a new array with the elements of the current ArrayMappable.

toByteArray

public final byte[] toByteArray(Function<E,Byte> byteMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toByteArray in interface ArrayMappable<E>

Parameters:

byteMapper -

Returns:

a new array with the bytes the given byteMapper maps from the elements of the current ArrayMappable. Maps null elements to 0.

toCharArray

public final char[] toCharArray(Function<E, Character> charMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toCharArray in interface ArrayMappable<E>

Parameters:

charMapper -

Returns:

a new array with the chars the given charMapper maps from the elements of the current ArrayMappable. Maps null elements to a space.

toConcatenatedString

public final String toConcatenatedString()

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toConcatenatedString in interface StringMappable

Returns:

a concatenation of the String representations of the elements of the current StringMappable.

toDoubleArray

public final double[] toDoubleArray(ToDoubleFunction<E> doubleMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toDoubleArray in interface ArrayMappable<E>

Parameters:

doubleMapper -

Returns:

a new array with the doubles the given doubleMapper maps from the elements of the current ArrayMappable. Maps null elements to 0.0.

toIntArray

public final int[] toIntArray(ToIntFunction<E> intMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toIntArray in interface ArrayMappable<E>

Parameters:

intMapper -

Returns:

a new array with the ints the given intMapper maps from the elements of the current ArrayMappable. Maps null elements to 0. Maps null elements to 0.

toLongArray

public final long[] toLongArray(ToLongFunction<E> longMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toLongArray in interface ArrayMappable<E>

Parameters:

longMapper -

Returns:

a new array with the longs the given longMapper maps from the elements of the current ArrayMappable. Maps null elements to 0.

toMultiples

public final <T> IContainer<T> toMultiples(Function<E, IContainer<T>> multipleMapper)

The time complexity of this implementation is O(m*n) if: -The current * AbstractContainer contains m elements. -On average, the given multipleMapper maps n elements from an element of the current AbstractContainer.

Specified by:

toMultiples in interface Mappable<E>

Type Parameters:

T - is the type of the elements of the IContainers the given multipleMapper maps from the elements of the current Mappable.

Parameters:

multipleMapper -

Returns:

a new IContainer with the elements of the IContainers the given multipleMapper maps from the elements of the current Mappable.

toNumbers

public <N extends Number> IContainer<N> toNumbers(Function<E,N> numberMapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toNumbers in interface Mappable<E>

Type Parameters:

N - is the type of the Numbers the given numberMapper maps from the elements of the current Mappable.

Parameters:

numberMapper -

Returns:

a new IContainer with the Numbers the given numberMapper maps from the elements of the current Mappable. Maps null elements to 0.0.

toReversedList

public final IContainer<E> toReversedList()

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toReversedList in interface IContainer<E>

Returns:

a new IContainer with the elements of the current IContainer in reversed order.

toStringArray

public final String[] toStringArray()

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toStringArray in interface ArrayMappable<E>

Returns:

a new array with the String representations of the elements of the current ArrayMappable.

toStrings

public final IContainer<String> toStrings()

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toStrings in interface Mappable<E>

Returns:

a new IContainer with the String representations of the elements of the current IContainer.

toStringWithSeparator

public final String toStringWithSeparator(char separator)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toStringWithSeparator in interface StringMappable

Parameters:

separator -

Returns:

a concatenation of the String representations of the elements of the current StringMappable with the given separator in between.

toStringWithSeparator

public final String toStringWithSeparator(String separator)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toStringWithSeparator in interface StringMappable

Parameters:

separator -

Returns:

a concatenation of the String representations of the elements of the current StringMappable with the given separator in between.

toWithOneBasedIndex

public final <T> IContainer<T> toWithOneBasedIndex(BiFunction<Integer,E,T> mapper)

The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.

Specified by:

toWithOneBasedIndex in interface Mappable<E>

Type Parameters:

T - is the type of the elements the given mapper maps from the elements of the current Mappable and from the one-based index of these elements.

Parameters:

mapper -

Returns:

a new IContainer with the elements the given mapper maps from the elements of the current Mappable and from the one-based index of these elements.