Package com.complexible.common.primitives

# Class ArrayUtil

java.lang.Object
com.complexible.common.primitives.ArrayUtil

public final class ArrayUtil extends Object

Since:
  4.0
Version:
  0.3
Author:
  Pedro Oliveira

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final byte[]`
  `EMPTY_BYTE_ARRAY`
  `static final int`
  `SIZE_INCREASE`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static int[]`
  `copyOf(int[] theArray)`
  `static int[]`
  `copyOf(int[] theArray, int theLength)`
  `static long[]`
  `copyOf(long[] theArray)`
  `static long[]`
  `copyOf(long[] theArray, int theLength)`
  `static <T> T[]`
  `copyOf(T[] theArray)`
  `static <T> T[]`
  `copyOf(T[] theArray, int theLength)`
  `static <T> int`
  `deferredEqualityBinarySearch(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)`
  Implementation of a binary search which uses the deferred equality approach.
  `static <T> int`
  `deferredEqualityBinarySearchAfter(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)`
  `Deferred equality binary search` with the position returned `normalized after`.
  `static <T> int`
  `deferredEqualityBinarySearchBefore(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)`
  `static <T> int`
  `deferredEqualityBinarySearchBefore(T[] theData, T theElement, Comparator<T> theComparator)`
  `static <T> void`
  `delete(long[] data, int size, int pos)`
  `static <T> void`
  `delete(T[] data, int size, int pos)`
  `static <T> T[]`
  `ensureSize(T[] theArray, int newSize)`
  `static <T> T[]`
  `increaseSize(T[] theArray)`
  `static long[]`
  `insert(long[] data, int size, int pos, long theElement)`
  `static <T> T[]`
  `insert(T[] data, int size, int pos, T theElement)`
  `static boolean`
  `isSorted(long[] theArray)`
  `static <T> com.google.common.collect.PeekingIterator<T>`
  `iterator(T[] theArray)`
  `Iterator` for the given array
  `static <T> com.google.common.collect.PeekingIterator<T>`
  `iterator(T[] theArray, int theStart, int theEnd)`
  `Iterator` for the given array
  `static byte[]`
  `merge(byte[] theFirst, byte[] theSecond)`
  `static long[]`
  `merge(long[] theFirst, long[] theSecond)`
  Merges two sorted arrays and removes duplicates
  `static <T> int`
  `merge(T[] theFirstArray, int theFirstSize, T[] theSecondArray, int theSecondSize, T[] theResult, Comparator<T> theComparator)`
  Merges two sorted arrays without duplicates into a new array.
  `static <T> T[]`
  `newArray(int theLength)`
  `static int`
  `normalizeAfter(int thePosition)`
  `static int`
  `normalizeBefore(int thePosition)`
  `static <T> T`
  `onlyMatch(T[] array, Predicate<T> predicate)`
  `static boolean`
  `rangeEquals(byte[] bytes1, int offset1, byte[] bytes2, int offset2, int length)`
  `static <T> int`
  `removeDuplicates(T[] theSortedArray, int theSize)`
  Removes duplicates from a sorted array by moving the unique elements to the front of the array and returns the number of unique elements.
  `static <T> int`
  `removeDuplicates(T[] theSortedArray, int theSize, Comparator<T> theComparator)`
  `static <T> int`
  `search(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)`
  `static <T> int`
  `search(T[] theArray, T theObject, Comparator<T> theComparator)`
  `static <T> int`
  `searchAfter(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)`
  `static <T> int`
  `searchAfter(T[] theArray, T theObject, Comparator<T> theComparator)`
  `static <T> int`
  `searchBefore(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)`
  `static <T> int`
  `searchBefore(T[] theArray, T theObject, Comparator<T> theComparator)`
  `static int`
  `sequentialSearch(long[] theArray, int theSize, long theElement)`
  `static <T> int`
  `sequentialSearch(T[] theArray, int theSize, T theElement)`
  `static <T> int`
  `sequentialSearch(T[] theArray, T theElement)`
  `static <T> void`
  `sort(T[] theArray, int theStart, int theEnd, Comparator<? super T> theComparator)`
  `static <T> void`
  `sort(T[] theArray, Comparator<T> theComparator)`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### SIZE_INCREASE

    public static final int SIZE_INCREASE
    See Also:
      - Constant Field Values

  - ### EMPTY_BYTE_ARRAY

    public static final byte[] EMPTY_BYTE_ARRAY

