Package org.miaixz.bus.core.center.array

Class PrimitiveArray

java.lang.Object
org.miaixz.bus.core.center.array.ArrayValidator
org.miaixz.bus.core.center.array.PrimitiveArray
Direct Known Subclasses:
ArrayKit
public class PrimitiveArray extends ArrayValidator
原始类型数组工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    PrimitiveArray()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean[]
    addAll(boolean[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static byte[]
    addAll(byte[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static char[]
    addAll(char[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static double[]
    addAll(double[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static float[]
    addAll(float[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static int[]
    addAll(int[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static long[]
    addAll(long[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static short[]
    addAll(short[]... arrays)
    将多个数组合并在一起 忽略null的数组
    static boolean
    contains(boolean[] array, boolean value)
    数组中是否包含元素
    static boolean
    contains(byte[] array, byte value)
    数组中是否包含元素
    static boolean
    contains(char[] array, char value)
    数组中是否包含元素
    static boolean
    contains(double[] array, double value)
    数组中是否包含元素
    static boolean
    contains(float[] array, float value)
    数组中是否包含元素
    static boolean
    contains(int[] array, int value)
    数组中是否包含元素
    static boolean
    contains(long[] array, long value)
    数组中是否包含元素
    static boolean
    contains(short[] array, short value)
    数组中是否包含元素
    static int
    indexOf(boolean[] array, boolean value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(byte[] array, byte value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(char[] array, char value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(double[] array, double value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(float[] array, float value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(int[] array, int value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(long[] array, long value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOf(short[] array, short value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(boolean[] array, boolean value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(byte[] array, byte value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(char[] array, char value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(double[] array, double value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(float[] array, float value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(int[] array, int value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(long[] array, long value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    lastIndexOf(short[] array, short value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static byte
    max(byte... numberArray)
    取最大值
    static char
    max(char... numberArray)
    取最大值
    static double
    max(double... numberArray)
    取最大值
    static float
    max(float... numberArray)
    取最大值
    static int
    max(int... numberArray)
    取最大值
    static long
    max(long... numberArray)
    取最大值
    static short
    max(short... numberArray)
    取最大值
    static byte
    min(byte... numberArray)
    取最小值
    static char
    min(char... numberArray)
    取最小值
    static double
    min(double... numberArray)
    取最小值
    static float
    min(float... numberArray)
    取最小值
    static int
    min(int... numberArray)
    取最小值
    static long
    min(long... numberArray)
    取最小值
    static short
    min(short... numberArray)
    取最小值
    static boolean[]
    remove(boolean[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static byte[]
    remove(byte[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static char[]
    remove(char[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static double[]
    remove(double[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static float[]
    remove(float[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static int[]
    remove(int[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static long[]
    remove(long[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static short[]
    remove(short[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static Object
    remove(Object array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static boolean[]
    removeEle(boolean[] array, boolean element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static byte[]
    removeEle(byte[] array, byte element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static char[]
    removeEle(char[] array, char element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static double[]
    removeEle(double[] array, double element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static float[]
    removeEle(float[] array, float element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static int[]
    removeEle(int[] array, int element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static long[]
    removeEle(long[] array, long element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static short[]
    removeEle(short[] array, short element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
    static byte[]
    resize(byte[] bytes, int newSize)
    生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
    static boolean[]
    reverse(boolean[] array)
    反转数组，会变更原数组
    static boolean[]
    reverse(boolean[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static byte[]
    reverse(byte[] array)
    反转数组，会变更原数组
    static byte[]
    reverse(byte[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static char[]
    reverse(char[] array)
    反转数组，会变更原数组
    static char[]
    reverse(char[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static double[]
    reverse(double[] array)
    反转数组，会变更原数组
    static double[]
    reverse(double[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static float[]
    reverse(float[] array)
    反转数组，会变更原数组
    static float[]
    reverse(float[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static int[]
    reverse(int[] array)
    反转数组，会变更原数组
    static int[]
    reverse(int[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static long[]
    reverse(long[] array)
    反转数组，会变更原数组
    static long[]
    reverse(long[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static short[]
    reverse(short[] array)
    反转数组，会变更原数组
    static short[]
    reverse(short[] array, int startIndexInclusive, int endIndexExclusive)
    反转数组，会变更原数组
    static boolean[]
    shuffle(boolean[] array)
    打乱数组顺序，会变更原数组
    static boolean[]
    shuffle(boolean[] array, Random random)
    打乱数组顺序，会变更原数组
    static byte[]
    shuffle(byte[] array)
    打乱数组顺序，会变更原数组
    static byte[]
    shuffle(byte[] array, Random random)
    打乱数组顺序，会变更原数组
    static char[]
    shuffle(char[] array)
    打乱数组顺序，会变更原数组
    static char[]
    shuffle(char[] array, Random random)
    打乱数组顺序，会变更原数组
    static double[]
    shuffle(double[] array)
    打乱数组顺序，会变更原数组
    static double[]
    shuffle(double[] array, Random random)
    打乱数组顺序，会变更原数组
    static float[]
    shuffle(float[] array)
    打乱数组顺序，会变更原数组
    static float[]
    shuffle(float[] array, Random random)
    打乱数组顺序，会变更原数组
    static int[]
    shuffle(int[] array)
    打乱数组顺序，会变更原数组
    static int[]
    shuffle(int[] array, Random random)
    打乱数组顺序，会变更原数组
    static long[]
    shuffle(long[] array)
    打乱数组顺序，会变更原数组
    static long[]
    shuffle(long[] array, Random random)
    打乱数组顺序，会变更原数组
    static short[]
    shuffle(short[] array)
    打乱数组顺序，会变更原数组
    static short[]
    shuffle(short[] array, Random random)
    打乱数组顺序，会变更原数组
    static byte[][]
    split(byte[] array, int len)
    拆分byte数组为几个等份（最后一份按照剩余长度分配空间）
    static boolean
    startWith(boolean[] array, boolean... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(byte[] array, byte... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(char[] array, char... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(double[] array, double... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(float[] array, float... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(int[] array, int... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(long[] array, long... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean
    startWith(short[] array, short... prefix)
    array数组是否以prefix开头 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    static boolean[]
    sub(boolean[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static byte[]
    sub(byte[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static char[]
    sub(char[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static double[]
    sub(double[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static float[]
    sub(float[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static int[]
    sub(int[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static long[]
    sub(long[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static short[]
    sub(short[] array, int start, int end)
    获取子数组 位置可以为负数，例如 -1 代表 数组最后一个元素的位置 如果 开始位置 大于 结束位置，会自动交换 如果 结束位置 大于 数组长度，会变为数组长度
    static boolean[]
    swap(boolean[] array, int index1, int index2)
    交换数组中两个位置的值
    static byte[]
    swap(byte[] array, int index1, int index2)
    交换数组中两个位置的值
    static char[]
    swap(char[] array, int index1, int index2)
    交换数组中两个位置的值
    static double[]
    swap(double[] array, int index1, int index2)
    交换数组中两个位置的值
    static float[]
    swap(float[] array, int index1, int index2)
    交换数组中两个位置的值
    static int[]
    swap(int[] array, int index1, int index2)
    交换数组中两个位置的值
    static long[]
    swap(long[] array, int index1, int index2)
    交换数组中两个位置的值
    static short[]
    swap(short[] array, int index1, int index2)
    交换数组中两个位置的值
    static boolean[]
    unWrap(Boolean... values)
    包装类数组转为原始类型数组 null 按照 false 对待
    static byte[]
    unWrap(Byte... values)
    包装类数组转为原始类型数组
    static char[]
    unWrap(Character... values)
    包装类数组转为原始类型数组
    static double[]
    unWrap(Double... values)
    包装类数组转为原始类型数组
    static float[]
    unWrap(Float... values)
    包装类数组转为原始类型数组
    static int[]
    unWrap(Integer... values)
    包装类数组转为原始类型数组，null转为0
    static long[]
    unWrap(Long... values)
    包装类数组转为原始类型数组
    static short[]
    unWrap(Short... values)
    包装类数组转为原始类型数组
    static Boolean[]
    wrap(boolean... values)
    将原始类型数组包装为包装类型
    static Byte[]
    wrap(byte... values)
    将原始类型数组包装为包装类型
    static Character[]
    wrap(char... values)
    将原始类型数组包装为包装类型
    static Double[]
    wrap(double... values)
    将原始类型数组包装为包装类型
    static Float[]
    wrap(float... values)
    将原始类型数组包装为包装类型
    static Integer[]
    wrap(int... values)
    将原始类型数组包装为包装类型
    static Long[]
    wrap(long... values)
    将原始类型数组包装为包装类型
    static Short[]
    wrap(short... values)
    将原始类型数组包装为包装类型

    Methods inherited from class org.miaixz.bus.core.center.array.ArrayValidator

    defaultIfEmpty, emptyCount, firstMatch, firstNonNull, hasBlank, hasEmpty, hasEmptyVarargs, hasNonNull, hasNull, indexOf, indexOf, indexOfIgnoreCase, indexOfSub, indexOfSub, isAllBlank, isAllEmpty, isAllEmptyVarargs, isAllNotBlank, isAllNotEmpty, isAllNotNull, isAllNull, isArray, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isSorted, isSorted, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSub, isSubEquals, lastIndexOf, lastIndexOf, length, matchIndex, matchIndex, regionMatches, toString

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • PrimitiveArray

      public PrimitiveArray()

  • Method Details

    • resize

      public static byte[] resize(byte[] bytes, int newSize)
      生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
      Parameters:
      bytes - 原数组
      newSize - 新的数组大小
      Returns:
      调整后的新数组

    • addAll

      public static byte[] addAll(byte[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static int[] addAll(int[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static long[] addAll(long[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static double[] addAll(double[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static float[] addAll(float[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static char[] addAll(char[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static boolean[] addAll(boolean[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • addAll

      public static short[] addAll(short[]... arrays)
      将多个数组合并在一起 忽略null的数组
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • split

      public static byte[][] split(byte[] array, int len)
      拆分byte数组为几个等份（最后一份按照剩余长度分配空间）
      Parameters:
      array - 数组
      len - 每个小节的长度
      Returns:
      拆分后的数组

    • indexOf

      public static int indexOf(long[] array, long value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(long[] array, long value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(long[] array, long value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(int[] array, int value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(int[] array, int value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(int[] array, int value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(short[] array, short value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(short[] array, short value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(short[] array, short value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(char[] array, char value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(char[] array, char value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(char[] array, char value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(byte[] array, byte value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(byte[] array, byte value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(byte[] array, byte value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(double[] array, double value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(double[] array, double value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(double[] array, double value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(float[] array, float value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(float[] array, float value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(float[] array, float value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • indexOf

      public static int indexOf(boolean[] array, boolean value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static int lastIndexOf(boolean[] array, boolean value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • contains

      public static boolean contains(boolean[] array, boolean value)
      数组中是否包含元素
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • wrap

      public static Integer[] wrap(int... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static int[] unWrap(Integer... values)
      包装类数组转为原始类型数组，null转为0
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Long[] wrap(long... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static long[] unWrap(Long... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Character[] wrap(char... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static char[] unWrap(Character... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Byte[] wrap(byte... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static byte[] unWrap(Byte... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Short[] wrap(short... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static short[] unWrap(Short... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Float[] wrap(float... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static float[] unWrap(Float... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Double[] wrap(double... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static double[] unWrap(Double... values)
      包装类数组转为原始类型数组
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • wrap

      public static Boolean[] wrap(boolean... values)
      将原始类型数组包装为包装类型
      Parameters:
      values - 原始类型数组
      Returns:
      包装类型数组

    • unWrap

      public static boolean[] unWrap(Boolean... values)
      包装类数组转为原始类型数组 null 按照 false 对待
      Parameters:
      values - 包装类型数组
      Returns:
      原始类型数组

    • sub

      public static byte[] sub(byte[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static int[] sub(int[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static long[] sub(long[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static short[] sub(short[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static char[] sub(char[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static double[] sub(double[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static float[] sub(float[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static boolean[] sub(boolean[] array, int start, int end)
      获取子数组
      • 位置可以为负数，例如 -1 代表 数组最后一个元素的位置
      • 如果 开始位置 大于 结束位置，会自动交换
      • 如果 结束位置 大于 数组长度，会变为数组长度
      Parameters:
      array - 数组
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • remove

      public static long[] remove(long[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static int[] remove(int[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static short[] remove(short[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static char[] remove(char[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static byte[] remove(byte[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static double[] remove(double[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static float[] remove(float[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static boolean[] remove(boolean[] array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • remove

      public static Object remove(Object array, int index) throws IllegalArgumentException
      移除数组中对应位置的元素 copier from commons-lang
      Parameters:
      array - 数组对象，可以是对象数组，也可以原始类型数组
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static long[] removeEle(long[] array, long element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static int[] removeEle(int[] array, int element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static short[] removeEle(short[] array, short element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static char[] removeEle(char[] array, char element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static byte[] removeEle(byte[] array, byte element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static double[] removeEle(double[] array, double element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static float[] removeEle(float[] array, float element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static boolean[] removeEle(boolean[] array, boolean element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Parameters:
      array - 数组对象
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • reverse

      public static long[] reverse(long[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static long[] reverse(long[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static int[] reverse(int[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static int[] reverse(int[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static short[] reverse(short[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static short[] reverse(short[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static char[] reverse(char[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static char[] reverse(char[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static byte[] reverse(byte[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static byte[] reverse(byte[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static double[] reverse(double[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static double[] reverse(double[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static float[] reverse(float[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static float[] reverse(float[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • reverse

      public static boolean[] reverse(boolean[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 起始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static boolean[] reverse(boolean[] array)
      反转数组，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • min

      public static long min(long... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static int min(int... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static short min(short... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static char min(char... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static byte min(byte... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static double min(double... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static float min(float... numberArray)
      取最小值
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • max

      public static long max(long... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static int max(int... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static short max(short... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static char max(char... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static byte max(byte... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static double max(double... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static float max(float... numberArray)
      取最大值
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • shuffle

      public static int[] shuffle(int[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static int[] shuffle(int[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static long[] shuffle(long[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static long[] shuffle(long[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static double[] shuffle(double[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static double[] shuffle(double[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static float[] shuffle(float[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static float[] shuffle(float[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static boolean[] shuffle(boolean[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static boolean[] shuffle(boolean[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static byte[] shuffle(byte[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static byte[] shuffle(byte[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static char[] shuffle(char[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static char[] shuffle(char[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • shuffle

      public static short[] shuffle(short[] array)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static short[] shuffle(short[] array, Random random)
      打乱数组顺序，会变更原数组
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • swap

      public static int[] swap(int[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static long[] swap(long[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static double[] swap(double[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static float[] swap(float[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static boolean[] swap(boolean[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static byte[] swap(byte[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static char[] swap(char[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static short[] swap(short[] array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • startWith

      public static boolean startWith(boolean[] array, boolean... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(byte[] array, byte... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(char[] array, char... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(double[] array, double... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(float[] array, float... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(int[] array, int... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(long[] array, long... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • startWith

      public static boolean startWith(short[] array, short... prefix)
      array数组是否以prefix开头
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头