java.lang.Object

ch.nolix.core.container.base.Container<E>

Typparameter:: E - is the type of the elements a Container can store.

Alle implementierten Schnittstellen:: IContainer<E>, IMappableContainer<E>, ISearchableContainer<E>, IStatisticalConainer<E>, IterableWithCopyableIterator<E>, StoringRequestable<E>, EmptinessRequestable, MaterializationRequestable, Iterable<E>

Bekannte direkte Unterklassen:: ArrayList, ArrayReadContainer, CachingContainer, CompressedList, GapMatrix, ImmutableList, IterableReadContainer, LinkedList, Matrix, MatrixColumn, MatrixRow, MultiReadContainer, ReadContainer

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

Version:: 2016-01-01
Autor:: Silvan Wyss

Konstruktorübersicht

Konstruktoren

Konstruktor

Beschreibung

Container()
Methodenübersicht

Modifizierer und Typ

Methode

Beschreibung

final boolean

contains(Object element)

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

final boolean

containsAll(Iterable<?> elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsAll(Object element, Object... elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsAny()

The complexity of this implementation is O(1).

final boolean

containsAny(Object element, Object... elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsAny(Predicate<E> selector)

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

final boolean

containsAnyOf(Iterable<?> elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsAsManyAs(Iterable<?> container)

The complexity of this implementation is -O(1) if the given container is a IContainer.

final boolean

containsEqualing(Object element)

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

final boolean

containsExactlyInSameOrder(Iterable<?> container)

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

final boolean

containsLessThan(Iterable<?> container)

The complexity of this implementation is -O(1) if the given container is a IContainer.

final boolean

containsMoreThan(Iterable<?> container)

The complexity of this implementation is O(1).

final boolean

containsNone(Object element, Object... elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsNone(Predicate<E> selector)

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

final boolean

containsNoneOf(Iterable<?> elements)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsOnce(E element)

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

final boolean

containsOne()

The complexity of this implementation is O(1).

final boolean

containsOne(Predicate<E> selector)

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

final boolean

containsOneEqualing(E element)

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

final boolean

containsOnly(Predicate<E> selector)

The complexity of this implementation is O(m*n) if: -The current Container contains m elements.

final boolean

containsOnlyEqualingAndViceVersa(Iterable<?> container)

The complexity of this implementation is O(m*n) if the current Container contains m elements and the container contains n elements.

protected abstract <E2> ILinkedList<E2>

createEmptyMutableList(Marker<E2> marker)

final IContainer<E>

from1BasedStartIndex(int startIndex)

The complexity of this implementation is O(1).

final IContainer<E>

from1BasedStartIndexUntil1BasedEndIndex(int startIndex, int endIndex)

The complexity of this implementation is O(1).

final int

get1BasedIndexOfFirst(Predicate<E> selector)

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

final int

get1BasedIndexOfFirstEqualElement(E element)

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

final int

get1BasedIndexOfFirstOccuranceOf(E element)

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

final double

getAverage(Function<E,Number> norm)

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

final double

getAverageOrZero(Function<E,Number> norm)

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

final int

getCount(Object element)

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

final int

getCount(Predicate<E> selector)

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

final <C extends Comparable<C>> C

getMax(Function<E,C> norm)

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

final double

getMaxOrZero(Function<E,Number> norm)

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

final double

getMedian(Function<E,Number> norm)

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

final double

getMedianOrZero(Function<E,Number> norm)

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

final <C extends Comparable<C>> C

getMin(Function<E,C> norm)

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

final double

getMinOrZero(Function<E,Number> norm)

final Optional<E>

getOptionalStoredFirst()

The complexity of this implementation is O(1).

final Optional<E>

getOptionalStoredFirst(Predicate<? super E> selector)

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

final double

getStandardDeviation(Function<E,Number> norm)

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

final E

getStoredAny()

The complexity of this implementation is O(1).

final <C extends Comparable<C>> E

getStoredByMax(Function<E,C> norm)

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

final <C extends Comparable<C>> E

getStoredByMin(Function<E,C> norm)

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

final E

getStoredFirst()

The complexity of this implementation is O(1).

final E

getStoredFirst(Predicate<? super E> selector)

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

final IContainer<? extends IContainer<E>>

getStoredGroups(Function<E,?> norm)

The complexity of this implementation is O(n^2) if the current Container contains n elements.

final <E2 extends E> IContainer<E2>

getStoredOfType(Class<E2> type)

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

final E

getStoredOne()

The complexity of this implementation is O(1).

final E

getStoredOne(Predicate<? super E> selector)

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

final IContainer<E>

getStoredOther(Predicate<E> selector)

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

final IContainer<E>

getStoredSelected(Predicate<? super E> selector)

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

final BigDecimal

getSum(Function<E,Number> norm)

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

final BigInteger

getSumOfIntegers(ToIntFunction<E> norm)

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

final double

getVariance(Function<E,Number> norm)

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

final boolean

isEmpty()

The complexity of this implementation is O(1).

final <E2> IContainer<E2>

to(Function<E,E2> extractor)

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

final Object[]

toArray()

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

final byte[]

toByteArray(Function<E,Byte> byteNorm)

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

final char[]

toCharArray(Function<E,Character> charNorm)

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

final String

toConcatenatedString()

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

final double[]

toDoubleArray(ToDoubleFunction<E> doubleNorm)

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

final <E2> IContainer<E2>

toFromGroups(Function<E,IContainer<E2>> extractor)

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

final int[]

toIntArray(ToIntFunction<E> intNorm)

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

final long[]

toLongArray(ToLongFunction<E> longNorm)

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

final IContainer<E>

toReversedList()

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

final String[]

toStringArray()

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

final IContainer<String>

toStrings()

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

final String

toStringWithSeparator(char separator)

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

final String

toStringWithSeparator(String separator)

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

final IContainer<E>

until1BasedIndex(int endIndex)

The complexity of this implementation is O(1).

final IContainer<E>

withoutFirst()

The complexity of this implementation is O(1).

final IContainer<E>

withoutFirst(int n)

The complexity of this implementation is O(1).

final IContainer<E>

withoutLast()

The complexity of this implementation is O(1).

final IContainer<E>

withoutLast(int n)

The complexity of this implementation is O(1).

Von Klasse geerbte Methoden java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IContainer
toOrderedList

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.ISearchableContainer
getStoredAt1BasedIndex, getStoredLast

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IStatisticalConainer
getCount

Von Schnittstelle geerbte Methoden java.lang.Iterable
forEach, spliterator

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IterableWithCopyableIterator
iterator

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.stateapi.staterequestapi.MaterializationRequestable
isMaterialized, isView

Konstruktordetails
- Container
  
  public Container()
Methodendetails
- contains
  
  public final boolean contains(Object element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  contains in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given element.
- containsAll
  
  public final boolean containsAll(Object element, Object... elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsAll in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given element and all of the given elements.
- containsAll
  
  public final boolean containsAll(Iterable<?> elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsAll in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains all of the given elements.
- containsAny
  
  public final boolean containsAny()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  containsAny in Schnittstelle EmptinessRequestable
  
  Gibt zurück:
  
  true if the current EmptinessRequestable contains one or several elements.
- containsAny
  
  public final boolean containsAny(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsAny in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains an element the given selector selects.
- containsAny
  
  public final boolean containsAny(Object element, Object... elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsAny in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given element or one of the given elements.
- containsAnyOf
  
  public final boolean containsAnyOf(Iterable<?> elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsAnyOf in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains any of the given elements.
- containsAsManyAs
  
  public final boolean containsAsManyAs(Iterable<?> container)
  
  The complexity of this implementation is -O(1) if the given container is a IContainer. -O(n) otherwise.
  
  Angegeben von:
  
  containsAsManyAs in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  container -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains as many elements as the given container.
- containsEqualing
  
  public final boolean containsEqualing(Object element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsEqualing in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains an element that equals the given given element.
- containsExactlyInSameOrder
  
  public final boolean containsExactlyInSameOrder(Iterable<?> container)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsExactlyInSameOrder in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  container -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains exactly the elements of the given container in the same order, false otherwise.
- containsLessThan
  
  public final boolean containsLessThan(Iterable<?> container)
  
  The complexity of this implementation is -O(1) if the given container is a IContainer. -O(n) otherwise.
  
  Angegeben von:
  
  containsLessThan in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  container -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains less elements than the given container.
- containsMoreThan
  
  public final boolean containsMoreThan(Iterable<?> container)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  containsMoreThan in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  container -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains more elements than the given container.
- containsNone
  
  public final boolean containsNone(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsNone in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable does not contain an element the given selector selects.
- containsNone
  
  public final boolean containsNone(Object element, Object... elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsNone in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable does not contain the given element and none of the given elements.
- containsNoneOf
  
  public final boolean containsNoneOf(Iterable<?> elements)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsNoneOf in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable does not contain any element of the given elements.
- containsOnce
  
  public final boolean containsOnce(E element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsOnce in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given element exactly 1 time.
- containsOne
  
  public final boolean containsOne()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  containsOne in Schnittstelle StoringRequestable<E>
  
  Gibt zurück:
  
  true if the current StoringRequestable contains exactly 1 element.
- containsOne
  
  public final boolean containsOne(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsOne in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains exactly 1 element the given selector selects.
- containsOneEqualing
  
  public final boolean containsOneEqualing(E element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  containsOneEqualing in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains exactly 1 element that equals the given element.
- containsOnly
  
  public final boolean containsOnly(Predicate<E> selector)
  
  The complexity of this implementation is O(m*n) if: -The current Container contains m elements. -n elements are given.
  
  Angegeben von:
  
  containsOnly in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains only elements the given selector selects.
- containsOnlyEqualingAndViceVersa
  
  public final boolean containsOnlyEqualingAndViceVersa(Iterable<?> container)
  
  The complexity of this implementation is O(m*n) if the current Container contains m elements and the container contains n elements.
  
  Angegeben von:
  
  containsOnlyEqualingAndViceVersa in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  container -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains only elements that equal an element in the given container and vice versa.
- from1BasedStartIndex
  
  public final IContainer<E> from1BasedStartIndex(int startIndex)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  from1BasedStartIndex in Schnittstelle IContainer<E>
  
  Parameter:
  
  startIndex -
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer from the given p1BasedStartIndex.
- from1BasedStartIndexUntil1BasedEndIndex
  
  public final IContainer<E> from1BasedStartIndexUntil1BasedEndIndex(int startIndex, int endIndex)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  from1BasedStartIndexUntil1BasedEndIndex in Schnittstelle IContainer<E>
  
  Parameter:
  
  startIndex -
  
  endIndex -
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer from the given p1BasedStartIndex to the given p1BasedEndIndex.
- getAverage
  
  public final double getAverage(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getAverage in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the average of the values the given norm returns from the elements of the current IStatisticalConainer.
- getAverageOrZero
  
  public final double getAverageOrZero(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getAverageOrZero in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the average of the values the given norm returns from the elements of the current IStatisticalConainer if the current IStatisticalConainer contains elements, 0.0 otherwise.
- getCount
  
  public final int getCount(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getCount in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  the number of elements the given selector selects from the current IStatisticalConainer.
- getCount
  
  public final int getCount(Object element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getCount in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  the number how many times the current IStatisticalConainer contains the given element.
- get1BasedIndexOfFirst
  
  public final int get1BasedIndexOfFirst(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  get1BasedIndexOfFirst in Schnittstelle IContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  the 1 based index of the first element the given selector selects from the current IContainer.
- get1BasedIndexOfFirstEqualElement
  
  public final int get1BasedIndexOfFirstEqualElement(E element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  get1BasedIndexOfFirstEqualElement in Schnittstelle IContainer<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  the 1-based index of the first element of the current IContainer that equals the given element.
- get1BasedIndexOfFirstOccuranceOf
  
  public final int get1BasedIndexOfFirstOccuranceOf(E element)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  get1BasedIndexOfFirstOccuranceOf in Schnittstelle IContainer<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  the 1-based index of the given element in the current IContainer.
- getMax
  
  public final <C extends Comparable<C>> C getMax(Function<E,C> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getMax in Schnittstelle IStatisticalConainer<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given norm returns.
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the biggest Comparable the given norm returns from the elements of the current IStatisticalConainer.
- getMaxOrZero
  
  public final double getMaxOrZero(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getMaxOrZero in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the biggest value the given norm returns from the elements of the current IStatisticalConainer if the current IStatisticalConainer contains elements, 0.0 otherwise.
- getMedian
  
  public final double getMedian(Function<E,Number> norm)
  
  The complexity of this implementation is O(n*log(n)) if the current Container contains n elements.
  
  Angegeben von:
  
  getMedian in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the median of the values the given norm returns from the elements of the current IStatisticalConainer.
- getMedianOrZero
  
  public final double getMedianOrZero(Function<E,Number> norm)
  
  The complexity of this implementation is O(n*log(n)) if the current Container contains n elements.
  
  Angegeben von:
  
  getMedianOrZero in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the median of the values the given norm returns from the elements of the current IStatisticalConainer if the current IStatisticalConainer contains elements, 0.0 otherwise.
- getMin
  
  public final <C extends Comparable<C>> C getMin(Function<E,C> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getMin in Schnittstelle IStatisticalConainer<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given norm returns.
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the smallest Comparable the given norm returns from the elements of the current IStatisticalConainer.
- getMinOrZero
  
  public final double getMinOrZero(Function<E,Number> norm)
  
  Angegeben von:
  
  getMinOrZero in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the smallest value the given norm returns from the elements of the current IStatisticalConainer if the current IStatisticalConainer contains elements, 0.0 otherwise.
- getOptionalStoredFirst
  
  public final Optional<E> getOptionalStoredFirst()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  getOptionalStoredFirst in Schnittstelle ISearchableContainer<E>
  
  Gibt zurück:
  
  a Optional with the first element of the current ISearchableContainer if the current ISearchableContainer contains any, an empty Optional otherwise.
- getOptionalStoredFirst
  
  public final Optional<E> getOptionalStoredFirst(Predicate<? super E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getOptionalStoredFirst in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  a new Optional with the first element the given selector selects from the current ISearchableContainer if the current ISearchableContainer contains an element the given selector selects, an empty Optional otherwise.
- getStoredAny
  
  public final E getStoredAny()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  getStoredAny in Schnittstelle ISearchableContainer<E>
  
  Gibt zurück:
  
  a randomly selected element of the current ISearchableContainer.
- getStoredByMax
  
  public final <C extends Comparable<C>> E getStoredByMax(Function<E,C> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredByMax in Schnittstelle ISearchableContainer<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given norm returns.
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the element with the biggest Comparable the given norm returns from the elements of the current ISearchableContainer.
- getStoredByMin
  
  public final <C extends Comparable<C>> E getStoredByMin(Function<E,C> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredByMin in Schnittstelle ISearchableContainer<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given norm returns.
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the element with the smallest Comparable the given norm returns from the elements of the current ISearchableContainer.
- getStoredFirst
  
  public final E getStoredFirst()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  getStoredFirst in Schnittstelle ISearchableContainer<E>
  
  Gibt zurück:
  
  the first element of the current ISearchableContainer.
- getStoredFirst
  
  public final E getStoredFirst(Predicate<? super E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredFirst in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  the first element the given selector selects from the current ISearchableContainer.
- getStoredGroups
  
  public final IContainer<? extends IContainer<E>> getStoredGroups(Function<E,?> norm)
  
  The complexity of this implementation is O(n^2) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredGroups in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  a new ISearchableContainer with groups with the elements of the current ISearchableContainer grouped by the given norm.
- getStoredOfType
  
  public final <E2 extends E> IContainer<E2> getStoredOfType(Class<E2> type)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredOfType in Schnittstelle ISearchableContainer<E>
  
  Typparameter:
  
  E2 - is the type of the elements of the returned ISearchableContainer.
  
  Parameter:
  
  type -
  
  Gibt zurück:
  
  a new ISearchableContainer with the elements from the current ISearchableContainer that are of the given type.
- getStoredOne
  
  public final E getStoredOne()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  getStoredOne in Schnittstelle ISearchableContainer<E>
  
  Gibt zurück:
  
  the one element of the current ISearchableContainer.
- getStoredOne
  
  public final E getStoredOne(Predicate<? super E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredOne in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  the one element the given selector selects from the current ISearchableContainer.
- getStoredOther
  
  public final IContainer<E> getStoredOther(Predicate<E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredOther in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  a new ISearchableContainer with the elements from the current ISearchableContainer the given selector skips (!).
- getStoredSelected
  
  public final IContainer<E> getStoredSelected(Predicate<? super E> selector)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStoredSelected in Schnittstelle ISearchableContainer<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  a new ISearchableContainer with the elements the given selector selects from the current ISearchableContainer.
- getStandardDeviation
  
  public final double getStandardDeviation(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getStandardDeviation in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the standard deviation of the values the given norm returns from the elements of the current IStatisticalConainer.
- getSum
  
  public final BigDecimal getSum(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getSum in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the sum of the values the given norm returns from the elements of the current IStatisticalConainer.
- getSumOfIntegers
  
  public final BigInteger getSumOfIntegers(ToIntFunction<E> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getSumOfIntegers in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the sum of the integers the given norm returns from the elements of the current IStatisticalConainer.
- getVariance
  
  public final double getVariance(Function<E,Number> norm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  getVariance in Schnittstelle IStatisticalConainer<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  the variance of the values the given norm returns from the elements of the current IStatisticalConainer.
- isEmpty
  
  public final boolean isEmpty()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  isEmpty in Schnittstelle EmptinessRequestable
  
  Gibt zurück:
  
  true if EmptinessRequestable does not contain an element.
- to
  
  public final <E2> IContainer<E2> to(Function<E,E2> extractor)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  to in Schnittstelle IMappableContainer<E>
  
  Typparameter:
  
  E2 - is the type of the elements the given extractor returns.
  
  Parameter:
  
  extractor -
  
  Gibt zurück:
  
  a new IMappableContainer with the elements the given extractor extracts from the elements of the current IMappableContainer.
- toArray
  
  public final Object[] toArray()
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toArray in Schnittstelle IMappableContainer<E>
  
  Gibt zurück:
  
  a new array with the elements of the current IMappableContainer.
- toByteArray
  
  public final byte[] toByteArray(Function<E,Byte> byteNorm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toByteArray in Schnittstelle IMappableContainer<E>
  
  Parameter:
  
  byteNorm -
  
  Gibt zurück:
  
  a new array with the bytes the given byteGetter returns from the elements of the current IMappableContainer.
- toCharArray
  
  public final char[] toCharArray(Function<E,Character> charNorm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toCharArray in Schnittstelle IMappableContainer<E>
  
  Parameter:
  
  charNorm -
  
  Gibt zurück:
  
  a new array with the chars the given charGetter returns from the elements of the current IMappableContainer.
- toConcatenatedString
  
  public final String toConcatenatedString()
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toConcatenatedString in Schnittstelle IMappableContainer<E>
  
  Gibt zurück:
  
  a concatenated String representation of the current IMappableContainer.
- toDoubleArray
  
  public final double[] toDoubleArray(ToDoubleFunction<E> doubleNorm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toDoubleArray in Schnittstelle IMappableContainer<E>
  
  Parameter:
  
  doubleNorm -
  
  Gibt zurück:
  
  a new array with the doubles the given doubleGetter returns from the elements of the current IMappableContainer.
- toFromGroups
  
  public final <E2> IContainer<E2> toFromGroups(Function<E,IContainer<E2>> extractor)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toFromGroups in Schnittstelle IMappableContainer<E>
  
  Typparameter:
  
  E2 - is the type of the elements of the IMappableContainers the given extractor returns.
  
  Parameter:
  
  extractor -
  
  Gibt zurück:
  
  a new IMappableContainer with the elements of the IMappableContainers the given extractor extracts from the elements of the current IMappableContainer.
- toIntArray
  
  public final int[] toIntArray(ToIntFunction<E> intNorm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toIntArray in Schnittstelle IMappableContainer<E>
  
  Parameter:
  
  intNorm -
  
  Gibt zurück:
  
  a new array with the ints the given intGetter returns from the elements of the current IMappableContainer.
- toLongArray
  
  public final long[] toLongArray(ToLongFunction<E> longNorm)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toLongArray in Schnittstelle IMappableContainer<E>
  
  Parameter:
  
  longNorm -
  
  Gibt zurück:
  
  a new array with the longs the given longGetter returns from the elements of the current IMappableContainer.
- toReversedList
  
  public final IContainer<E> toReversedList()
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toReversedList in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  a new IContainer with the elements of the current IContainer in the reversed order.
- toStringArray
  
  public final String[] toStringArray()
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toStringArray in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  a new array with the Strings that represent the elements of the current IContainer.
- toStrings
  
  public final IContainer<String> toStrings()
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toStrings in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  a new IContainer with the String representations of the elements of the current IContainer.
- toStringWithSeparator
  
  public final String toStringWithSeparator(char separator)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toStringWithSeparator in Schnittstelle IContainer<E>
  
  Parameter:
  
  separator -
  
  Gibt zurück:
  
  a String representation the current IContainer with the given separator.
- toStringWithSeparator
  
  public final String toStringWithSeparator(String separator)
  
  The complexity of this implementation is O(n) if the current Container contains n elements.
  
  Angegeben von:
  
  toStringWithSeparator in Schnittstelle IContainer<E>
  
  Parameter:
  
  separator -
  
  Gibt zurück:
  
  a String representation of the current IContainer with the given separator.
- until1BasedIndex
  
  public final IContainer<E> until1BasedIndex(int endIndex)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  until1BasedIndex in Schnittstelle IContainer<E>
  
  Parameter:
  
  endIndex -
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer with the elements to the given p1BasedEndIndex.
- withoutFirst
  
  public final IContainer<E> withoutFirst()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  withoutFirst in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer without the first element.
- withoutFirst
  
  public final IContainer<E> withoutFirst(int n)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  withoutFirst in Schnittstelle IContainer<E>
  
  Parameter:
  
  n -
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer without the first n elements.
- withoutLast
  
  public final IContainer<E> withoutLast()
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  withoutLast in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer without the last element.
- withoutLast
  
  public final IContainer<E> withoutLast(int n)
  
  The complexity of this implementation is O(1).
  
  Angegeben von:
  
  withoutLast in Schnittstelle IContainer<E>
  
  Parameter:
  
  n -
  
  Gibt zurück:
  
  a new sub IContainer of the current IContainer without the last n elements of the current IContainer.
- createEmptyMutableList
  
  protected abstract <E2> ILinkedList<E2> createEmptyMutableList(Marker<E2> marker)
  
  Typparameter:
  
  E2 - is the type of the elements the created ILinkedList can contain.
  
  Parameter:
  
  marker -
  
  Gibt zurück:
  
  a new empty ILinkedList.

Klasse Container<E>

Konstruktorübersicht

Methodenübersicht

Von Klasse geerbte Methoden java.lang.Object

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IContainer

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.ISearchableContainer

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IStatisticalConainer

Von Schnittstelle geerbte Methoden java.lang.Iterable

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IterableWithCopyableIterator

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.stateapi.staterequestapi.MaterializationRequestable

Konstruktordetails

Container

Methodendetails

contains

containsAll

containsAll

containsAny

containsAny

containsAny

containsAnyOf

containsAsManyAs

containsEqualing

containsExactlyInSameOrder

containsLessThan

containsMoreThan

containsNone

containsNone

containsNoneOf

containsOnce

containsOne

containsOne

containsOneEqualing

containsOnly

containsOnlyEqualingAndViceVersa

from1BasedStartIndex

from1BasedStartIndexUntil1BasedEndIndex

getAverage

getAverageOrZero

getCount

getCount

get1BasedIndexOfFirst

get1BasedIndexOfFirstEqualElement

get1BasedIndexOfFirstOccuranceOf

getMax

getMaxOrZero

getMedian

getMedianOrZero

getMin

getMinOrZero

getOptionalStoredFirst

getOptionalStoredFirst

getStoredAny

getStoredByMax

getStoredByMin

getStoredFirst

getStoredFirst

getStoredGroups

getStoredOfType

getStoredOne

getStoredOne

getStoredOther

getStoredSelected

getStandardDeviation

getSum

getSumOfIntegers

getVariance

isEmpty

to

toArray

toByteArray

toCharArray

toConcatenatedString

toDoubleArray

toFromGroups

toIntArray

toLongArray

toReversedList

toStringArray

toStrings

toStringWithSeparator