- ## Method Details

  - ### iterator

    public static <T> com.google.common.collect.PeekingIterator<T> iterator(T[] theArray, int theStart, int theEnd)
    `Iterator` for the given array
    Type Parameters:
      `T` -
    Parameters:
      `theArray` - The Array to iterate over
      `theStart` - The starting point (inclusive)
      `theEnd` - The ending point (exclusive)
    Returns:

  - ### iterator

    public static <T> com.google.common.collect.PeekingIterator<T> iterator(T[] theArray)
    `Iterator` for the given array
    Type Parameters:
      `T` -
    Parameters:
      `theArray` - The Array to iterate over
    Returns:

  - ### search

    public static <T> int search(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)

  - ### search

    public static <T> int search(T[] theArray, T theObject, Comparator<T> theComparator)

  - ### searchAfter

    public static <T> int searchAfter(T[] theArray, T theObject, Comparator<T> theComparator)
    Type Parameters:
      `T` -
    Parameters:
      `theArray` -
      `theObject` -
      `theComparator` -
    Returns:
      If found, the position of the element. Otherwise, the position of the next bigger element.

  - ### searchAfter

    public static <T> int searchAfter(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)

  - ### deferredEqualityBinarySearch

    public static <T> int deferredEqualityBinarySearch(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)
    Implementation of a binary search which uses the deferred equality approach. This trades some efficiency -- more iterations will be performed -- for the guarantee that the minimum matching element is always selected. This is the preferred search if you have duplicate elements in the array, or the Comparator is lax in that it can return 0 for multiple elements that are not .equals.
    Type Parameters:
      `T` - the type of elements in the array
    Parameters:
      `theData` - the array to search
      `theElement` - the element to search for
      `theStart` - the start position, inclusive
      `theEnd` - the end position, exclusive
      `theComparator` - the comparator
    Returns:
      the position of the element, not found returned as a negative position same as `Arrays.binarySearch(long[], long)`
    See Also:
      - description

  - ### deferredEqualityBinarySearchAfter

    public static <T> int deferredEqualityBinarySearchAfter(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)
    `Deferred equality binary search` with the position returned `normalized after`.
    Type Parameters:
      `T` - the type of elements in the array
    Parameters:
      `theData` - the array to search
      `theElement` - the element to search for
      `theStart` - the start index of the search
      `theEnd` - the end index of the search
      `theComparator` - the comparator
    Returns:
      the position of the element in the array. This will always be a positive value, the index of the actual element in the list, or it will be the location the element whould be in the list if it was present. That is, when the element is not present you can use the return value as the location to insert the element such that the ordering is maintained

  - ### deferredEqualityBinarySearchBefore

    public static <T> int deferredEqualityBinarySearchBefore(T[] theData, T theElement, Comparator<T> theComparator)

  - ### deferredEqualityBinarySearchBefore

    public static <T> int deferredEqualityBinarySearchBefore(T[] theData, T theElement, int theStart, int theEnd, Comparator<T> theComparator)

  - ### searchBefore

    public static <T> int searchBefore(T[] theArray, T theObject, Comparator<T> theComparator)
    Type Parameters:
      `T` -
    Parameters:
      `theArray` -
      `theObject` -
      `theComparator` -
    Returns:
      If found, the position of the element. Otherwise, the position of the next smaller element.

  - ### searchBefore

    public static <T> int searchBefore(T[] theArray, T theObject, int theStart, int theEnd, Comparator<T> theComparator)

  - ### copyOf

    public static <T> T[] copyOf(T[] theArray)

  - ### normalizeAfter

    public static int normalizeAfter(int thePosition)

  - ### normalizeBefore

    public static int normalizeBefore(int thePosition)

  - ### increaseSize

    public static <T> T[] increaseSize(T[] theArray)

  - ### ensureSize

    public static <T> T[] ensureSize(T[] theArray, int newSize)

  - ### copyOf

    public static <T> T[] copyOf(T[] theArray, int theLength)

  - ### copyOf

    public static long[] copyOf(long[] theArray)

  - ### copyOf

    public static long[] copyOf(long[] theArray, int theLength)

  - ### copyOf

    public static int[] copyOf(int[] theArray)

  - ### copyOf

    public static int[] copyOf(int[] theArray, int theLength)

  - ### newArray

    public static <T> T[] newArray(int theLength)

  - ### sequentialSearch

    public static int sequentialSearch(long[] theArray, int theSize, long theElement)

  - ### sequentialSearch

    public static <T> int sequentialSearch(T[] theArray, T theElement)

  - ### sequentialSearch

    public static <T> int sequentialSearch(T[] theArray, int theSize, T theElement)

  - ### sort

    public static <T> void sort(T[] theArray, int theStart, int theEnd, Comparator<? super T> theComparator)

  - ### isSorted

    public static boolean isSorted(long[] theArray)

  - ### sort

    public static <T> void sort(T[] theArray, Comparator<T> theComparator)

  - ### merge

    public static byte[] merge(byte[] theFirst, byte[] theSecond)

  - ### merge

    public static long[] merge(long[] theFirst, long[] theSecond)
    Merges two sorted arrays and removes duplicates
    Parameters:
      `theFirst` - the first array
      `theSecond` - the second array
    Returns:
      the resulting array

  - ### removeDuplicates

    public static <T> int removeDuplicates(T[] theSortedArray, int theSize)
    Removes duplicates from a sorted array by moving the unique elements to the front of the array and returns the number of unique elements.
    Parameters:
      `theSortedArray` - a sorted array that possibly contains duplicates
      `theSize` - the size of the array that contains valid elements, elements beyond this index are completely ignored
    Returns:
      the number of unique elements in the array

  - ### removeDuplicates

    public static <T> int removeDuplicates(T[] theSortedArray, int theSize, Comparator<T> theComparator)

  - ### merge

    public static <T> int merge(T[] theFirstArray, int theFirstSize, T[] theSecondArray, int theSecondSize, T[] theResult, Comparator<T> theComparator)
    Merges two sorted arrays without duplicates into a new array. Both arrays should already be sorted with the given comparator. Neither array should contain duplicates within itself but there may be common elements that exist in both arrays. The resulting array will be sorted and won't contain duplicates either.
    Type Parameters:
      `T` -
    Parameters:
      `theFirstArray` - the first array to be merged
      `theFirstSize` - the size of valid elements in the first array
      `theSecondArray` - the second array to be merged
      `theSecondSize` - the size of valid elements in the second array
      `theResult` - the result array where elements will be copied
      `theComparator` - the comparator for the element
    Returns:
      the size of valid elements in the resulting array, typically equal to the sum of first and second size might be less if the arrays have some elements in common

  - ### delete

    public static <T> void delete(T[] data, int size, int pos)

  - ### delete

    public static <T> void delete(long[] data, int size, int pos)

  - ### insert

    public static <T> T[] insert(T[] data, int size, int pos, T theElement)

  - ### insert

    public static long[] insert(long[] data, int size, int pos, long theElement)

  - ### rangeEquals

    public static boolean rangeEquals(byte[] bytes1, int offset1, byte[] bytes2, int offset2, int length)

  - ### onlyMatch

    public static <T> T onlyMatch(T[] array, Predicate<T> predicate)