Package one.microstream.collections

Class 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 Detail

      • AbstractArrayStorage

        public AbstractArrayStorage()

    • Method Detail

      • 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)

      • 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,
                                  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)

      • 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,
                                                 char 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.