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:

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

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