Class ArrayUtils

java.lang.Object
cool.scx.common.util.ArrayUtils
public final class ArrayUtils extends Object
提供一些操作 Array 的方法
Version:
0.0.1
Author:
scx567888

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayUtils()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean[]
    concat(boolean[] first, boolean... second)
     
    static byte[]
    concat(byte[] first, byte... second)
     
    static char[]
    concat(char[] first, char... second)
     
    static double[]
    concat(double[] first, double... second)
     
    static float[]
    concat(float[] first, float... second)
     
    static int[]
    concat(int[] first, int... second)
     
    static long[]
    concat(long[] first, long... second)
     
    static short[]
    concat(short[] first, short... second)
     
    static <T> T[]
    concat(T[] first, T... second)
     
    static int
    indexOf(boolean[] a, boolean a1)
     
    static int
    indexOf(boolean[] a, boolean... a1)
     
    static int
    indexOf(boolean[] a, int startPosition, int maxLength, boolean a1)
     
    static int
    indexOf(boolean[] a, int startPosition, int maxLength, boolean... a1)
     
    static int
    indexOf(byte[] a, byte a1)
     
    static int
    indexOf(byte[] a, byte... a1)
     
    static int
    indexOf(byte[] a, int startPosition, int maxLength, byte a1)
     
    static int
    indexOf(byte[] a, int startPosition, int maxLength, byte... a1)
     
    static int
    indexOf(char[] a, char a1)
     
    static int
    indexOf(char[] a, char... a1)
     
    static int
    indexOf(char[] a, int startPosition, int maxLength, char a1)
     
    static int
    indexOf(char[] a, int startPosition, int maxLength, char... a1)
     
    static int
    indexOf(double[] a, double a1)
     
    static int
    indexOf(double[] a, double... a1)
     
    static int
    indexOf(double[] a, int startPosition, int maxLength, double a1)
     
    static int
    indexOf(double[] a, int startPosition, int maxLength, double... a1)
     
    static int
    indexOf(float[] a, float a1)
     
    static int
    indexOf(float[] a, float... a1)
     
    static int
    indexOf(float[] a, int startPosition, int maxLength, float a1)
     
    static int
    indexOf(float[] a, int startPosition, int maxLength, float... a1)
     
    static int
    indexOf(int[] a, int a1)
     
    static int
    indexOf(int[] a, int... a1)
     
    static int
    indexOf(int[] a, int startPosition, int maxLength, int a1)
     
    static int
    indexOf(int[] a, int startPosition, int maxLength, int... a1)
     
    static int
    indexOf(long[] a, int startPosition, int maxLength, long a1)
     
    static int
    indexOf(long[] a, int startPosition, int maxLength, long... a1)
     
    static int
    indexOf(long[] a, long a1)
     
    static int
    indexOf(long[] a, long... a1)
     
    static int
    indexOf(short[] a, int startPosition, int maxLength, short a1)
     
    static int
    indexOf(short[] a, int startPosition, int maxLength, short... a1)
     
    static int
    indexOf(short[] a, short a1)
     
    static int
    indexOf(short[] a, short... a1)
     
    static int
    indexOf(Object[] a, int startPosition, int maxLength, Object a1)
     
    static int
    indexOf(Object[] a, int startPosition, int maxLength, Object... a1)
     
    static int
    indexOf(Object[] a, Object a1)
     
    static int
    indexOf(Object[] a, Object... a1)
     
    static int
    numOfSlices(int length, int n)
    计算 长度可以被分割为几个子长度 (向上取整)
    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)
    按照指定份数切割 List, 注意和 splitList(List,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)
     
    static boolean[]
    tryConcat(boolean[] first, boolean... second)
     
    static byte[]
    tryConcat(byte[] first, byte... second)
     
    static char[]
    tryConcat(char[] first, char... second)
     
    static double[]
    tryConcat(double[] first, double... second)
     
    static float[]
    tryConcat(float[] first, float... second)
     
    static int[]
    tryConcat(int[] first, int... second)
     
    static long[]
    tryConcat(long[] first, long... second)
     
    static short[]
    tryConcat(short[] first, short... second)
     
    static <T> T[]
    tryConcat(T[] first, T... second)
     

    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... a1)

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • indexOf

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

    • concat

      public static byte[] concat(byte[] first, byte... second)

    • concat

      public static short[] concat(short[] first, short... second)

    • concat

      public static int[] concat(int[] first, int... second)

    • concat

      public static long[] concat(long[] first, long... second)

    • concat

      public static float[] concat(float[] first, float... second)

    • concat

      public static double[] concat(double[] first, double... second)

    • concat

      public static boolean[] concat(boolean[] first, boolean... second)

    • concat

      public static char[] concat(char[] first, char... second)

    • concat

      @SafeVarargs public static <T> T[] concat(T[] first, T... second)

    • tryConcat

      public static byte[] tryConcat(byte[] first, byte... second)

    • tryConcat

      public static short[] tryConcat(short[] first, short... second)

    • tryConcat

      public static int[] tryConcat(int[] first, int... second)

    • tryConcat

      public static long[] tryConcat(long[] first, long... second)

    • tryConcat

      public static float[] tryConcat(float[] first, float... second)

    • tryConcat

      public static double[] tryConcat(double[] first, double... second)

    • tryConcat

      public static boolean[] tryConcat(boolean[] first, boolean... second)

    • tryConcat

      public static char[] tryConcat(char[] first, char... second)

    • tryConcat

      @SafeVarargs public static <T> T[] tryConcat(T[] first, T... second)

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

    • splitList

      public static <T> List<List<T>> splitList(List<T> list, int size)
      按照指定长度切割 List, 注意和 splitListN(List,int)} 进行区分
      Type Parameters:
      T - T
      Parameters:
      list - list
      size - 每份的长度
      Returns:
      切割后的 list

    • 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)
      按照指定份数切割 List, 注意和 splitList(List,int) 进行区分
      Type Parameters:
      T - T
      Parameters:
      arr - arr
      n - 份数
      Returns:
      切割后的 list

    • splitListN

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

    • toObjectArray

      public static Object[] toObjectArray(Object source)

    • toLongArray

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

    • numOfSlices

      public static int numOfSlices(int length, int n)
      计算 长度可以被分割为几个子长度 (向上取整)
      Parameters:
      length - l
      n - n
      Returns:
      c

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

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