Class ArrayUtils

java.lang.Object
cool.scx.common.util.ArrayUtils
public final class ArrayUtils extends Object
ArrayUtils
Version:
0.0.1
Author:
scx567888

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayUtils()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean[]
    concat(boolean[]... arrays)
     
    static byte[]
    concat(byte[]... arrays)
     
    static char[]
    concat(char[]... arrays)
     
    static double[]
    concat(double[]... arrays)
     
    static float[]
    concat(float[]... arrays)
     
    static int[]
    concat(int[]... arrays)
     
    static long[]
    concat(long[]... arrays)
     
    static short[]
    concat(short[]... arrays)
     
    static <T> T[]
    concat(T[]... arrays)
    该方法可以正确处理数组协变.
    static int
    indexOf(boolean[] a, boolean b)
     
    static int
    indexOf(boolean[] a, boolean... b)
     
    static int
    indexOf(boolean[] a, int startPosition, int maxLength, boolean b)
     
    static int
    indexOf(boolean[] a, int startPosition, int maxLength, boolean... b)
     
    static int
    indexOf(byte[] a, byte b)
     
    static int
    indexOf(byte[] a, byte... b)
     
    static int
    indexOf(byte[] a, int startPosition, int maxLength, byte b)
     
    static int
    indexOf(byte[] a, int startPosition, int maxLength, byte... b)
     
    static int
    indexOf(char[] a, char b)
     
    static int
    indexOf(char[] a, char... b)
     
    static int
    indexOf(char[] a, int startPosition, int maxLength, char b)
     
    static int
    indexOf(char[] a, int startPosition, int maxLength, char... b)
     
    static int
    indexOf(double[] a, double b)
     
    static int
    indexOf(double[] a, double... b)
     
    static int
    indexOf(double[] a, int startPosition, int maxLength, double b)
     
    static int
    indexOf(double[] a, int startPosition, int maxLength, double... b)
     
    static int
    indexOf(float[] a, float b)
     
    static int
    indexOf(float[] a, float... b)
     
    static int
    indexOf(float[] a, int startPosition, int maxLength, float b)
     
    static int
    indexOf(float[] a, int startPosition, int maxLength, float... b)
     
    static int
    indexOf(int[] a, int b)
     
    static int
    indexOf(int[] a, int... b)
     
    static int
    indexOf(int[] a, int startPosition, int maxLength, int b)
     
    static int
    indexOf(int[] a, int startPosition, int maxLength, int... b)
     
    static int
    indexOf(long[] a, int startPosition, int maxLength, long b)
     
    static int
    indexOf(long[] a, int startPosition, int maxLength, long... b)
     
    static int
    indexOf(long[] a, long b)
     
    static int
    indexOf(long[] a, long... b)
     
    static int
    indexOf(short[] a, int startPosition, int maxLength, short b)
     
    static int
    indexOf(short[] a, int startPosition, int maxLength, short... b)
     
    static int
    indexOf(short[] a, short b)
     
    static int
    indexOf(short[] a, short... b)
     
    static int
    indexOf(Object[] a, int startPosition, int maxLength, Object b)
     
    static int
    indexOf(Object[] a, int startPosition, int maxLength, Object... b)
     
    static int
    indexOf(Object[] a, Object b)
     
    static int
    indexOf(Object[] a, Object... b)
     
    static void
    reverse(boolean... arr)
     
    static void
    reverse(byte... arr)
     
    static void
    reverse(char... arr)
     
    static void
    reverse(double... arr)
     
    static void
    reverse(float... arr)
     
    static void
    reverse(int... arr)
     
    static void
    reverse(long... arr)
     
    static void
    reverse(short... arr)
     
    static void
    reverse(Object... arr)
     
    static boolean[]
    safeSubArray(boolean[] array, int fromIndex, int toIndex)
     
    static byte[]
    safeSubArray(byte[] array, int fromIndex, int toIndex)
     
    static char[]
    safeSubArray(char[] array, int fromIndex, int toIndex)
     
    static double[]
    safeSubArray(double[] array, int fromIndex, int toIndex)
     
    static float[]
    safeSubArray(float[] array, int fromIndex, int toIndex)
     
    static int[]
    safeSubArray(int[] array, int fromIndex, int toIndex)
     
    static long[]
    safeSubArray(long[] array, int fromIndex, int toIndex)
     
    static short[]
    safeSubArray(short[] array, int fromIndex, int toIndex)
     
    static <T> T[]
    safeSubArray(T[] array, int fromIndex, int toIndex)
     
    static <T> List<T>
    safeSubList(List<T> list, int fromIndex, int toIndex)
     
    static void
    shuffle(boolean... arr)
     
    static void
    shuffle(byte... arr)
     
    static void
    shuffle(char... arr)
     
    static void
    shuffle(double... arr)
     
    static void
    shuffle(float... arr)
     
    static void
    shuffle(int... arr)
     
    static void
    shuffle(long... arr)
     
    static void
    shuffle(short... arr)
     
    static void
    shuffle(Object... arr)
     
    static boolean[][]
    splitArray(boolean[] arr, int sliceSize)
     
    static byte[][]
    splitArray(byte[] arr, int sliceSize)
     
    static char[][]
    splitArray(char[] arr, int sliceSize)
     
    static double[][]
    splitArray(double[] arr, int sliceSize)
     
    static float[][]
    splitArray(float[] arr, int sliceSize)
     
    static int[][]
    splitArray(int[] arr, int sliceSize)
     
    static long[][]
    splitArray(long[] arr, int sliceSize)
     
    static short[][]
    splitArray(short[] arr, int sliceSize)
     
    static <T> T[][]
    splitArray(T[] arr, int sliceSize)
    按照指定长度切割数组
    static boolean[][]
    splitArrayN(boolean[] arr, int n)
     
    static byte[][]
    splitArrayN(byte[] arr, int n)
     
    static char[][]
    splitArrayN(char[] arr, int n)
     
    static double[][]
    splitArrayN(double[] arr, int n)
     
    static float[][]
    splitArrayN(float[] arr, int n)
     
    static int[][]
    splitArrayN(int[] arr, int n)
     
    static long[][]
    splitArrayN(long[] arr, int n)
     
    static short[][]
    splitArrayN(short[] arr, int n)
     
    static <T> T[][]
    splitArrayN(T[] arr, int n)
    按照指定份数切割 数组, 注意和 splitArray(Object[], int) 进行区分
    static <T> List<List<T>>
    splitList(List<T> list, int size)
    按照指定长度切割 List, 注意和 splitListN(List,int)} 进行区分
    static <T> List<List<T>>
    splitListN(List<T> list, int n)
    按照指定份数切割 List, 注意和 splitList(List,int) 进行区分
    static boolean[]
    subArray(boolean[] array, int fromIndex, int toIndex)
     
    static byte[]
    subArray(byte[] array, int fromIndex, int toIndex)
     
    static char[]
    subArray(char[] array, int fromIndex, int toIndex)
     
    static double[]
    subArray(double[] array, int fromIndex, int toIndex)
     
    static float[]
    subArray(float[] array, int fromIndex, int toIndex)
     
    static int[]
    subArray(int[] array, int fromIndex, int toIndex)
     
    static long[]
    subArray(long[] array, int fromIndex, int toIndex)
     
    static short[]
    subArray(short[] array, int fromIndex, int toIndex)
     
    static <T> T[]
    subArray(T[] array, int fromIndex, int toIndex)
     
    static void
    subArrayCheck(int fromIndex, int toIndex, int size)
     
    static <T> List<T>
    subList(List<T> list, int fromIndex, int toIndex)
     
    static void
    swap(boolean[] arr, int i, int j)
     
    static void
    swap(byte[] arr, int i, int j)
     
    static void
    swap(char[] arr, int i, int j)
     
    static void
    swap(double[] arr, int i, int j)
     
    static void
    swap(float[] arr, int i, int j)
     
    static void
    swap(int[] arr, int i, int j)
     
    static void
    swap(long[] arr, int i, int j)
     
    static void
    swap(short[] arr, int i, int j)
     
    static void
    swap(Object[] arr, int i, int j)
     
    static long[]
    toLongArray(int... intArray)
     
    static Object[]
    toObjectArray(Object source)
     
    static boolean[]
    toPrimitive(Boolean... w)
     
    static byte[]
    toPrimitive(Byte... w)
     
    static char[]
    toPrimitive(Character... w)
     
    static double[]
    toPrimitive(Double... w)
     
    static float[]
    toPrimitive(Float... w)
     
    static int[]
    toPrimitive(Integer... w)
     
    static long[]
    toPrimitive(Long... w)
     
    static short[]
    toPrimitive(Short... w)
     
    static Boolean[]
    toWrapper(boolean... p)
     
    static Byte[]
    toWrapper(byte... p)
     
    static Character[]
    toWrapper(char... p)
     
    static Double[]
    toWrapper(double... p)
     
    static Float[]
    toWrapper(float... p)
     
    static Integer[]
    toWrapper(int... p)
     
    static Long[]
    toWrapper(long... p)
     
    static Short[]
    toWrapper(short... p)
     

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • ArrayUtils

      public ArrayUtils()

  • Method Details

    • toPrimitive

      public static byte[] toPrimitive(Byte... w)

    • toPrimitive

      public static short[] toPrimitive(Short... w)

    • toPrimitive

      public static int[] toPrimitive(Integer... w)

    • toPrimitive

      public static long[] toPrimitive(Long... w)

    • toPrimitive

      public static float[] toPrimitive(Float... w)

    • toPrimitive

      public static double[] toPrimitive(Double... w)

    • toPrimitive

      public static boolean[] toPrimitive(Boolean... w)

    • toPrimitive

      public static char[] toPrimitive(Character... w)

    • toWrapper

      public static Byte[] toWrapper(byte... p)

    • toWrapper

      public static Short[] toWrapper(short... p)

    • toWrapper

      public static Integer[] toWrapper(int... p)

    • toWrapper

      public static Long[] toWrapper(long... p)

    • toWrapper

      public static Float[] toWrapper(float... p)

    • toWrapper

      public static Double[] toWrapper(double... p)

    • toWrapper

      public static Boolean[] toWrapper(boolean... p)

    • toWrapper

      public static Character[] toWrapper(char... p)

    • swap

      public static void swap(byte[] arr, int i, int j)

    • swap

      public static void swap(short[] arr, int i, int j)

    • swap

      public static void swap(int[] arr, int i, int j)

    • swap

      public static void swap(long[] arr, int i, int j)

    • swap

      public static void swap(float[] arr, int i, int j)

    • swap

      public static void swap(double[] arr, int i, int j)

    • swap

      public static void swap(boolean[] arr, int i, int j)

    • swap

      public static void swap(char[] arr, int i, int j)

    • swap

      public static void swap(Object[] arr, int i, int j)

    • shuffle

      public static void shuffle(byte... arr)

    • shuffle

      public static void shuffle(short... arr)

    • shuffle

      public static void shuffle(int... arr)

    • shuffle

      public static void shuffle(long... arr)

    • shuffle

      public static void shuffle(float... arr)

    • shuffle

      public static void shuffle(double... arr)

    • shuffle

      public static void shuffle(boolean... arr)

    • shuffle

      public static void shuffle(char... arr)

    • shuffle

      public static void shuffle(Object... arr)

    • reverse

      public static void reverse(byte... arr)

    • reverse

      public static void reverse(short... arr)

    • reverse

      public static void reverse(int... arr)

    • reverse

      public static void reverse(long... arr)

    • reverse

      public static void reverse(float... arr)

    • reverse

      public static void reverse(double... arr)

    • reverse

      public static void reverse(boolean... arr)

    • reverse

      public static void reverse(char... arr)

    • reverse

      public static void reverse(Object... arr)

    • indexOf

      public static int indexOf(byte[] a, int startPosition, int maxLength, byte... b)

    • indexOf

      public static int indexOf(short[] a, int startPosition, int maxLength, short... b)

    • indexOf

      public static int indexOf(int[] a, int startPosition, int maxLength, int... b)

    • indexOf

      public static int indexOf(long[] a, int startPosition, int maxLength, long... b)

    • indexOf

      public static int indexOf(float[] a, int startPosition, int maxLength, float... b)

    • indexOf

      public static int indexOf(double[] a, int startPosition, int maxLength, double... b)

    • indexOf

      public static int indexOf(boolean[] a, int startPosition, int maxLength, boolean... b)

    • indexOf

      public static int indexOf(char[] a, int startPosition, int maxLength, char... b)

    • indexOf

      public static int indexOf(Object[] a, int startPosition, int maxLength, Object... b)

    • indexOf

      public static int indexOf(byte[] a, byte... b)

    • indexOf

      public static int indexOf(short[] a, short... b)

    • indexOf

      public static int indexOf(int[] a, int... b)

    • indexOf

      public static int indexOf(long[] a, long... b)

    • indexOf

      public static int indexOf(float[] a, float... b)

    • indexOf

      public static int indexOf(double[] a, double... b)

    • indexOf

      public static int indexOf(boolean[] a, boolean... b)

    • indexOf

      public static int indexOf(char[] a, char... b)

    • indexOf

      public static int indexOf(Object[] a, Object... b)

    • indexOf

      public static int indexOf(byte[] a, int startPosition, int maxLength, byte b)

    • indexOf

      public static int indexOf(short[] a, int startPosition, int maxLength, short b)

    • indexOf

      public static int indexOf(int[] a, int startPosition, int maxLength, int b)

    • indexOf

      public static int indexOf(long[] a, int startPosition, int maxLength, long b)

    • indexOf

      public static int indexOf(float[] a, int startPosition, int maxLength, float b)

    • indexOf

      public static int indexOf(double[] a, int startPosition, int maxLength, double b)

    • indexOf

      public static int indexOf(boolean[] a, int startPosition, int maxLength, boolean b)

    • indexOf

      public static int indexOf(char[] a, int startPosition, int maxLength, char b)

    • indexOf

      public static int indexOf(Object[] a, int startPosition, int maxLength, Object b)

    • indexOf

      public static int indexOf(byte[] a, byte b)

    • indexOf

      public static int indexOf(short[] a, short b)

    • indexOf

      public static int indexOf(int[] a, int b)

    • indexOf

      public static int indexOf(long[] a, long b)

    • indexOf

      public static int indexOf(float[] a, float b)

    • indexOf

      public static int indexOf(double[] a, double b)

    • indexOf

      public static int indexOf(boolean[] a, boolean b)

    • indexOf

      public static int indexOf(char[] a, char b)

    • indexOf

      public static int indexOf(Object[] a, Object b)

    • concat

      public static byte[] concat(byte[]... arrays)

    • concat

      public static short[] concat(short[]... arrays)

    • concat

      public static int[] concat(int[]... arrays)

    • concat

      public static long[] concat(long[]... arrays)

    • concat

      public static float[] concat(float[]... arrays)

    • concat

      public static double[] concat(double[]... arrays)

    • concat

      public static boolean[] concat(boolean[]... arrays)

    • concat

      public static char[] concat(char[]... arrays)

    • concat

      public static <T> T[] concat(T[]... arrays)
      该方法可以正确处理数组协变. 因为 arrays 参数在编译期会被推断为传入数组的最小公共父类 (即协变后的上界类型), 所以可以通过 arrays.getClass().componentType().componentType() 来获取推断后的组件类型.

    • splitArray

      public static byte[][] splitArray(byte[] arr, int sliceSize)

    • splitArray

      public static short[][] splitArray(short[] arr, int sliceSize)

    • splitArray

      public static int[][] splitArray(int[] arr, int sliceSize)

    • splitArray

      public static long[][] splitArray(long[] arr, int sliceSize)

    • splitArray

      public static float[][] splitArray(float[] arr, int sliceSize)

    • splitArray

      public static double[][] splitArray(double[] arr, int sliceSize)

    • splitArray

      public static boolean[][] splitArray(boolean[] arr, int sliceSize)

    • splitArray

      public static char[][] splitArray(char[] arr, int sliceSize)

    • splitArray

      public static <T> T[][] splitArray(T[] arr, int sliceSize)
      按照指定长度切割数组

    • splitArrayN

      public static byte[][] splitArrayN(byte[] arr, int n)

    • splitArrayN

      public static short[][] splitArrayN(short[] arr, int n)

    • splitArrayN

      public static int[][] splitArrayN(int[] arr, int n)

    • splitArrayN

      public static long[][] splitArrayN(long[] arr, int n)

    • splitArrayN

      public static float[][] splitArrayN(float[] arr, int n)

    • splitArrayN

      public static double[][] splitArrayN(double[] arr, int n)

    • splitArrayN

      public static boolean[][] splitArrayN(boolean[] arr, int n)

    • splitArrayN

      public static char[][] splitArrayN(char[] arr, int n)

    • splitArrayN

      public static <T> T[][] splitArrayN(T[] arr, int n)
      按照指定份数切割 数组, 注意和 splitArray(Object[], int) 进行区分

    • subArrayCheck

      public static void subArrayCheck(int fromIndex, int toIndex, int size)

    • subArray

      public static byte[] subArray(byte[] array, int fromIndex, int toIndex)

    • subArray

      public static short[] subArray(short[] array, int fromIndex, int toIndex)

    • subArray

      public static int[] subArray(int[] array, int fromIndex, int toIndex)

    • subArray

      public static long[] subArray(long[] array, int fromIndex, int toIndex)

    • subArray

      public static float[] subArray(float[] array, int fromIndex, int toIndex)

    • subArray

      public static double[] subArray(double[] array, int fromIndex, int toIndex)

    • subArray

      public static boolean[] subArray(boolean[] array, int fromIndex, int toIndex)

    • subArray

      public static char[] subArray(char[] array, int fromIndex, int toIndex)

    • subArray

      public static <T> T[] subArray(T[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static byte[] safeSubArray(byte[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static short[] safeSubArray(short[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static int[] safeSubArray(int[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static long[] safeSubArray(long[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static float[] safeSubArray(float[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static double[] safeSubArray(double[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static boolean[] safeSubArray(boolean[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static char[] safeSubArray(char[] array, int fromIndex, int toIndex)

    • safeSubArray

      public static <T> T[] safeSubArray(T[] array, int fromIndex, int toIndex)

    • splitList

      public static <T> List<List<T>> splitList(List<T> list, int size)
      按照指定长度切割 List, 注意和 splitListN(List,int)} 进行区分

    • splitListN

      public static <T> List<List<T>> splitListN(List<T> list, int n)
      按照指定份数切割 List, 注意和 splitList(List,int) 进行区分

    • subList

      public static <T> List<T> subList(List<T> list, int fromIndex, int toIndex)

    • safeSubList

      public static <T> List<T> safeSubList(List<T> list, int fromIndex, int toIndex)

    • toObjectArray

      public static Object[] toObjectArray(Object source)

    • toLongArray

      public static long[] toLongArray(int... intArray)