java.lang.Object

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

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

Alle implementierten Schnittstellen:: 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>

Bekannte direkte Unterklassen:: AbstractExtendedContainer

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

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

Konstruktorübersicht

Konstruktoren

Konstruktor

Beschreibung

AbstractContainer()
Methodenübersicht

Modifizierer und Typ

Methode

Beschreibung

final boolean

contains(Object object)

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

final boolean

containsAll(Iterable<?> objects)

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

final boolean

containsAll(Object[] objects)

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

final boolean

containsAll(Object object, Object... objects)

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

final boolean

containsAny(Object object, 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(Object object, Object... objects)

The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m 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

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.

protected abstract <E2> IArrayList<E2>

createEmptyMutableList(Marker<E2> marker)

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 <E2 extends E> E2

getStoredFirstOfType(Class<E2> 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 <E2 extends E> IContainer<E2>

getStoredOfType(Class<E2> 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 <E2> IContainer<E2>

to(Function<E,E2> 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 <E2> IContainer<E2>

toMultiples(Function<E,IContainer<E2>> 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 <E2> IContainer<E2>

toWithOneBasedIndex(BiFunction<Integer,E,E2> mapper)

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

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.commoncontainerapi.CountRequestable
getCount

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.stateapi.staterequestapi.EmptinessRequestable
containsAny

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

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IFilteringContainerViewProvider
getViewOfStoredSelected

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.baseapi.IIntervallContainerViewProvider
getViewFromOneBasedStartIndexToOneBasedEndIndex

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

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

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

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.commoncontainerapi.SingleSearchable
getStoredAtOneBasedIndex

Konstruktordetails
- AbstractContainer
  
  public AbstractContainer()
Methodendetails
- contains
  
  public final boolean contains(Object object)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  contains in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given object, false otherwise.
- containsAll
  
  public final boolean containsAll(Iterable<?> objects)
  
  The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.
  
  Angegeben von:
  
  containsAll in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  objects -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains all of the given objects, false otherwise.
- containsAll
  
  public final boolean containsAll(Object object, Object... objects)
  
  The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.
  
  Angegeben von:
  
  containsAll in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  objects -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given object and all of the given objects, false otherwise.
- containsAll
  
  public final boolean containsAll(Object[] objects)
  
  The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.
  
  Angegeben von:
  
  containsAll in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  objects -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsAny in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains an element the given selector selects, false otherwise. Ignores null elements.
- containsAny
  
  public final boolean containsAny(Object object, Object... objects)
  
  The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.
  
  Angegeben von:
  
  containsAny in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  objects -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains the given object or one of the given objects, false otherwise.
- 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.
  
  Angegeben von:
  
  containsAnyOf in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  objects -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsAnyOf in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  objects -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains any 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.
  
  Angegeben von:
  
  containsAsManyAs in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  iterable -
  
  Gibt zurück:
  
  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.
  
  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, 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.
  
  Angegeben von:
  
  containsExactlyEqualingInSameOrder in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  iterable -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsExactlyInSameOrder in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  iterable -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsLessThan in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  iterable -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsMoreThan in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  iterable -
  
  Gibt zurück:
  
  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.
  
  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. Ignores null elements.
- containsNone
  
  public final boolean containsNone(Object object, Object... objects)
  
  The time complexity of this implementation is O(m*n) if: -The current AbstractContainer contains m elements. -n objects are given.
  
  Angegeben von:
  
  containsNone in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  objects -
  
  Gibt zurück:
  
  true if the current StoringRequestable does not contain the given object and none of the given objects, false otherwise.
- 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.
  
  Angegeben von:
  
  containsNoneOf in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  elements -
  
  Gibt zurück:
  
  true if the current StoringRequestable does not contain any of the given objects.
- containsOnce
  
  public final boolean containsOnce(Object object)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  containsOnce in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  containsOne in Schnittstelle StoringRequestable<E>
  
  Gibt zurück:
  
  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.
  
  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, 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.
  
  Angegeben von:
  
  containsOneEqualing in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  object -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  containsOnly in Schnittstelle StoringRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  true if the current StoringRequestable contains only elements the given selector selects. 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.
  
  Angegeben von:
  
  getAverage in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  valueMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getAverageOrZero in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  mapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getCount in Schnittstelle CountRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getCountOf in Schnittstelle CountRequestable<E>
  
  Parameter:
  
  element -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getOneBasedIndexOfFirst in Schnittstelle IndexRequestable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getOneBasedIndexOfFirstEqualElement in Schnittstelle IndexRequestable<E>
  
  Parameter:
  
  object -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getOneBasedIndexOfFirstOccurrenceOf in Schnittstelle IndexRequestable<E>
  
  Parameter:
  
  object -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getMax in Schnittstelle AggregationRequestable<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given comparableMapper maps from the elements of the current AggregationRequestable.
  
  Parameter:
  
  comparableMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getMaxOrZero in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  numberMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getMedian in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  numberMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getMedianOrZero in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getMin in Schnittstelle AggregationRequestable<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given comparableMapper maps from the elements of the current AggregationRequestable.
  
  Parameter:
  
  comparableMapper -
  
  Gibt zurück:
  
  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)
  
  Angegeben von:
  
  getMinOrZero in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  numberMapper -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getOptionalStoredFirst in Schnittstelle SingleSearchable<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getOptionalStoredFirst in Schnittstelle SingleSearchable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStandardDeviation in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredByMax in Schnittstelle SingleSearchable<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given comparableMapper maps from the elements of the current SingleSearchable.
  
  Parameter:
  
  comparableMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredByMin in Schnittstelle SingleSearchable<E>
  
  Typparameter:
  
  C - is the type of the Comparables the given comparableMapper maps from the elements of the current SingleSearchable.
  
  Parameter:
  
  comparableMapper -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getStoredFirst in Schnittstelle SingleSearchable<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredFirst in Schnittstelle SingleSearchable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  the first element the given selector selects from the current SingleSearchable. Ignores null elements.
- getStoredFirstOfType
  
  public final <E2 extends E> E2 getStoredFirstOfType(Class<E2> type)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  getStoredFirstOfType in Schnittstelle SingleSearchable<E>
  
  Typparameter:
  
  E2 - is the given type.
  
  Parameter:
  
  type -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredInGroups in Schnittstelle Groupable<E>
  
  Parameter:
  
  norm -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredLast in Schnittstelle SingleSearchable<E>
  
  Gibt zurück:
  
  the last element of the current SingleSearchable. The element can be null.
- getStoredOfType
  
  public final <E2 extends E> IContainer<E2> getStoredOfType(Class<E2> type)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  getStoredOfType in Schnittstelle Filterable<E>
  
  Typparameter:
  
  E2 - is the type of the elements of the returned IContainer.
  
  Parameter:
  
  type -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getStoredOne in Schnittstelle SingleSearchable<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredOne in Schnittstelle SingleSearchable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredOthers in Schnittstelle Filterable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getStoredSelected in Schnittstelle Filterable<E>
  
  Parameter:
  
  selector -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getSum in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  valueMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getSumOfInts in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  intMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getVariance in Schnittstelle AggregationRequestable<E>
  
  Parameter:
  
  numberMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  getViewOf in Schnittstelle IMappingContainerViewProvider<E>
  
  Typparameter:
  
  T - is the type of the elements the given mapper maps from the elements of the current IMappingContainerViewProvider.
  
  Parameter:
  
  mapper -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewFromOneBasedStartIndex in Schnittstelle IIntervallContainerViewProvider<E>
  
  Parameter:
  
  oneBasedStartIndex -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewToOneBasedEndIndex in Schnittstelle IIntervallContainerViewProvider<E>
  
  Parameter:
  
  oneBasedEndIndex -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewWithoutFirst in Schnittstelle IIntervallContainerViewProvider<E>
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewWithoutFirst in Schnittstelle IIntervallContainerViewProvider<E>
  
  Parameter:
  
  n -
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewWithoutLast in Schnittstelle IIntervallContainerViewProvider<E>
  
  Gibt zurück:
  
  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).
  
  Angegeben von:
  
  getViewWithoutLast in Schnittstelle IIntervallContainerViewProvider<E>
  
  Parameter:
  
  n -
  
  Gibt zurück:
  
  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.
  
  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> mapper)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  to in Schnittstelle Mappable<E>
  
  Typparameter:
  
  E2 - is the type of the elements the given mapper maps from the elements of the current Mappable.
  
  Parameter:
  
  mapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toArray in Schnittstelle ArrayMappable<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toByteArray in Schnittstelle ArrayMappable<E>
  
  Parameter:
  
  byteMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toCharArray in Schnittstelle ArrayMappable<E>
  
  Parameter:
  
  charMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toConcatenatedString in Schnittstelle StringMappable
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toDoubleArray in Schnittstelle ArrayMappable<E>
  
  Parameter:
  
  doubleMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toIntArray in Schnittstelle ArrayMappable<E>
  
  Parameter:
  
  intMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toLongArray in Schnittstelle ArrayMappable<E>
  
  Parameter:
  
  longMapper -
  
  Gibt zurück:
  
  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 <E2> IContainer<E2> toMultiples(Function<E,IContainer<E2>> 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.
  
  Angegeben von:
  
  toMultiples in Schnittstelle Mappable<E>
  
  Typparameter:
  
  E2 - is the type of the elements of the IContainers the given multipleMapper maps from the elements of the current Mappable.
  
  Parameter:
  
  multipleMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toNumbers in Schnittstelle Mappable<E>
  
  Typparameter:
  
  N - is the type of the Numbers the given numberMapper maps from the elements of the current Mappable.
  
  Parameter:
  
  numberMapper -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toReversedList in Schnittstelle IContainer<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toStringArray in Schnittstelle ArrayMappable<E>
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toStrings in Schnittstelle Mappable<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 time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  toStringWithSeparator in Schnittstelle StringMappable
  
  Parameter:
  
  separator -
  
  Gibt zurück:
  
  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.
  
  Angegeben von:
  
  toStringWithSeparator in Schnittstelle StringMappable
  
  Parameter:
  
  separator -
  
  Gibt zurück:
  
  a concatenation of the String representations of the elements of the current StringMappable with the given separator in between.
- toWithOneBasedIndex
  
  public final <E2> IContainer<E2> toWithOneBasedIndex(BiFunction<Integer,E,E2> mapper)
  
  The time complexity of this implementation is O(n) if the current AbstractContainer contains n elements.
  
  Angegeben von:
  
  toWithOneBasedIndex in Schnittstelle Mappable<E>
  
  Typparameter:
  
  E2 - 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.
  
  Parameter:
  
  mapper -
  
  Gibt zurück:
  
  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.
- createEmptyMutableList
  
  protected abstract <E2> IArrayList<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 AbstractContainer<E>

Konstruktorübersicht

Methodenübersicht

Von Klasse geerbte Methoden java.lang.Object

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.commoncontainerapi.CountRequestable

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

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

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

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

Von Schnittstelle geerbte Methoden java.lang.Iterable

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

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

Von Schnittstelle geerbte Methoden ch.nolix.coreapi.containerapi.commoncontainerapi.SingleSearchable

Konstruktordetails

AbstractContainer

Methodendetails

contains

containsAll

containsAll

containsAll

containsAny

containsAny

containsAnyOf

containsAnyOf

containsAsManyAs

containsEqualing

containsExactlyEqualingInSameOrder

containsExactlyInSameOrder

containsLessThan

containsMoreThan

containsNone

containsNone

containsNoneOf

containsOnce

containsOne

containsOne

containsOneEqualing

containsOnly

getAverage

getAverageOrZero

getCount

getCountOf

getOneBasedIndexOfFirst

getOneBasedIndexOfFirstEqualElement

getOneBasedIndexOfFirstOccurrenceOf

getMax

getMaxOrZero

getMedian

getMedianOrZero

getMin

getMinOrZero

getOptionalStoredFirst

getOptionalStoredFirst

getStandardDeviation

getStoredByMax

getStoredByMin

getStoredFirst

getStoredFirst

getStoredFirstOfType

getStoredInGroups

getStoredLast

getStoredOfType

getStoredOne

getStoredOne

getStoredOthers

getStoredSelected

getSum

getSumOfInts

getVariance

getViewOf

getViewFromOneBasedStartIndex

getViewToOneBasedEndIndex

getViewWithoutFirst

getViewWithoutFirst

getViewWithoutLast

getViewWithoutLast

isEmpty

to

toArray

toByteArray