Package one.microstream.collections

Class AbstractArrayStorage

java.lang.Object
one.microstream.collections.AbstractArrayStorage
public abstract class AbstractArrayStorage
extends Object
Abstract class with static delegate array logic methods to be used as pseudo-array-inherent methods.

The passed array and size are handled as pseudo implementation details and thus are never sanity-checked.

See ChainStorage and for example ChainStorageStrong as a comparable actual logic implementation without delegate-pseudo-character.

  • Constructor Details

  • Method Details

    • validateRange0toUpperBound

      public static final void validateRange0toUpperBound​(int upperBound, int offset, int length)

    • rangedIndexOF

      public static final <E> int rangedIndexOF​(E[] data, int size, int offset, int length, E element)

    • forwardIndexOf

      public static final <E> int forwardIndexOf​(E[] data, int lowOffset, int highBound, E element)

    • reverseIndexOf

      public static final <E> int reverseIndexOf​(E[] data, int highOffset, int lowEnd, E element)

    • rangedConditionalIndexOf

      public static final <E> int rangedConditionalIndexOf​(E[] data, int size, int offset, int length, Predicate<? super E> predicate)

    • forwardConditionalIndexOf

      public static final <E> int forwardConditionalIndexOf​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)

    • reverseConditionalIndexOf

      public static final <E> int reverseConditionalIndexOf​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)

    • rangedScan

      public static final <E> int rangedScan​(E[] data, int size, int offset, int length, Predicate<? super E> predicate)

    • forwardScan

      public static final <E> int forwardScan​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)

    • reverseScan

      public static final <E> int reverseScan​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)

    • rangedContains

      public static final <E> boolean rangedContains​(E[] data, int size, int offset, int length, Predicate<? super E> predicate)

    • forwardContains

      public static final <E> boolean forwardContains​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)

    • reverseContains

      public static final <E> boolean reverseContains​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)

    • rangedApplies

      public static final <E> boolean rangedApplies​(E[] data, int size, int offset, int length, Predicate<? super E> predicate)

    • forwardApplies

      public static final <E> boolean forwardApplies​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)

    • reverseApplies

      public static final <E> boolean reverseApplies​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)

    • rangedConditionalCount

      public static final <E> int rangedConditionalCount​(E[] data, int size, int offset, int length, Predicate<? super E> predicate)

    • forwardConditionalCount

      public static final <E> int forwardConditionalCount​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate)

    • reverseConditionalCount

      public static final <E> int reverseConditionalCount​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate)

    • rangedSearchElement

      public static final <E> E rangedSearchElement​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)

    • forwardSearchElement

      public static final <E> E forwardSearchElement​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, E notFoundMarker)

    • reverseSearchElement

      public static final <E> E reverseSearchElement​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, E notFoundMarker)

    • rangedQueryElement

      public static final <E> E rangedQueryElement​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)

    • forwardQueryElement

      public static final <E> E forwardQueryElement​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, E notFoundMarker)

    • reverseQueryElement

      public static final <E> E reverseQueryElement​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, E notFoundMarker)

    • iterate

      public static final <E> void iterate​(E[] data, int size, Consumer<? super E> iterator)

    • join

      public static final <E,​ A> void join​(E[] data, int size, BiConsumer<? super E,​? super A> joiner, A aggregate)
      Iterates over all elements of data which index is lower than the given size. Calls the joiner with each element and the aggregate.
      Type Parameters:
      E - type of data
      A - type of aggregate
      Parameters:
      data - which is iterated and given to the joiner
      size - of the given data array. The actual size of the data array may be greater, but not smaller.
      joiner - is the actual function to do the joining
      aggregate - where to join into

    • rangedIterate

      public static final <E> void rangedIterate​(E[] data, int size, int offset, int length, Consumer<? super E> procedure)

    • rangedJoin

      public static final <E,​ A> void rangedJoin​(E[] data, int size, int offset, int length, BiConsumer<? super E,​? super A> joiner, A aggregate)

    • forwardIterate

      public static final <E> void forwardIterate​(E[] data, int lowOffset, int highBound, Consumer<? super E> procedure)

    • reverseIterate

      public static final <E> void reverseIterate​(E[] data, int highOffset, int lowEnd, Consumer<? super E> procedure)

    • forwardJoin

      public static final <E,​ A> void forwardJoin​(E[] data, int lowOffset, int highBound, BiConsumer<? super E,​? super A> joiner, A aggregate)

    • reverseJoin

      public static final <E,​ A> void reverseJoin​(E[] data, int highOffset, int lowEnd, BiConsumer<? super E,​? super A> joiner, A aggregate)

    • rangedConditionalIterate

      public static final <E> void rangedConditionalIterate​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, Consumer<? super E> procedure)

    • forwardConditionalIterate

      public static final <E> void forwardConditionalIterate​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, Consumer<? super E> procedure)

    • reverseConditionalIterate

      public static final <E> void reverseConditionalIterate​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, Consumer<? super E> procedure)

    • rangedAggregate

      public static final <E,​ R> R rangedAggregate​(E[] data, int size, int offset, int length, Aggregator<? super E,​R> aggregator)

    • forwardAggregate

      public static final <E,​ R> R forwardAggregate​(E[] data, int lowOffset, int highBound, Aggregator<? super E,​R> aggregator)

    • reverseAggregate

      public static final <E,​ R> R reverseAggregate​(E[] data, int highOffset, int lowEnd, Aggregator<? super E,​R> aggregator)

    • rangedConditionalAggregate

      public static final <E,​ R> R rangedConditionalAggregate​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, Aggregator<? super E,​R> aggregator)

    • forwardConditionalAggregate

      public static final <E,​ R> R forwardConditionalAggregate​(E[] data, int lowOffset, int highBound, Predicate<? super E> predicate, Aggregator<? super E,​R> aggregator)

    • reverseConditionalAggregate

      public static final <E,​ R> R reverseConditionalAggregate​(E[] data, int highOffset, int lowEnd, Predicate<? super E> predicate, Aggregator<? super E,​R> aggregator)

    • addAll

      public static final <E> int addAll​(E[] data, int size, E[] src, int srcIndex, int srcLength, Predicate<? super E> predicate)

    • rangedContainsNull

      public static final <E> boolean rangedContainsNull​(E[] data, int size, int offset, int length)

    • forwardNullContained

      public static final <E> boolean forwardNullContained​(E[] data, int lowOffset, int highBound)

    • reverseNullContained

      public static final <E> boolean reverseNullContained​(E[] data, int highOffset, int lowEnd)

    • rangedContainsSame

      public static final <E> boolean rangedContainsSame​(E[] data, int size, int offset, int length, E element)

    • forwardContainsSame

      public static final <E> boolean forwardContainsSame​(E[] data, int lowOffset, int highBound, E element)

    • reverseContainsSame

      public static final <E> boolean reverseContainsSame​(E[] data, int lowOffset, int highBound, E element)

    • containsAll

      public static final <E> boolean containsAll​(E[] data, int size, XGettingCollection<? extends E> elements)

    • rangedContainsAll

      public static final <E> boolean rangedContainsAll​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> elements)

    • containsAll

      public static final <E> boolean containsAll​(E[] data, int size, XGettingCollection<? extends E> elements, Equalator<? super E> equalator)

    • rangedCount

      public static final <E> int rangedCount​(E[] data, int size, int offset, int length, E element)

    • forwardCount

      public static final <E> int forwardCount​(E[] data, int lowOffset, int highBound, E element)

    • reverseCount

      public static final <E> int reverseCount​(E[] data, int highOffset, int lowEnd, E element)

    • max

      public static final <E> E max​(E[] data, int size, Comparator<? super E> comparator)

    • min

      public static final <E> E min​(E[] data, int size, Comparator<? super E> comparator)

    • lastIndexOf

      public static final <E> int lastIndexOf​(E[] data, int size, Predicate<? super E> predicate)

    • maxIndex

      public static final <E> int maxIndex​(E[] data, int size, Comparator<? super E> comparator)

    • minIndex

      public static final <E> int minIndex​(E[] data, int size, Comparator<? super E> comparator)

    • rangedCopyTo

      public static final <E,​ C extends Consumer<? super E>> C rangedCopyTo​(E[] data, int size, int offset, int length, C target)

    • forwardCopyTo

      public static final <E,​ C extends Consumer<? super E>> C forwardCopyTo​(E[] data, int lowOffset, int highBound, C target)

    • reverseCopyTo

      public static final <E,​ C extends Consumer<? super E>> C reverseCopyTo​(E[] data, int highOffset, int lowEnd, C target)

    • rangedCopyTo

      public static final <E,​ C extends Consumer<? super E>> C rangedCopyTo​(E[] data, int size, int offset, int length, C target, Predicate<? super E> predicate)

    • forwardCopyTo

      public static final <E,​ C extends Consumer<? super E>> C forwardCopyTo​(E[] data, int lowOffset, int highBound, C target, Predicate<? super E> predicate)

    • reverseCopyTo

      public static final <E,​ C extends Consumer<? super E>> C reverseCopyTo​(E[] data, int highOffset, int lowEnd, C target, Predicate<? super E> predicate)

    • rangedCopyTo

      public static final <E,​ T> T[] rangedCopyTo​(E[] data, int size, int offset, int length, T[] target, int targetOffset)

    • copySelection

      public static final <E,​ C extends Consumer<? super E>> C copySelection​(E[] data, int size, long[] indices, C target)

    • binarySearch

      public static final <E> int binarySearch​(E[] data, int size, E element, Comparator<? super E> comparator)

    • rangedBinarySearch

      public static final <E> int rangedBinarySearch​(E[] data, int size, int offset, int length, E element, Comparator<? super E> comparator)

    • intersect

      public static final <E,​ C extends Consumer<? super E>> C intersect​(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • except

      public static final <E,​ C extends Consumer<? super E>> C except​(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • union

      public static final <E,​ C extends Consumer<? super E>> C union​(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • rangedIntersect

      public static final <E,​ C extends Consumer<? super E>> C rangedIntersect​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • rangedExcept

      public static final <E,​ C extends Consumer<? super E>> C rangedExcept​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • rangedUnion

      public static final <E,​ C extends Consumer<? super E>> C rangedUnion​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

    • distinct

      public static final <E,​ C extends Consumer<? super E>> C distinct​(E[] data, int size, C target)

    • rangedDistinct

      public static final <E,​ C extends Consumer<? super E>> C rangedDistinct​(E[] data, int size, int offset, int length, C target)

    • distinct

      public static final <E,​ C extends Consumer<? super E>> C distinct​(E[] data, int size, C target, Equalator<? super E> equalator)

    • rangedDistinct

      public static final <E,​ C extends Consumer<? super E>> C rangedDistinct​(E[] data, int size, int offset, int length, C target, Equalator<? super E> equalator)

    • iterate

      public static final <E> void iterate​(E[] data, int size, IndexedAcceptor<? super E> procedure)

    • rangedIterate

      public static final <E> void rangedIterate​(E[] data, int size, int offset, int length, IndexedAcceptor<? super E> procedure)

    • rangedRemove

      public static final <E> int rangedRemove​(E[] data, int size, int offset, int length, E element)

    • rangedRemove

      public static final <E> int rangedRemove​(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator)

    • rangedRemoveNull

      public static final <E> int rangedRemoveNull​(E[] data, int size, int offset, int length)

    • reduce

      public static final <E> int reduce​(E[] data, int size, Predicate<? super E> predicate, E removeMarker)

    • rangedReduce

      public static final <E> int rangedReduce​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E removeMarker)

    • retainAll

      public static final <E> int retainAll​(E[] data, int size, XGettingCollection<E> elements, E removeMarker)

    • rangedRetainAll

      public static final <E> int rangedRetainAll​(E[] data, int size, int offset, int length, XGettingCollection<E> elements, E removeMarker)

    • retainAll

      public static final <E> int retainAll​(E[] data, int size, XGettingCollection<E> samples, Equalator<? super E> equalator, E removeMarker)

    • rangedRetainAll

      public static final <E> int rangedRetainAll​(E[] data, int size, int offset, int length, XGettingCollection<E> samples, Equalator<? super E> equalator, E removeMarker)

    • process

      public static final <E> int process​(E[] data, int size, Consumer<? super E> procedure, E removeMarker)

    • rangedProcess

      public static final <E> int rangedProcess​(E[] data, int size, int offset, int length, Consumer<? super E> procedure, E removeMarker)

    • moveTo

      public static final <E> int moveTo​(E[] data, int size, Consumer<? super E> target, Predicate<? super E> predicate, E removeMarker)

    • rangedMoveTo

      public static final <E> int rangedMoveTo​(E[] data, int size, int offset, int length, Consumer<? super E> target, Predicate<? super E> predicate, E removeMarker)

    • moveSelection

      public static final <E> int moveSelection​(E[] data, int size, long[] indices, Consumer<? super E> target, E removeMarker)

    • rangedRemoveAll

      public static final <E> int rangedRemoveAll​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> elements)

    • rangedRemoveAll

      public static final <E> int rangedRemoveAll​(E[] data, int size, int offset, int length, XGettingCollection<? extends E> samples, Equalator<? super E> equalator, E removeMarker)

    • removeDuplicates

      public static final <E> int removeDuplicates​(E[] data, int size, Equalator<? super E> equalator, E removeMarker)

    • rangedRemoveDuplicates

      public static final <E> int rangedRemoveDuplicates​(E[] data, int size, int offset, int length, Equalator<? super E> equalator, E removeMarker)

    • removeDuplicates

      public static final <E> int removeDuplicates​(E[] data, int size, E removeMarker)

    • rangedRemoveDuplicates

      public static final <E> int rangedRemoveDuplicates​(E[] data, int size, int offset, int length, E removeMarker)

    • removeSelection

      public static final <E> int removeSelection​(E[] data, int size, long[] indices, E removeMarker)

    • removeRange

      public static final <E> int removeRange​(E[] data, int size, int offset, int length)

    • retainRange

      public static final <E> int retainRange​(E[] data, int size, int offset, int length)

    • retrieve

      public static final <E> E retrieve​(E[] data, int size, E element, E notFoundMarker)

    • retrieve

      public static final <E> E retrieve​(E[] data, int size, E sample, Equalator<? super E> equalator, E notFoundMarker)

    • retrieve

      public static final <E> E retrieve​(E[] data, int size, Predicate<? super E> predicate, E notFoundMarker)

    • removeOne

      public static final <E> boolean removeOne​(E[] data, int size, E element)

    • removeOne

      public static final <E> boolean removeOne​(E[] data, int size, E sample, Equalator<? super E> equalator)

    • rangedRetrieve

      public static final <E> E rangedRetrieve​(E[] data, int size, int offset, int length, E element, E notFoundMarker)

    • rangedRetrieve

      public static final <E> E rangedRetrieve​(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator, E notFoundMarker)

    • rangedRetrieve

      public static final <E> E rangedRetrieve​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E notFoundMarker)

    • rangedRemoveOne

      public static final <E> boolean rangedRemoveOne​(E[] data, int size, int offset, int length, E element)

    • rangedRemoveOne

      public static final <E> boolean rangedRemoveOne​(E[] data, int size, int offset, int length, E sample, Equalator<? super E> equalator)

    • replaceOne

      public static final <E> boolean replaceOne​(E[] data, int size, E oldElement, E newElement)

    • rangedReplaceOne

      public static final <E> int rangedReplaceOne​(E[] data, int size, int offset, int length, E oldElement, E newElement)

    • replaceOne

      public static final <E> boolean replaceOne​(E[] data, int size, E sample, E newElement, Equalator<? super E> equalator)

    • rangedReplaceOne

      public static final <E> int rangedReplaceOne​(E[] data, int size, int offset, int length, E sample, E newElement, Equalator<? super E> equalator)

    • substituteOne

      public static final <E> boolean substituteOne​(E[] data, int size, Predicate<? super E> predicate, E replacement)

    • rangedReplaceOne

      public static final <E> int rangedReplaceOne​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E newElement)

    • replace

      public static final <E> int replace​(E[] data, int size, E oldElement, E newElement)

    • rangedReplace

      public static final <E> int rangedReplace​(E[] data, int size, int offset, int length, E oldElement, E newElement)

    • replace

      public static final <E> int replace​(E[] data, int size, E sample, E newElement, Equalator<? super E> equalator)

    • rangedReplace

      public static final <E> long rangedReplace​(E[] data, int size, int offset, int length, E sample, E newElement, Equalator<? super E> equalator)

    • substitute

      public static final <E> long substitute​(E[] data, int size, Predicate<? super E> predicate, E newElement)

    • rangedReplace

      public static final <E> int rangedReplace​(E[] data, int size, int offset, int length, Predicate<? super E> predicate, E newElement)

    • replaceAll

      public static final <E,​ U extends E> int replaceAll​(E[] data, int size, XGettingCollection<U> oldElements, E newElement, E marker)

    • rangedReplaceAll

      public static final <E> int rangedReplaceAll​(E[] data, int size, int offset, int length, XGettingCollection<E> oldElements, E newElement)

    • replaceAll

      public static final <E,​ U extends E> int replaceAll​(E[] data, int size, XGettingCollection<U> samples, E newElement, Equalator<? super E> equalator, E marker)

    • rangedReplaceAll

      public static final <E> int rangedReplaceAll​(E[] data, int size, int offset, int length, XGettingCollection<E> samples, E newElement, Equalator<? super E> equalator)

    • replaceAll

      public static final <E> int replaceAll​(E[] data, int size, XMap<E,​E> replacementMapping)

    • substitute

      public static final <E> long substitute​(E[] data, int size, Function<? super E,​? extends E> mapper)

    • substitute

      public static final <E> long substitute​(E[] data, int size, Predicate<? super E> predicate, Function<E,​E> mapper)

    • rangedReplaceAll

      public static final <E> int rangedReplaceAll​(E[] data, int size, int offset, int length, XMap<E,​E> replacementMapping)

    • rangedModify

      public static final <E> int rangedModify​(E[] data, int size, int offset, int length, Function<E,​E> mapper)

    • swap

      public static final <E> void swap​(E[] data, int size, int indexA, int indexB) throws IndexOutOfBoundsException, ArrayIndexOutOfBoundsException
      Throws:
      IndexOutOfBoundsException
      ArrayIndexOutOfBoundsException

    • swap

      public static final <E> void swap​(E[] data, int size, int indexA, int indexB, int length)

    • reverse

      public static final <E> void reverse​(E[] data, int size)

    • rangedReverse

      public static final <E> void rangedReverse​(E[] data, int size, int offset, int length)

    • set

      public static final <E> void set​(E[] data, int size, int offset, E[] elements)

    • set

      public static final <E> void set​(E[] data, int size, int offset, XGettingSequence<? extends E> elements, long elementsOffset, long elementsLength)

    • set

      public static final <E> void set​(E[] data, int size, int offset, E[] src, int srcIndex, int srcLength)

    • fill

      public static final <E> void fill​(E[] data, int size, int offset, int length, E element)

    • toString

      public static final String toString​(Object[] data, int size)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc, char separator)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc, String separator)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc, BiConsumer<VarString,​? super E> appender)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc, BiConsumer<VarString,​? super E> appender, char separator)

    • appendTo

      public static final <E> VarString appendTo​(E[] data, int size, VarString vc, BiConsumer<VarString,​? super E> appender, String separator)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc, char separator)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc, String separator)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,​? super E> appender)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,​? super E> appender, char separator)

    • rangedAppendTo

      public static final <E> VarString rangedAppendTo​(E[] data, int size, int offset, int length, VarString vc, BiConsumer<VarString,​? super E> appender, String separator)

    • isSorted

      public static final <E> boolean isSorted​(E[] data, int size, Comparator<? super E> comparator)

    • rangedIsSorted

      public static final <E> boolean rangedIsSorted​(E[] data, int size, int offset, int length, Comparator<? super E> comparator)

    • sortInsertion

      public static final <E> void sortInsertion​(E[] data, int size, Comparator<? super E> comparator)

    • rangedSortInsertion

      public static final <E> void rangedSortInsertion​(E[] data, int size, int offset, int length, Comparator<? super E> comparator)

    • rangedSortQuick

      public static final <E> void rangedSortQuick​(E[] data, int size, int offset, int length, Comparator<? super E> comparator)

    • rangedSortMerge

      public static final <E> void rangedSortMerge​(E[] data, int size, int offset, int length, Comparator<? super E> comparator)

    • rangedSort

      public static final <E> void rangedSort​(E[] data, int size, int offset, int length, Comparator<? super E> comparator)

    • shuffle

      public static final <E> void shuffle​(E[] data, int size)

    • rangedShuffle

      public static final <E> void rangedShuffle​(E[] data, int size, int offset, int length)

    • toReversed

      public static final <T> T[] toReversed​(T[] array, int size)

    • hasDistinctValues

      public static final <E> boolean hasDistinctValues​(E[] data, int size)

    • rangedHasUniqueValues

      public static final <E> boolean rangedHasUniqueValues​(E[] data, int size, int offset, int length)

    • hasDistinctValues

      public static final <E> boolean hasDistinctValues​(E[] data, int size, Equalator<? super E> equalator)

    • hasDistinctValues

      public static final <E> boolean hasDistinctValues​(E[] data, int size, HashEqualator<? super E> equalator)

    • rangedHasUniqueValues

      public static final <E> boolean rangedHasUniqueValues​(E[] data, int size, int offset, int length, Equalator<? super E> equalator)

    • equalsContent

      public static final <E> boolean equalsContent​(E[] data, int size, Collection<? extends E> collection, Equalator<? super E> equalator)

    • equalsContent

      public static final <E> boolean equalsContent​(E[] data, int size, XGettingCollection<? extends E> samples, Equalator<? super E> equalator)

    • rangedEqualsContent

      public static final <E> boolean rangedEqualsContent​(E[] data, int size, int offset, int length, List<? extends E> list, Equalator<? super E> equalator)

    • rangedEqualsContent

      public static final <E> boolean rangedEqualsContent​(E[] data, int size, int offset, int length, XGettingSequence<? extends E> sequence, Equalator<? super E> equalator)

    • rangedToArray

      public static final Object[] rangedToArray​(Object[] data, int size, int offset, int length)

    • rangedToArray

      public static final <T> T[] rangedToArray​(Object[] data, int size, int offset, int length, T[] a)

    • rangedToArray

      public static <E> E[] rangedToArray​(E[] data, int size, int offset, int length, Class<E> type)

    • checkIterationDirection

      @Deprecated public static final int checkIterationDirection​(int size, int offset, int length)
      Deprecated.