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.