Package org.aoju.bus.core.toolkit
Class ArrayKit
java.lang.Object
org.aoju.bus.core.toolkit.ArrayKit
-
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionstatic boolean[]add(boolean[] array, boolean element) 复制给定数组并在新数组的末尾添加给定元素.static boolean[]add(boolean[] array, int index, boolean element) 复制给定数组并在新数组的末尾添加给定元素.static byte[]add(byte[] array, byte element) 复制给定数组并在新数组的末尾添加给定元素.static byte[]add(byte[] array, int index, byte element) 复制给定数组并在新数组的末尾添加给定元素.static char[]add(char[] array, char element) 复制给定数组并在新数组的末尾添加给定元素.static char[]add(char[] array, int index, char element) 复制给定数组并在新数组的末尾添加给定元素.static double[]add(double[] array, double element) 复制给定数组并在新数组的末尾添加给定元素.static double[]add(double[] array, int index, double element) 复制给定数组并在新数组的末尾添加给定元素.static float[]add(float[] array, float element) 复制给定数组并在新数组的末尾添加给定元素.static float[]add(float[] array, int index, float element) 复制给定数组并在新数组的末尾添加给定元素.static int[]add(int[] array, int element) 复制给定数组并在新数组的末尾添加给定元素.static int[]add(int[] array, int index, int element) 复制给定数组并在新数组的末尾添加给定元素.static long[]add(long[] array, int index, long element) 复制给定数组并在新数组的末尾添加给定元素.static long[]add(long[] array, long element) 复制给定数组并在新数组的末尾添加给定元素.static short[]add(short[] array, int index, short element) 复制给定数组并在新数组的末尾添加给定元素.static short[]add(short[] array, short element) 复制给定数组并在新数组的末尾添加给定元素.static <T> T[]add(T[] array, int index, T element) 复制给定数组并在新数组的末尾添加给定元素.static <T> T[]add(T[] array, T element) 复制给定数组并在新数组的末尾添加给定元素.static boolean[]addAll(boolean[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static byte[]addAll(byte[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static char[]addAll(char[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static double[]addAll(double[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static float[]addAll(float[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static int[]addAll(int[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static long[]addAll(long[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static short[]addAll(short[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static <T> T[]addAll(T[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素static <T> Object将新元素添加到已有数组中 添加新元素会生成一个新的数组,不影响原数组static <T> T[]append(T[] buffer, T... newElements) 将新元素添加到已有数组中 添加新元素会生成一个新的数组,不影响原数组static Object[]强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组static boolean[]clone(boolean[] array) 克隆数组static byte[]clone(byte[] array) 克隆数组static char[]clone(char[] array) 克隆数组static double[]clone(double[] array) 克隆数组static float[]clone(float[] array) 克隆数组static int[]clone(int[] array) 克隆数组static long[]clone(long[] array) 克隆数组static short[]clone(short[] array) 克隆数组static <T> Tclone(T object) 克隆数组,如果非数组返回nullstatic <T> T[]clone(T[] array) 克隆数组static booleancontains(boolean[] array, boolean value) 数组中是否包含元素static booleancontains(byte[] array, byte value) 数组中是否包含元素static booleancontains(char[] array, char value) 数组中是否包含元素static booleancontains(double[] array, double value) 数组中是否包含元素static booleancontains(double[] array, double value, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1static booleancontains(float[] array, float value) 数组中是否包含元素static booleancontains(int[] array, int value) 数组中是否包含元素static booleancontains(long[] array, long value) 数组中是否包含元素static booleancontains(short[] array, short value) 数组中是否包含元素static boolean数组中是否包含元素static <T> booleancontainsAll(T[] array, T... values) 数组中是否包含指定元素中的全部static <T> booleancontainsAny(T[] array, T... values) 数组中是否包含指定元素中的任意一个static booleancontainsIgnoreCase(CharSequence[] array, CharSequence value) 数组中是否包含元素,忽略大小写static Objectstatic Object包装System.arraycopy(Object, int, Object, int, int)数组复制,缘数组和目标数组都是从位置0开始复制static boolean判断两个数组是否相等,判断依据包括数组长度和每个元素都相等static <T> T[]过滤 过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能:static <T> T[]过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能:static <T> intfirstNonAll(Predicate<T> matcher, int beginIndexInclude, T... array) 返回数组中第一个匹配规则的值的位置static <T> intfirstNonAll(Predicate<T> matcher, T... array) 返回数组中第一个匹配规则的值的位置static <T> TfirstNonNull(Predicate<T> matcher, T... array) 返回数组中第一个匹配规则的值static <T> TfirstNonNull(T... array) 返回数组中第一个非空元素firstNotNull(Object[] objects) 找到第一个不为 null 的元素static <T> T获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值static <T> T[]获取数组中指定多个下标元素值,组成新数组static Class<?> getArrayType(Class<?> componentType) 根据数组元素类型,获取数组的类型 方法是通过创建一个空数组从而获取其类型static Class<?> getComponentType(Class<?> arrayClass) 获取数组对象的元素类型static Class<?> getComponentType(Object array) 获取数组对象的元素类型static int返回指定数组的长度static boolean是否存在null或空对象,通过ObjectKit.isEmpty(Object)判断元素static int获得一个数组哈希码,用于正确处理多维数组 多维基元数组也可以用该方法正确处理static <T> booleanhasNull(T... array) 是否包含null元素static intindexOf(boolean[] array, boolean value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(boolean[] array, boolean value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(byte[] array, byte value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(byte[] array, byte value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(char[] array, char value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(char[] array, char value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(double[] array, double value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(double[] array, double value, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(double[] array, double value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(double[] array, double value, int index, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(float[] array, float value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(float[] array, float value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(int[] array, int value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(int[] array, int value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(long[] array, long value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(long[] array, long value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(short[] array, short value) 返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOf(short[] array, short value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1static int返回数组中指定元素所在位置,未找到返回Normal.__1static int返回数组中指定元素所在位置,未找到返回Normal.__1static intindexOfIgnoreCase(CharSequence[] array, CharSequence value) 返回数组中指定元素所在位置,忽略大小写,未找到返回Normal.__1static <T> intindexOfSub(T[] array, T[] subArray) 查找子数组的位置static boolean[]insert(int index, boolean[] array, boolean... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static byte[]insert(int index, byte[] array, byte... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static char[]insert(int index, char[] array, char... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static double[]insert(int index, double[] array, double... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static float[]insert(int index, float[] array, float... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static int[]insert(int index, int[] array, int... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static long[]insert(int index, long[] array, long... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static short[]insert(int index, short[] array, short... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static <T> T[]insert(int index, T[] array, T... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组static <A,T> A insert(A array, int index, T... newElements) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组,不影响原数组 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充static <T> T[]insert(T[] buffer, int index, T... newElements) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组,不影响原数组 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充static booleanisAllEmpty(Object... args) 是否存都为null或空对象,通过ObjectKit.isEmpty(Object)判断元素static booleanisAllNotEmpty(Object... args) 是否存都不为null或空对象,通过ObjectKit.isEmpty(Object)判断元素static <T> booleanisAllNotNull(T... array) 多个字段是否全部不为nullstatic <T> booleanisAllNull(T... array) 多个字段是否全为nullstatic boolean对象是否为数组对象static <T> booleanisArrayIndexValid(T[] array, int index) 返回是否可以在给定索引处安全地访问给定数组static booleanisEmpty(boolean[] array) 数组是否为空static booleanisEmpty(byte[] array) 数组是否为空static booleanisEmpty(char[] array) 数组是否为空static booleanisEmpty(double[] array) 数组是否为空static booleanisEmpty(float[] array) 数组是否为空static booleanisEmpty(int[] array) 数组是否为空static booleanisEmpty(long[] array) 数组是否为空static booleanisEmpty(short[] array) 数组是否为空static boolean数组是否为空 此方法会匹配单一对象,如果此对象为null则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回truestatic <T> booleanisEmpty(T[] array) 数组是否为空static booleanisNotEmpty(boolean[] array) 数组是否为非空static booleanisNotEmpty(byte[] array) 数组是否为非空static booleanisNotEmpty(char[] array) 数组是否为非空static booleanisNotEmpty(double[] array) 数组是否为非空static booleanisNotEmpty(float[] array) 数组是否为非空static booleanisNotEmpty(int[] array) 数组是否为非空static booleanisNotEmpty(long[] array) 数组是否为非空static booleanisNotEmpty(short[] array) 数组是否为非空static <T> booleanisNotEmpty(T[] array) 数组是否为非空 此方法会匹配单一对象,如果此对象为null则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回falsestatic booleanisSameLength(boolean[] array1, boolean[] array2) 检查两个数组是否相同长度static booleanisSameLength(byte[] array1, byte[] array2) 检查两个数组是否相同长度static booleanisSameLength(char[] array1, char[] array2) 检查两个数组是否相同长度static booleanisSameLength(double[] array1, double[] array2) 检查两个数组是否相同长度static booleanisSameLength(float[] array1, float[] array2) 检查两个数组是否相同长度static booleanisSameLength(int[] array1, int[] array2) 检查两个数组是否相同长度static booleanisSameLength(long[] array1, long[] array2) 检查两个数组是否相同长度static booleanisSameLength(short[] array1, short[] array2) 检查两个数组是否相同长度static booleanisSameLength(Object[] array1, Object[] array2) 检查两个数组是否相同长度static booleanisSameType(Object array1, Object array2) 检查两个数组是否为同一类型static booleanisSorted(boolean[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(byte[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(char[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(double[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(float[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(int[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(long[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static booleanisSorted(short[] array) 该方法检查提供的数组是否按照提供的Comparator排序.static <T extends Comparable<? super T>>
booleanisSorted(T[] array) 该方法检查提供的数组是否按照类的compareTo方法排序.static <T> booleanisSorted(T[] array, Comparator<T> comparator) 该方法检查提供的数组是否按照提供的Comparator排序.static <T> booleanisSub(T[] array, T[] subArray) 查找子数组的位置static Stringjoin(CharSequence conjunction, Object... args) 以 conjunction 为分隔符将多个对象转换为字符串static <T> Stringjoin(T[] array, CharSequence conjunction) 以 conjunction 为分隔符将数组转换为字符串static <T> Stringjoin(T[] array, CharSequence delimiter, String prefix, String suffix) 以 conjunction 为分隔符将数组转换为字符串static <T> Stringjoin(T[] array, CharSequence conjunction, Editor<T> editor) 以 conjunction 为分隔符将数组转换为字符串static intlastIndexOf(boolean[] array, boolean value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(boolean[] array, boolean value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(byte[] array, byte value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(byte[] array, byte value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(char[] array, char value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(char[] array, char value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(double[] array, double value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(double[] array, double value, double tolerance) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(double[] array, double value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(double[] array, double value, int index, double tolerance) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(float[] array, float value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(float[] array, float value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(int[] array, int value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(int[] array, int value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(long[] array, long value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(long[] array, long value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(short[] array, short value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(short[] array, short value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(Object[] array, Object value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static intlastIndexOf(Object[] array, Object value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1static <T> intlastIndexOfSub(T[] array, T[] subArray) 查找最后一个子数组的开始位置static int获取数组长度 如果参数为null,返回0static <T,R> R[] 按照指定规则,将一种类型的数组转换为另一种类型static <T,R> R[] 按照指定规则,将一种类型的数组转换为另一种类型static <T,R> List <R> 按照指定规则,将一种类型的数组元素提取后转换为Liststatic <T,R> Set <R> 按照指定规则,将一种类型的数组元素提取后转换为Setstatic bytemax(byte... numberArray) 取最大值static charmax(char... numberArray) 取最大值static doublemax(double... numberArray) 取最大值static floatmax(float... numberArray) 取最大值static intmax(int... numberArray) 取最大值static longmax(long... numberArray) 取最大值static shortmax(short... numberArray) 取最大值static <T extends Comparable<? super T>>
Tmax(T[] numberArray) 取最大值static <T extends Comparable<? super T>>
Tmax(T[] numberArray, Comparator<T> comparator) 取最大值static bytemin(byte... numberArray) 取最小值static charmin(char... numberArray) 取最小值static doublemin(double... numberArray) 取最小值static floatmin(float... numberArray) 取最小值static intmin(int... numberArray) 取最小值static longmin(long... numberArray) 取最小值static shortmin(short... numberArray) 取最小值static <T extends Comparable<? super T>>
Tmin(T[] numberArray) 取最小值static <T extends Comparable<? super T>>
Tmin(T[] numberArray, Comparator<T> comparator) 取最小值static <T> T[]newArray(int newSize) 新建一个空数组static <T> T[]新建一个空数组static Object[]强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组static boolean[]nullToEmpty(boolean[] array) 输入数组返回一个空数组或原始数组static byte[]nullToEmpty(byte[] array) 输入数组返回一个空数组或原始数组static char[]nullToEmpty(char[] array) 输入数组返回一个空数组或原始数组static double[]nullToEmpty(double[] array) 输入数组返回一个空数组或原始数组static float[]nullToEmpty(float[] array) 输入数组返回一个空数组或原始数组static int[]nullToEmpty(int[] array) 输入数组返回一个空数组或原始数组static long[]nullToEmpty(long[] array) 输入数组返回一个空数组或原始数组static short[]nullToEmpty(short[] array) 输入数组返回一个空数组或原始数组static Boolean[]nullToEmpty(Boolean[] array) 输入数组返回一个空数组或原始数组static Byte[]nullToEmpty(Byte[] array) 输入数组返回一个空数组或原始数组static Character[]nullToEmpty(Character[] array) 输入数组返回一个空数组或原始数组static Class<?>[]nullToEmpty(Class<?>[] array) 输入数组返回一个空数组或原始数组static Double[]nullToEmpty(Double[] array) 输入数组返回一个空数组或原始数组static Float[]nullToEmpty(Float[] array) 输入数组返回一个空数组或原始数组static Integer[]nullToEmpty(Integer[] array) 输入数组返回一个空数组或原始数组static Long[]nullToEmpty(Long[] array) 输入数组返回一个空数组或原始数组static Object[]nullToEmpty(Object[] array) 输入数组返回一个空数组或原始数组static Short[]nullToEmpty(Short[] array) 输入数组返回一个空数组或原始数组static String[]nullToEmpty(String[] array) 输入数组返回一个空数组或原始数组static <T> T[]nullToEmpty(T[] array, Class<T[]> type) 输入数组返回一个空数组或原始数组static int[]range(int excludedEnd) 生成一个从0开始的数字列表static int[]range(int includedStart, int excludedEnd) 生成一个数字列表 自动判定正序反序static int[]range(int includedStart, int excludedEnd, int step) 生成一个数字列表 自动判定正序反序static boolean[]remove(boolean[] array, int index) 从指定数组中移除指定位置的元素。static byte[]remove(byte[] array, int index) 从指定数组中移除指定位置的元素。static char[]remove(char[] array, int index) 从指定数组中移除指定位置的元素。static double[]remove(double[] array, int index) 从指定数组中移除指定位置的元素。static float[]remove(float[] array, int index) 从指定数组中移除指定位置的元素。static int[]remove(int[] array, int index) 从指定数组中移除指定位置的元素。static long[]remove(long[] array, int index) 从指定数组中移除指定位置的元素。static short[]remove(short[] array, int index) 从指定数组中移除指定位置的元素。static <T> T[]remove(T[] array) 去重数组中的元素,去重后生成新的数组,原数组不变 此方法通过LinkedHashSet去重static <T> T[]remove(T[] array, int index) 从指定数组中移除指定位置的元素。static <T,K> T[] 去重数组中的元素,去重后生成新的数组,原数组不变 此方法通过LinkedHashSet去重static boolean[]removeAll(boolean[] array, int... indices) 从指定数组中移除指定位置的元素。static byte[]removeAll(byte[] array, int... indices) 从指定数组中移除指定位置的元素。static char[]removeAll(char[] array, int... indices) 从指定数组中移除指定位置的元素。static double[]removeAll(double[] array, int... indices) 从指定数组中移除指定位置的元素。static float[]removeAll(float[] array, int... indices) 从指定数组中移除指定位置的元素。static int[]removeAll(int[] array, int... indices) 从指定数组中移除指定位置的元素。static long[]removeAll(long[] array, int... indices) 从指定数组中移除指定位置的元素。static short[]removeAll(short[] array, int... indices) 从指定数组中移除指定位置的元素。static <T> T[]removeAll(T[] array, int... indices) 从指定数组中移除指定位置的元素。static boolean[]removeAllOccurences(boolean[] array, boolean element) 从指定的布尔数组中移除指定元素.static byte[]removeAllOccurences(byte[] array, byte element) 从指定的布尔数组中移除指定元素.static char[]removeAllOccurences(char[] array, char element) 从指定的布尔数组中移除指定元素.static double[]removeAllOccurences(double[] array, double element) 从指定的布尔数组中移除指定元素.static float[]removeAllOccurences(float[] array, float element) 从指定的布尔数组中移除指定元素.static int[]removeAllOccurences(int[] array, int element) 从指定的布尔数组中移除指定元素.static long[]removeAllOccurences(long[] array, long element) 从指定的布尔数组中移除指定元素.static short[]removeAllOccurences(short[] array, short element) 从指定的布尔数组中移除指定元素.static <T> T[]removeAllOccurences(T[] array, T element) 从指定的布尔数组中移除指定元素.static <T extends CharSequence>
T[]removeBlank(T[] array) 去除null或者""或者空白字符串 元素static boolean[]removeElement(boolean[] array, boolean element) 从指定数组中移除指定位置的元素。static byte[]removeElement(byte[] array, byte element) 从指定数组中移除指定位置的元素。static char[]removeElement(char[] array, char element) 从指定数组中移除指定位置的元素。static double[]removeElement(double[] array, double element) 从指定数组中移除指定位置的元素。static float[]removeElement(float[] array, float element) 从指定数组中移除指定位置的元素。static int[]removeElement(int[] array, int element) 从指定数组中移除指定位置的元素。static long[]removeElement(long[] array, long element) 从指定数组中移除指定位置的元素。static short[]removeElement(short[] array, short element) 从指定数组中移除指定位置的元素。static <T> T[]removeElement(T[] array, Object element) 从指定数组中移除指定位置的元素。static boolean[]removeElements(boolean[] array, boolean... values) 从指定数组中移除指定数量*的指定元素。static byte[]removeElements(byte[] array, byte... values) 从指定数组中移除指定数量*的指定元素。static char[]removeElements(char[] array, char... values) 从指定数组中移除指定数量*的指定元素。static double[]removeElements(double[] array, double... values) 从指定数组中移除指定数量*的指定元素。static float[]removeElements(float[] array, float... values) 从指定数组中移除指定数量*的指定元素。static int[]removeElements(int[] array, int... values) 从指定数组中移除指定数量*的指定元素。static long[]removeElements(long[] array, long... values) 从指定数组中移除指定数量*的指定元素。static short[]removeElements(short[] array, short... values) 从指定数组中移除指定数量*的指定元素。static <T> T[]removeElements(T[] array, T... values) 从指定数组中移除指定数量*的指定元素。static <T extends CharSequence>
T[]removeEmpty(T[] array) 去除null或者"" 元素static <T> T[]replace(T[] buffer, int index, T... values) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新数组或原有数组 如果插入位置为为负数,那么生成一个由插入元素顺序加已有数组顺序的新数组static byte[]resize(byte[] bytes, int newSize) 生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,其它位置补充0,缩小则截断static <T> T[]resize(T[] buffer, int newSize) 生成一个新的重新设置大小的数组 新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断static <T> T[]生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断static boolean[]reverse(boolean[] array) 反转数组,会变更原数组static boolean[]reverse(boolean[] array, int startIndex, int endIndex) 反转数组,会变更原数组static byte[]reverse(byte[] array) 反转数组,会变更原数组static byte[]reverse(byte[] array, int startIndex, int endIndex) 反转数组,会变更原数组static char[]reverse(char[] array) 反转数组,会变更原数组static char[]reverse(char[] array, int startIndex, int endIndex) 反转数组,会变更原数组static double[]reverse(double[] array) 反转数组,会变更原数组static double[]reverse(double[] array, int startIndex, int endIndex) 反转数组,会变更原数组static float[]reverse(float[] array) 反转数组,会变更原数组static float[]reverse(float[] array, int startIndex, int endIndex) 反转数组,会变更原数组static int[]reverse(int[] array) 反转数组,会变更原数组static int[]reverse(int[] array, int startIndex, int endIndex) 反转数组,会变更原数组static long[]reverse(long[] array) 反转数组,会变更原数组static long[]reverse(long[] array, int startIndex, int endIndex) 反转数组,会变更原数组static short[]reverse(short[] array) 反转数组,会变更原数组static short[]reverse(short[] array, int startIndex, int endIndex) 反转数组,会变更原数组static ObjectsetOrAppend(Object array, int index, Object value) 将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加static <T> T[]setOrAppend(T[] buffer, int index, T value) 将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加static voidshift(boolean[] array, int offset) 改变数组的顺序static voidshift(boolean[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(byte[] array, int offset) 改变数组的顺序static voidshift(byte[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(char[] array, int offset) 改变数组的顺序static voidshift(char[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(double[] array, int offset) 改变数组的顺序static voidshift(double[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(float[] array, int offset) 改变数组的顺序static voidshift(float[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(int[] array, int offset) 移位给定int数组的顺序static voidshift(int[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(long[] array, int offset) 移位给定长数组的顺序static voidshift(long[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static voidshift(short[] array, int offset) 改变数组的顺序static voidshift(short[] array, int startIndex, int endIndex, int offset) 改变数组的顺序static void移位给定数组的顺序static void改变数组的顺序static voidshuffle(boolean[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(byte[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(char[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(double[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(float[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(int[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(long[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static voidshuffle(short[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static void使用Fisher-Yates算法随机遍历指定数组的元素.static boolean[]sub(boolean[] array, int start, int end) 获取子数组static byte[]sub(byte[] array, int start, int end) 获取子数组static char[]sub(char[] array, int start, int end) 获取子数组static double[]sub(double[] array, int start, int end) 获取子数组static float[]sub(float[] array, int start, int end) 获取子数组static int[]sub(int[] array, int start, int end) 获取子数组static long[]sub(long[] array, int start, int end) 获取子数组static short[]sub(short[] array, int start, int end) 获取子数组static Object[]获取子数组static Object[]获取子数组static <T> T[]sub(T[] array, int start, int end) 获取子数组static boolean[]subarray(boolean[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static byte[]subarray(byte[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static char[]subarray(char[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static double[]subarray(double[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static float[]subarray(float[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static int[]subarray(int[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static long[]subarray(long[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static short[]subarray(short[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static <T> T[]subarray(T[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出static voidswap(boolean[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(boolean[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(byte[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(byte[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(char[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(char[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(double[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(double[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(float[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(float[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(int[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(int[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(long[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(long[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static voidswap(short[] array, int offset1, int offset2) 交换数组中连个位置的值static voidswap(short[] array, int offset1, int offset2, int len) 交换数组中连个位置的值static void交换数组中连个位置的值static void交换数组中连个位置的值static <T> T[]将集合转为数组static byte[]toArray(ByteBuffer bytebuffer) ByteBuffer转byte数组static <T> T[]toArray(Collection<T> collection, Class<T> componentType) 将集合转为数组static String[]toArray(Enumeration<String> enumeration) 将给定的枚举复制到String数组中 枚举必须只包含String元素static <T> T[]将集合转为数组static String[]将集合转数组static Boolean[]toObject(boolean[] array) 将原始布尔值数组转换为对象 此方法为null输入数组返回nullstatic Byte[]toObject(byte[] array) 将对象byte数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic Character[]toObject(char[] array) 将对象char数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic Double[]toObject(double[] array) 将对象double数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic Float[]toObject(float[] array) 将基元float组转换为对象 此方法为null输入数组返回nullstatic Integer[]toObject(int[] array) 将对象int数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic Long[]toObject(long[] array) 将对象long数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic Short[]toObject(short[] array) 将对象short数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic boolean[]toPrimitive(Boolean[] array) 将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回nullstatic boolean[]toPrimitive(Boolean[] array, boolean valueForNull) 将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回nullstatic byte[]toPrimitive(Byte[] array) 将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic byte[]toPrimitive(Byte[] array, byte valueForNull) 将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic char[]toPrimitive(Character[] array) 将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic char[]toPrimitive(Character[] array, char valueForNull) 将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic double[]toPrimitive(Double[] array) 将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic double[]toPrimitive(Double[] array, double valueForNull) 将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic float[]toPrimitive(Float[] array) 将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic float[]toPrimitive(Float[] array, float valueForNull) 将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic int[]toPrimitive(Integer[] array) 将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic int[]toPrimitive(Integer[] array, int valueForNull) 将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic long[]toPrimitive(Long[] array) 将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic long[]toPrimitive(Long[] array, long valueForNull) 将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic ObjecttoPrimitive(Object array) 从包装器类型数组创建基元类型数组 该方法为一个null输入数组返回nullstatic short[]toPrimitive(Short[] array) 将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic short[]toPrimitive(Short[] array, short valueForNull) 将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回nullstatic String数组或集合转Stringstatic String数组或集合转Stringstatic String[]toStringArray(Object[] array) 返回一个数组,该数组包含参数数组中每个元素的字符串表示形式.static String[]toStringArray(Object[] array, String valueForNullElements) 返回一个数组,该数组包含处理null元素的参数数组中每个元素的字符串表示形式 该方法为一个null输入数组返回nullstatic boolean[]包装类数组转为原始类型数组static byte[]包装类数组转为原始类型数组static char[]包装类数组转为原始类型数组static double[]包装类数组转为原始类型数组static float[]包装类数组转为原始类型数组static int[]包装类数组转为原始类型数组static long[]包装类数组转为原始类型数组static short[]包装类数组转为原始类型数组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 Long[]wrap(long... values) 将原始类型数组包装为包装类型static Short[]wrap(short... values) 将原始类型数组包装为包装类型static Object[]包装数组对象static <K,V> Map <K, V> zip(K[] keys, V[] values) 映射键值(参考Python的zip()函数),返回Map无序 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分static <K,V> Map <K, V> zip(K[] keys, V[] values, boolean isOrder) 映射键值(参考Python的zip()函数) 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分
-
Constructor Details
-
ArrayKit
public ArrayKit()
-
-
Method Details
-
isArray
对象是否为数组对象- Parameters:
object- 对象- Returns:
- 是否为数组对象, 如果为
null返回false
-
isEmpty
数组是否为空 此方法会匹配单一对象,如果此对象为null则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static <T> boolean isEmpty(T[] array) 数组是否为空- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(long[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(int[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(short[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(char[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(byte[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(double[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(float[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isEmpty
public static boolean isEmpty(boolean[] array) 数组是否为空- Parameters:
array- 数组- Returns:
- 是否为空
-
isNotEmpty
public static <T> boolean isNotEmpty(T[] array) 数组是否为非空 此方法会匹配单一对象,如果此对象为null则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false- Type Parameters:
T- 对象- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(long[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(int[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(short[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(char[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(byte[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(double[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(float[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isNotEmpty
public static boolean isNotEmpty(boolean[] array) 数组是否为非空- Parameters:
array- 数组- Returns:
- 是否为非空
-
isAllEmpty
是否存都为null或空对象,通过ObjectKit.isEmpty(Object)判断元素- Parameters:
args- 被检查的对象,一个或者多个- Returns:
- 是否都为空
-
isAllNotEmpty
是否存都不为null或空对象,通过ObjectKit.isEmpty(Object)判断元素- Parameters:
args- 被检查的对象,一个或者多个- Returns:
- 是否都不为空
-
nullToEmpty
输入数组返回一个空数组或原始数组- Type Parameters:
T- class 类型- Parameters:
array- 要检查null或为空的数组type- 所需数组的类表示形式- Returns:
- 如果
null - Throws:
IllegalArgumentException- 如果类型参数为空
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
public static long[] nullToEmpty(long[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static int[] nullToEmpty(int[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static short[] nullToEmpty(short[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static char[] nullToEmpty(char[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static byte[] nullToEmpty(byte[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static double[] nullToEmpty(double[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static float[] nullToEmpty(float[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
public static boolean[] nullToEmpty(boolean[] array) 输入数组返回一个空数组或原始数组- Parameters:
array- 数组- Returns:
- 空数组或原始数组
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
nullToEmpty
-
hasEmpty
是否存在null或空对象,通过ObjectKit.isEmpty(Object)判断元素- Parameters:
args- 被检查对象- Returns:
- 是否存在
-
hasNull
public static <T> boolean hasNull(T... array) 是否包含null元素- Type Parameters:
T- 数组元素类型- Parameters:
array- 被检查的数组- Returns:
- 是否包含null元素
-
isAllNull
public static <T> boolean isAllNull(T... array) 多个字段是否全为null- Type Parameters:
T- 数组元素类型- Parameters:
array- 被检查的数组- Returns:
- 多个字段是否全为null
-
isAllNotNull
public static <T> boolean isAllNotNull(T... array) 多个字段是否全部不为null- Type Parameters:
T- 数组元素类型- Parameters:
array- 被检查的数组- Returns:
- 多个字段是否全部不为null
-
firstNonNull
public static <T> T firstNonNull(T... array) 返回数组中第一个非空元素- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组- Returns:
- 非空元素,如果不存在非空元素或数组为空,返回
null
-
firstNonNull
返回数组中第一个匹配规则的值- Type Parameters:
T- 数组元素类型- Parameters:
matcher- 匹配接口,实现此接口自定义匹配规则array- 数组- Returns:
- 匹配元素,如果不存在匹配元素或数组为空,返回
null
-
firstNonAll
返回数组中第一个匹配规则的值的位置- Type Parameters:
T- 数组元素类型- Parameters:
matcher- 匹配接口,实现此接口自定义匹配规则array- 数组- Returns:
- 匹配到元素的位置,-1表示未匹配到
-
firstNonAll
返回数组中第一个匹配规则的值的位置- Type Parameters:
T- 数组元素类型- Parameters:
matcher- 匹配接口,实现此接口自定义匹配规则beginIndexInclude- 检索开始的位置array- 数组- Returns:
- 匹配到元素的位置,-1表示未匹配到
-
firstNotNull
-
removeEmpty
去除null或者"" 元素- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组- Returns:
- 处理后的数组
-
removeBlank
去除null或者""或者空白字符串 元素- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组- Returns:
- 处理后的数组
-
toString
-
toString
-
toArray
-
toArray
将给定的枚举复制到String数组中 枚举必须只包含String元素- Parameters:
enumeration- 要复制的枚举Enumeration- Returns:
String数组
-
toArray
ByteBuffer转byte数组- Parameters:
bytebuffer-ByteBuffer- Returns:
- byte数组
-
toArray
-
toArray
-
toArray
将集合转为数组- Type Parameters:
T- 数组元素类型- Parameters:
collection- 集合componentType- 集合元素类型- Returns:
- 数组
-
clone
public static <T> T[] clone(T[] array) 克隆数组- Type Parameters:
T- 对象- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static <T> T clone(T object) 克隆数组,如果非数组返回null- Type Parameters:
T- 数组元素类型- Parameters:
object- 数组对象- Returns:
- 克隆后的数组对象
-
clone
public static long[] clone(long[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static int[] clone(int[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static short[] clone(short[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static char[] clone(char[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static byte[] clone(byte[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static double[] clone(double[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static float[] clone(float[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
clone
public static boolean[] clone(boolean[] array) 克隆数组- Parameters:
array- 被克隆的数组- Returns:
- 新数组
-
subarray
public static <T> T[] subarray(T[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Type Parameters:
T- 对象- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static long[] subarray(long[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static int[] subarray(int[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static short[] subarray(short[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static char[] subarray(char[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static byte[] subarray(byte[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static double[] subarray(double[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static float[] subarray(float[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
subarray
public static boolean[] subarray(boolean[] array, int startIndex, int endIndex) 生成一个新的数组,其中包含元素开始索引取值至结束位置索引 开始索引包含,结束索引不包含,空数组输入产生空输出- Parameters:
array- 对象数组startIndex- 开始索引endIndex- 结束索引- Returns:
- 新数组
-
isSameLength
-
isSameLength
public static boolean isSameLength(long[] array1, long[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(int[] array1, int[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(short[] array1, short[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(char[] array1, char[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(byte[] array1, byte[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(double[] array1, double[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(float[] array1, float[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
isSameLength
public static boolean isSameLength(boolean[] array1, boolean[] array2) 检查两个数组是否相同长度- Parameters:
array1- 参数1array2- 参数2- Returns:
- 如果长度匹配返回true否则false
-
reverse
public static long[] reverse(long[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static long[] reverse(long[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static int[] reverse(int[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static int[] reverse(int[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static short[] reverse(short[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static short[] reverse(short[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static char[] reverse(char[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static char[] reverse(char[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static byte[] reverse(byte[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static byte[] reverse(byte[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static double[] reverse(double[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static double[] reverse(double[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static float[] reverse(float[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static float[] reverse(float[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
reverse
public static boolean[] reverse(boolean[] array) 反转数组,会变更原数组- Parameters:
array- 数组,会变更- Returns:
- 变更后的原数组
-
reverse
public static boolean[] reverse(boolean[] array, int startIndex, int endIndex) 反转数组,会变更原数组- Parameters:
array- 数组,会变更startIndex- 其实位置(包含)endIndex- 结束位置(不包含)- Returns:
- 变更后的原数组
-
swap
交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(long[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(int[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(short[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(char[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(byte[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(double[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(float[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(boolean[] array, int offset1, int offset2) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2
-
swap
public static void swap(boolean[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(byte[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(char[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(double[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(float[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(int[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(long[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
swap
public static void swap(short[] array, int offset1, int offset2, int len) 交换数组中连个位置的值- Parameters:
array- 数组offset1- 位置1offset2- 位置2len- 从给定索引开始交换的元素数量
-
shift
移位给定数组的顺序- Parameters:
array- 要移动的数组,可以为nulloffset- 旋转元素的位置数。如果偏移量大于*旋转的元素数,则有效偏移量将等于旋转的元素数
-
shift
public static void shift(long[] array, int offset) 移位给定长数组的顺序- Parameters:
array- 要移动的数组,可以为nulloffset- 旋转元素的位置数。如果偏移量大于*旋转的元素数,则有效偏移量将等于旋转的元素数
-
shift
public static void shift(int[] array, int offset) 移位给定int数组的顺序- Parameters:
array- 要移动的数组,可以为nulloffset- 旋转元素的位置数。如果偏移量大于*旋转的元素数,则有效偏移量将等于旋转的元素数
-
shift
public static void shift(short[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(char[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(byte[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(double[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(float[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(boolean[] array, int offset) 改变数组的顺序- Parameters:
array- 原数组offset- 偏移量
-
shift
public static void shift(boolean[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(byte[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(char[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(double[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(float[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(int[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(long[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
shift
public static void shift(short[] array, int startIndex, int endIndex, int offset) 改变数组的顺序- Parameters:
array- 原数组startIndex- 开始索引endIndex- 结束索引offset- 偏移量
-
indexOf
返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
contains
-
indexOf
public static int indexOf(long[] array, long value) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
public static int indexOf(long[] array, long value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(long[] array, long value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(long[] array, long value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(int[] array, int value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(int[] array, int value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(int[] array, int value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(short[] array, short value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(short[] array, short value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(short[] array, short value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(char[] array, char value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(char[] array, char value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(char[] array, char value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(byte[] array, byte value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(byte[] array, byte value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(byte[] array, byte value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(double[] array, double value, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素tolerance- 容差- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
public static int indexOf(double[] array, double value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
public static int indexOf(double[] array, double value, int index, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引tolerance- 容差- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(double[] array, double value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(double[] array, double value, double tolerance) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素tolerance- 容差- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(double[] array, double value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(double[] array, double value, int index, double tolerance) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引tolerance- 容差- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
contains
public static boolean contains(double[] array, double value) 数组中是否包含元素- Parameters:
array- 数组value- 被检查的元素- Returns:
- 是否包含
-
contains
public static boolean contains(double[] array, double value, double tolerance) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素tolerance- 容差- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
public static int indexOf(float[] array, float value) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
indexOf
public static int indexOf(float[] array, float value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(float[] array, float value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(float[] array, float value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- 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
-
indexOf
public static int indexOf(boolean[] array, boolean value, int index) 返回数组中指定元素所在位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(boolean[] array, boolean value) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
lastIndexOf
public static int lastIndexOf(boolean[] array, boolean value, int index) 返回数组中指定元素所在最后的位置,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素index- 索引- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
contains
public static boolean contains(boolean[] array, boolean value) 数组中是否包含元素- Parameters:
array- 数组value- 被检查的元素- Returns:
- 是否包含
-
toPrimitive
将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Character数组,可以是null- Returns:
char数组,null如果为空数组输入- Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象Character数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Character数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Character数组,null如果为空数组输入
-
toObject
将对象char数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-char数组,可以是null- Returns:
Character数组,null如果为空数组输入
-
toPrimitive
将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Long数组,可以是null- Returns:
long数组,null如果为空数组输入
-
toPrimitive
将对象Long数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Long数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Long数组,null如果为空数组输入
-
toObject
将对象long数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-long数组,可以是null- Returns:
Long数组,null如果为空数组输入
-
toPrimitive
将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Integer数组,可以是null- Returns:
int数组,null如果为空数组输入- Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象Integer数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Integer数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Integer数组,null如果为空数组输入
-
toObject
将对象int数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-int数组,可以是null- Returns:
Integer数组,null如果为空数组输入
-
toPrimitive
将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Short数组,可以是null- Returns:
short数组,null如果为空数组输入
-
toPrimitive
将对象Short数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Short数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Short数组,null如果为空数组输入
-
toObject
将对象short数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-short数组,可以是null- Returns:
Short数组,null如果为空数组输入
-
toPrimitive
将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Byte数组,可以是null- Returns:
byte数组,null如果为空数组输入- Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象Byte数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Byte数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Byte数组,null如果为空数组输入
-
toObject
将对象byte数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-byte数组,可以是null- Returns:
Byte数组,null如果为空数组输入
-
toPrimitive
将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Double数组,可以是null- Returns:
double数组,null如果为空数组输入- Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象Double数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Double数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
Double数组,null如果为空数组输入
-
toObject
将对象double数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-double数组,可以是null- Returns:
double数组,null如果为空数组输入
-
toPrimitive
将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Float数组,可以是null- Returns:
float数组,null如果为空数组输入- Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象Float数组转换为处理null的原始对象 此方法为null输入数组返回null- Parameters:
array-Float数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
float数组,null如果为空数组输入
-
toObject
将基元float组转换为对象 此方法为null输入数组返回null- Parameters:
array-float数组- Returns:
Float数组,null如果为空数组输入
-
toPrimitive
-
toPrimitive
将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null- Parameters:
array-Boolean数组,可以是null- Returns:
- 返回
boolean数组, 如果输入为null则为null - Throws:
NullPointerException- 如果数组内容是null
-
toPrimitive
将对象布尔值数组转换为处理null的原始的类型 此方法为null输入数组返回null- Parameters:
array-Boolean数组,可以是nullvalueForNull- 找到null时要插入的值- Returns:
- 返回
boolean数组, 如果输入为null则为null
-
toObject
将原始布尔值数组转换为对象 此方法为null输入数组返回null- Parameters:
array-boolean数组- Returns:
- 返回
boolean数组, 如果输入为null则为null
-
addAll
public static <T> T[] addAll(T[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(null, null) = null ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = [] ArrayKit.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
- Type Parameters:
T- 数组元素类型- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 T[]
-
addAll
public static byte[] addAll(byte[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 byte[]
-
addAll
public static boolean[] addAll(boolean[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 boolean[]
-
addAll
public static char[] addAll(char[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 char[]
-
addAll
public static short[] addAll(short[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 short[]
-
addAll
public static int[] addAll(int[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 int[]
-
addAll
public static long[] addAll(long[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 long[]
-
addAll
public static float[] addAll(float[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 float[]
-
addAll
public static double[] addAll(double[]... arrays) 将给定数组的所有元素添加到新数组中 忽略null数组,新数组包含arrays的所有元素ArrayKit.addAll(array1, null) = cloned copy of array1 ArrayKit.addAll(null, array2) = cloned copy of array2 ArrayKit.addAll([], []) = []
- Parameters:
arrays- 数组集合- Returns:
- 合并后的新数组 double[]
-
add
public static <T> T[] add(T[] array, T element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组, 其组件类型与元素相同,除非元素本身为空,否则返回类型为Object[]ArrayKit.add(null, null) = IllegalArgumentException ArrayKit.add(null, "a") = ["a"] ArrayKit.add(["a"], null) = ["a", null] ArrayKit.add(["a"], "b") = ["a", "b"] ArrayKit.add(["a", "b"], "c") = ["a", "b", "c"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要“add”元素的数组可以是nullelement- 要添加的对象可以是null- Returns:
- 包含现有元素的新数组加上返回的新元素数组类型将是输入数组的类型(除非为空), 在这种情况下,它将具有与元素相同的类型。如果两者都为空,则抛出IllegalArgumentException
- Throws:
IllegalArgumentException- 如果两个参数都为空
-
add
public static boolean[] add(boolean[] array, boolean element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, true) = [true] ArrayKit.add([true], false) = [true, false] ArrayKit.add([true, false], true) = [true, false, true]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static byte[] add(byte[] array, byte element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static char[] add(char[] array, char element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, '0') = ['0'] ArrayKit.add(['1'], '0') = ['1', '0'] ArrayKit.add(['1', '0'], '1') = ['1', '0', '1']
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static double[] add(double[] array, double element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static float[] add(float[] array, float element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static int[] add(int[] array, int element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static long[] add(long[] array, long element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static short[] add(short[] array, short element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0) = [0] ArrayKit.add([1], 0) = [1, 0] ArrayKit.add([1, 0], 1) = [1, 0, 1]
- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static <T> T[] add(T[] array, int index, T element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0, null) = IllegalArgumentException ArrayKit.add(null, 0, "a") = ["a"] ArrayKit.add(["a"], 1, null) = ["a", null] ArrayKit.add(["a"], 1, "b") = ["a", "b"] ArrayKit.add(["a", "b"], 3, "c") = ["a", "b", "c"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static boolean[] add(boolean[] array, int index, boolean element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0, true) = [true] ArrayKit.add([true], 0, false) = [false, true] ArrayKit.add([false], 1, true) = [false, true] ArrayKit.add([true, false], 1, true) = [true, true, false]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static char[] add(char[] array, int index, char element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add(null, 0, 'a') = ['a'] ArrayKit.add(['a'], 0, 'b') = ['b', 'a'] ArrayKit.add(['a', 'b'], 0, 'c') = ['c', 'a', 'b'] ArrayKit.add(['a', 'b'], 1, 'k') = ['a', 'k', 'b'] ArrayKit.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static byte[] add(byte[] array, int index, byte element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1], 0, 2) = [2, 1] ArrayKit.add([2, 6], 2, 3) = [2, 6, 3] ArrayKit.add([2, 6], 0, 1) = [1, 2, 6] ArrayKit.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static short[] add(short[] array, int index, short element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1], 0, 2) = [2, 1] ArrayKit.add([2, 6], 2, 10) = [2, 6, 10] ArrayKit.add([2, 6], 0, -4) = [-4, 2, 6] ArrayKit.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static int[] add(int[] array, int index, int element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1], 0, 2) = [2, 1] ArrayKit.add([2, 6], 2, 10) = [2, 6, 10] ArrayKit.add([2, 6], 0, -4) = [-4, 2, 6] ArrayKit.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static long[] add(long[] array, int index, long element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1L], 0, 2L) = [2L, 1L] ArrayKit.add([2L, 6L], 2, 10L) = [2L, 6L, 10L] ArrayKit.add([2L, 6L], 0, -4L) = [-4L, 2L, 6L] ArrayKit.add([2L, 6L, 3L], 2, 1L) = [2L, 6L, 1L, 3L]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static float[] add(float[] array, int index, float element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1.1f], 0, 2.2f) = [2.2f, 1.1f] ArrayKit.add([2.3f, 6.4f], 2, 10.5f) = [2.3f, 6.4f, 10.5f] ArrayKit.add([2.6f, 6.7f], 0, -4.8f) = [-4.8f, 2.6f, 6.7f] ArrayKit.add([2.9f, 6.0f, 0.3f], 2, 1.0f) = [2.9f, 6.0f, 1.0f, 0.3f]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
add
public static double[] add(double[] array, int index, double element) 复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null,则返回一个新元素数组,其组件类型与元素相同.ArrayKit.add([1.1], 0, 2.2) = [2.2, 1.1] ArrayKit.add([2.3, 6.4], 2, 10.5) = [2.3, 6.4, 10.5] ArrayKit.add([2.6, 6.7], 0, -4.8) = [-4.8, 2.6, 6.7] ArrayKit.add([2.9, 6.0, 0.3], 2, 1.0) = [2.9, 6.0, 1.0, 0.3]
- Parameters:
array- 要复制并添加元素的数组可以是nullindex- 新对象的位置element- 要在新数组的最后一个索引处添加的对象- Returns:
- 包含现有元素和新元素的新数组
-
remove
public static <T> T[] remove(T[] array) 去重数组中的元素,去重后生成新的数组,原数组不变 此方法通过LinkedHashSet去重- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组- Returns:
- 去重后的数组
-
remove
public static <T> T[] remove(T[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove(["a"], 0) = [] ArrayKit.remove(["a", "b"], 0) = ["b"] ArrayKit.remove(["a", "b"], 1) = ["a"] ArrayKit.remove(["a", "b", "c"], 1) = ["a", "c"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要从中删除的元素index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
去重数组中的元素,去重后生成新的数组,原数组不变 此方法通过LinkedHashSet去重- Type Parameters:
T- 数组元素类型K- 唯一键类型- Parameters:
array- 数组uniqueGenerator- 唯一键生成器override- 是否覆盖模式,如果为true,加入的新值会覆盖相同key的旧值,否则会忽略新加值- Returns:
- 去重后的数组
-
removeElement
从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, "a") = null ArrayKit.removeElement([], "a") = [] ArrayKit.removeElement(["a"], "b") = ["a"] ArrayKit.removeElement(["a", "b"], "a") = ["b"] ArrayKit.removeElement(["a", "b", "a"], "a") = ["b", "a"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要复制并添加元素的数组可以是nullelement- 要在新数组的最后一个索引处添加的对象- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static boolean[] remove(boolean[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([true], 0) = [] ArrayKit.remove([true, false], 0) = [false] ArrayKit.remove([true, false], 1) = [true] ArrayKit.remove([true, true, false], 1) = [true, false]
- Parameters:
array- 要从中删除的元素index- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static boolean[] removeElement(boolean[] array, boolean element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, true) = null ArrayKit.removeElement([], true) = [] ArrayKit.removeElement([true], false) = [true] ArrayKit.removeElement([true, false], false) = [true] ArrayKit.removeElement([true, false, true], true) = [false, true]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static byte[] remove(byte[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1], 0) = [] ArrayKit.remove([1, 0], 0) = [0] ArrayKit.remove([1, 0], 1) = [1] ArrayKit.remove([1, 0, 1], 1) = [1, 1]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static byte[] removeElement(byte[] array, byte element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1) = null ArrayKit.removeElement([], 1) = [] ArrayKit.removeElement([1], 0) = [1] ArrayKit.removeElement([1, 0], 0) = [1] ArrayKit.removeElement([1, 0, 1], 1) = [0, 1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static char[] remove(char[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove(['a'], 0) = [] ArrayKit.remove(['a', 'b'], 0) = ['b'] ArrayKit.remove(['a', 'b'], 1) = ['a'] ArrayKit.remove(['a', 'b', 'c'], 1) = ['a', 'c']
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素..
-
removeElement
public static char[] removeElement(char[] array, char element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 'a') = null ArrayKit.removeElement([], 'a') = [] ArrayKit.removeElement(['a'], 'b') = ['a'] ArrayKit.removeElement(['a', 'b'], 'a') = ['b'] ArrayKit.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static double[] remove(double[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1.1], 0) = [] ArrayKit.remove([2.5, 6.0], 0) = [6.0] ArrayKit.remove([2.5, 6.0], 1) = [2.5] ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static double[] removeElement(double[] array, double element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1.1) = null ArrayKit.removeElement([], 1.1) = [] ArrayKit.removeElement([1.1], 1.2) = [1.1] ArrayKit.removeElement([1.1, 2.3], 1.1) = [2.3] ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static float[] remove(float[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1.1], 0) = [] ArrayKit.remove([2.5, 6.0], 0) = [6.0] ArrayKit.remove([2.5, 6.0], 1) = [2.5] ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static float[] removeElement(float[] array, float element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1.1) = null ArrayKit.removeElement([], 1.1) = [] ArrayKit.removeElement([1.1], 1.2) = [1.1] ArrayKit.removeElement([1.1, 2.3], 1.1) = [2.3] ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static int[] remove(int[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1], 0) = [] ArrayKit.remove([2, 6], 0) = [6] ArrayKit.remove([2, 6], 1) = [2] ArrayKit.remove([2, 6, 3], 1) = [2, 3]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static int[] removeElement(int[] array, int element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1) = null ArrayKit.removeElement([], 1) = [] ArrayKit.removeElement([1], 2) = [1] ArrayKit.removeElement([1, 3], 1) = [3] ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static long[] remove(long[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1], 0) = [] ArrayKit.remove([2, 6], 0) = [6] ArrayKit.remove([2, 6], 1) = [2] ArrayKit.remove([2, 6, 3], 1) = [2, 3]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static long[] removeElement(long[] array, long element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1) = null ArrayKit.removeElement([], 1) = [] ArrayKit.removeElement([1], 2) = [1] ArrayKit.removeElement([1, 3], 1) = [3] ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
remove
public static short[] remove(short[] array, int index) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.remove([1], 0) = [] ArrayKit.remove([2, 6], 0) = [6] ArrayKit.remove([2, 6], 1) = [2] ArrayKit.remove([2, 6, 3], 1) = [2, 3]
- Parameters:
array- 要从中移除元素的数组index- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeElement
public static short[] removeElement(short[] array, short element) 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组,除了指定位置上的元素外,该数组具有与输入数组相同的元素 如果是null,则会抛出IndexOutOfBoundsException,无法指定有效的索引ArrayKit.removeElement(null, 1) = null ArrayKit.removeElement([], 1) = [] ArrayKit.removeElement([1], 2) = [1] ArrayKit.removeElement([1, 3], 1) = [3] ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
- Parameters:
array- 要从中移除元素的数组element- 要删除的元素- Returns:
- 一个新数组,包含指定位置的元素以外的现有元素.
-
removeAll
public static <T> T[] removeAll(T[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll(["a", "b", "c"], 0, 2) = ["b"] ArrayKit.removeAll(["a", "b", "c"], 1, 2) = ["a"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static <T> T[] removeElements(T[] array, T... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, "a", "b") = null ArrayKit.removeElements([], "a", "b") = [] ArrayKit.removeElements(["a"], "b", "c") = ["a"] ArrayKit.removeElements(["a", "b"], "a", "c") = ["b"] ArrayKit.removeElements(["a", "b", "a"], "a") = ["b", "a"] ArrayKit.removeElements(["a", "b", "a"], "a", "a") = ["b"]
- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static byte[] removeAll(byte[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static byte[] removeElements(byte[] array, byte... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static short[] removeAll(short[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static short[] removeElements(short[] array, short... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static int[] removeAll(int[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static int[] removeElements(int[] array, int... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移. 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static char[] removeAll(char[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static char[] removeElements(char[] array, char... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static long[] removeAll(long[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static long[] removeElements(long[] array, long... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static float[] removeAll(float[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static float[] removeElements(float[] array, float... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改 返回数组的组件类型始终与输入数组的组件类型相同ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static double[] removeAll(double[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([1], 0) = [] ArrayKit.removeAll([2, 6], 0) = [6] ArrayKit.removeAll([2, 6], 0, 1) = [] ArrayKit.removeAll([2, 6, 3], 1, 2) = [2] ArrayKit.removeAll([2, 6, 3], 0, 2) = [6] ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeElements
public static double[] removeElements(double[] array, double... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, 1, 2) = null ArrayKit.removeElements([], 1, 2) = [] ArrayKit.removeElements([1], 2, 3) = [1] ArrayKit.removeElements([1, 3], 1, 2) = [3] ArrayKit.removeElements([1, 3, 1], 1) = [3, 1] ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
removeAll
public static boolean[] removeAll(boolean[] array, int... indices) 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动 返回数组的组件类型始终与输入数组的组件类型相同 此方法返回一个新数组,该数组具有与输入数组相同的元素ArrayKit.removeAll([true, false, true], 0, 2) = [false] ArrayKit.removeAll([true, false, true], 1, 2) = [true]
- Parameters:
array- 要从中删除元素的数组可能不是nullindices- 要删除的元素的位置- Returns:
- 一个新数组,包含指定位置之外的现有元素
-
removeElements
public static boolean[] removeElements(boolean[] array, boolean... values) 从指定数组中移除指定数量*的指定元素。所有后续元素都左移 对于指定的要删除的元素,其数量大于原始数组中包含的数量, 除了删除现有的匹配项外,不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.ArrayKit.removeElements(null, true, false) = null ArrayKit.removeElements([], true, false) = [] ArrayKit.removeElements([true], false, false) = [true] ArrayKit.removeElements([true, false], true, true) = [false] ArrayKit.removeElements([true, false, true], true) = [false, true] ArrayKit.removeElements([true, false, true], true, true) = [false]
- Parameters:
array- 要从中删除元素的数组可能不是nullvalues- 要删除的元素- Returns:
- 一个新数组,包含指定位置之外的现有元素.
-
isSorted
该方法检查提供的数组是否按照类的compareTo方法排序.- Type Parameters:
T- 要检查数组的数据类型,必须实现Comparable- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
该方法检查提供的数组是否按照提供的Comparator排序.- Type Parameters:
T- 数组的数据类型- Parameters:
array- 要检查的数组comparator- 要比较的Comparator- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(int[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(long[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(short[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(double[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(float[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(byte[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(char[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
isSorted
public static boolean isSorted(boolean[] array) 该方法检查提供的数组是否按照提供的Comparator排序.- Parameters:
array- 要检查的数组- Returns:
- 数组是否已排序
-
removeAllOccurences
public static boolean[] removeAllOccurences(boolean[] array, boolean element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static char[] removeAllOccurences(char[] array, char element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static byte[] removeAllOccurences(byte[] array, byte element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static short[] removeAllOccurences(short[] array, short element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static int[] removeAllOccurences(int[] array, int element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static long[] removeAllOccurences(long[] array, long element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static float[] removeAllOccurences(float[] array, float element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static double[] removeAllOccurences(double[] array, double element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
removeAllOccurences
public static <T> T[] removeAllOccurences(T[] array, T element) 从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素,则不会从数组中删除任何元素. 如果输入的数组是null,则返回的是null- Type Parameters:
T- 对象- Parameters:
array- 输入数组element- 要删除的元素- Returns:
- 一个新数组,包含除指定元素之外的现有元素.
-
toStringArray
-
toStringArray
-
insert
public static <T> T[] insert(T[] buffer, int index, T... newElements) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组,不影响原数组 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 已有数组index- 插入位置,此位置为对应此位置元素之前的空档newElements- 新元素- Returns:
- 新数组
-
insert
public static <A,T> A insert(A array, int index, T... newElements) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新的数组,不影响原数组 如果插入位置为为负数,从原数组从后向前计数,若大于原数组长度,则空白处用null填充- Type Parameters:
A- 泛型对象T- 数组元素类型- Parameters:
array- 已有数组index- 插入位置,此位置为对应此位置元素之前的空档newElements- 新元素- Returns:
- 新数组
-
insert
public static boolean[] insert(int index, boolean[] array, boolean... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static byte[] insert(int index, byte[] array, byte... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static char[] insert(int index, char[] array, char... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static double[] insert(int index, double[] array, double... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static float[] insert(int index, float[] array, float... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static int[] insert(int index, int[] array, int... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static long[] insert(int index, long[] array, long... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static short[] insert(int index, short[] array, short... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
insert
public static <T> T[] insert(int index, T[] array, T... values) 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时,它总是一个新的数组ArrayKit.insert(index, null, null) = null ArrayKit.insert(index, array, null) = cloned copy of 'array' ArrayKit.insert(index, null, values) = null
- Type Parameters:
T- 对象- Parameters:
index- 插入位置,此位置为对应此位置元素之前的空档array- 已有数组values- 要插入的新值可以是null- Returns:
- 新数组
-
shuffle
-
shuffle
-
shuffle
public static void shuffle(boolean[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(byte[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(char[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(short[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(int[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(long[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(float[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
shuffle
public static void shuffle(double[] array) 使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组
-
shuffle
使用Fisher-Yates算法随机遍历指定数组的元素.- Parameters:
array- 要洗牌的数组random- 用于排列元素的随机性的来源
-
newArray
新建一个空数组- Type Parameters:
T- 数组元素类型- Parameters:
componentType- 元素类型newSize- 大小- Returns:
- 空数组
-
newArray
public static <T> T[] newArray(int newSize) 新建一个空数组- Type Parameters:
T- 数组元素类型- Parameters:
newSize- 大小- Returns:
- 空数组
-
newArray
强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组- Parameters:
type- 数组类型或数组元素类型arrayObj- 原数组- Returns:
- 转换后的数组类型
- Throws:
NullPointerException- 提供参数为空IllegalArgumentException- 参数arrayObj不是数组
-
getComponentType
-
getComponentType
-
getArrayType
-
append
public static <T> T[] append(T[] buffer, T... newElements) 将新元素添加到已有数组中 添加新元素会生成一个新的数组,不影响原数组- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 已有数组newElements- 新元素- Returns:
- 新数组
-
append
-
setOrAppend
public static <T> T[] setOrAppend(T[] buffer, int index, T value) 将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 已有数组index- 位置,大于长度追加,否则替换value- 新值- Returns:
- 新数组或原有数组
-
setOrAppend
-
replace
public static <T> T[] replace(T[] buffer, int index, T... values) 将新元素插入到到已有数组中的某个位置 添加新元素会生成一个新数组或原有数组 如果插入位置为为负数,那么生成一个由插入元素顺序加已有数组顺序的新数组- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 已有数组index- 位置,大于长度追加,否则替换,<0表示从头部追加values- 新值- Returns:
- 新数组或原有数组
-
resize
生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 原数组newSize- 新的数组大小componentType- 数组元素类型- Returns:
- 调整后的新数组
-
resize
public static <T> T[] resize(T[] buffer, int newSize) 生成一个新的重新设置大小的数组 新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,缩小则截断- Type Parameters:
T- 数组元素类型- Parameters:
buffer- 原数组newSize- 新的数组大小- Returns:
- 调整后的新数组
-
resize
public static byte[] resize(byte[] bytes, int newSize) 生成一个新的重新设置大小的数组 调整大小后拷贝原数组到新数组下 扩大则占位前N个位置,其它位置补充0,缩小则截断- Parameters:
bytes- 原数组newSize- 新的数组大小- Returns:
- 调整后的新数组
-
copy
- Parameters:
src- 源数组srcPos- 源数组开始位置dest- 目标数组destPos- 目标数组开始位置length- 拷贝数组长度- Returns:
- 目标数组
-
copy
包装System.arraycopy(Object, int, Object, int, int)数组复制,缘数组和目标数组都是从位置0开始复制- Parameters:
src- 源数组dest- 目标数组length- 拷贝数组长度- Returns:
- 目标数组
-
range
public static int[] range(int excludedEnd) 生成一个从0开始的数字列表- Parameters:
excludedEnd- 结束的数字(不包含)- Returns:
- 数字列表
-
range
public static int[] range(int includedStart, int excludedEnd) 生成一个数字列表 自动判定正序反序- Parameters:
includedStart- 开始的数字(包含)excludedEnd- 结束的数字(不包含)- Returns:
- 数字列表
-
range
public static int[] range(int includedStart, int excludedEnd, int step) 生成一个数字列表 自动判定正序反序- Parameters:
includedStart- 开始的数字(包含)excludedEnd- 结束的数字(不包含)step- 步进- Returns:
- 数字列表
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
将原始类型数组包装为包装类型- Parameters:
values- 原始类型数组- Returns:
- 包装类型数组
-
unWrap
包装类数组转为原始类型数组- Parameters:
values- 包装类型数组- Returns:
- 原始类型数组
-
wrap
包装数组对象- Parameters:
object- 对象,可以是对象数组或者基本类型数组- Returns:
- 包装类型数组或对象数组
- Throws:
InternalException- 对象为非数组
-
get
获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组对象index- 下标,支持负数- Returns:
- 值
-
get
获取数组中指定多个下标元素值,组成新数组- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组indexes- 下标列表- Returns:
- 结果
-
sub
public static <T> T[] sub(T[] array, int start, int end) 获取子数组- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static byte[] sub(byte[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static int[] sub(int[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static long[] sub(long[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static short[] sub(short[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static char[] sub(char[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static double[] sub(double[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static float[] sub(float[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
public static boolean[] sub(boolean[] array, int start, int end) 获取子数组- Parameters:
array- 数组start- 开始位置(包括)end- 结束位置(不包括)- Returns:
- 新的数组
- See Also:
-
sub
-
sub
-
join
以 conjunction 为分隔符将多个对象转换为字符串- Parameters:
conjunction- 分隔符Symbol.COMMAargs- 数组- Returns:
- 连接后的字符串
-
join
以 conjunction 为分隔符将数组转换为字符串- Type Parameters:
T- 被处理的集合- Parameters:
array- 数组conjunction- 分隔符- Returns:
- 连接后的字符串
-
join
以 conjunction 为分隔符将数组转换为字符串- Type Parameters:
T- 被处理的集合- Parameters:
array- 数组delimiter- 分隔符prefix- 每个元素添加的前缀,null表示不添加suffix- 每个元素添加的后缀,null表示不添加- Returns:
- 连接后的字符串
-
join
以 conjunction 为分隔符将数组转换为字符串- Type Parameters:
T- 被处理的集合- Parameters:
array- 数组conjunction- 分隔符editor- 每个元素的编辑器,null表示不编辑- 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:
- 最小值
-
min
取最小值- Type Parameters:
T- 元素类型- Parameters:
numberArray- 数字数组- Returns:
- 最小值
-
min
取最小值- Type Parameters:
T- 元素类型- Parameters:
numberArray- 数字数组comparator- 比较器,null按照默认比较- 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:
- 最大值
-
max
取最大值- Type Parameters:
T- 元素类型- Parameters:
numberArray- 数字数组- Returns:
- 最大值
-
max
取最大值- Type Parameters:
T- 元素类型- Parameters:
numberArray- 数字数组comparator- 比较器,null表示默认比较器- Returns:
- 最大值
-
filter
过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能:1、过滤出需要的对象,如果返回null表示这个元素对象抛弃 2、修改元素对象,返回集合中为修改后的对象
- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组editor- 编辑器接口- Returns:
- 过滤后的数组
-
filter
过滤 过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能:- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组filter- 过滤器接口,用于定义过滤规则- Returns:
- 过滤后的数组
-
zip
映射键值(参考Python的zip()函数),返回Map无序 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分- Type Parameters:
K- Key类型V- Value类型- Parameters:
keys- 键列表values- 值列表- Returns:
- Map
-
zip
映射键值(参考Python的zip()函数) 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分- Type Parameters:
K- Key类型V- Value类型- Parameters:
keys- 键列表values- 值列表isOrder- 是否有序- Returns:
- Map
-
isSameType
检查两个数组是否为同一类型- Parameters:
array1- 第1个数组不能是nullarray2- 第2个数组不能是null- Returns:
- 如果数组类型匹配,则为
true - Throws:
IllegalArgumentException- 如果其中一个数组是null
-
indexOfIgnoreCase
返回数组中指定元素所在位置,忽略大小写,未找到返回Normal.__1- Parameters:
array- 数组value- 被检查的元素- Returns:
- 数组中指定元素所在位置, 未找到返回
Normal.__1
-
isArrayIndexValid
public static <T> boolean isArrayIndexValid(T[] array, int index) 返回是否可以在给定索引处安全地访问给定数组- Type Parameters:
T- 数组的组件类型- Parameters:
array- 要检查的数组可能为空index- 要检查的数组的索引- Returns:
- 给定索引在给定数组中是否可安全访问
-
containsIgnoreCase
数组中是否包含元素,忽略大小写- Parameters:
array- 数组value- 被检查的元素- Returns:
- 是否包含
-
containsAny
public static <T> boolean containsAny(T[] array, T... values) 数组中是否包含指定元素中的任意一个- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组values- 被检查的多个元素- Returns:
- 是否包含指定元素中的任意一个
-
containsAll
public static <T> boolean containsAll(T[] array, T... values) 数组中是否包含指定元素中的全部- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组values- 被检查的多个元素- Returns:
- 是否包含指定元素中的全部
-
getLength
返回指定数组的长度ArrayKit.getLength(null) = 0 ArrayKit.getLength([]) = 0 ArrayKit.getLength([null]) = 1 ArrayKit.getLength([true, false]) = 2 ArrayKit.getLength([1, 2, 3]) = 3 ArrayKit.getLength(["a", "b", "c"]) = 3
- Parameters:
array- 要从中检索长度的数组可以为空- Returns:
- 数组的长度,如果数组是
null,则为0 - Throws:
IllegalArgumentException- 如果对象参数不是数组
-
hashCode
获得一个数组哈希码,用于正确处理多维数组 多维基元数组也可以用该方法正确处理- Parameters:
array- 数组- Returns:
- 返回数组的哈希码
-
cast
public static Object[] cast(Class<?> type, Object arrayObj) throws NullPointerException, IllegalArgumentException 强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组- Parameters:
type- 数组类型或数组元素类型arrayObj- 原数组- Returns:
- 转换后的数组类型
- Throws:
NullPointerException- 提供参数为空IllegalArgumentException- 参数arrayObj不是数组
-
map
-
map
-
map
-
mapToSet
-
equals
-
isSub
public static <T> boolean isSub(T[] array, T[] subArray) 查找子数组的位置- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组subArray- 子数组- Returns:
- 子数组的开始位置,即子数字第一个元素在数组中的位置
-
indexOfSub
public static <T> int indexOfSub(T[] array, T[] subArray) 查找子数组的位置- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组subArray- 子数组- Returns:
- 子数组的开始位置,即子数字第一个元素在数组中的位置
-
lastIndexOfSub
public static <T> int lastIndexOfSub(T[] array, T[] subArray) 查找最后一个子数组的开始位置- Type Parameters:
T- 数组元素类型- Parameters:
array- 数组subArray- 子数组- Returns:
- 最后一个子数组的开始位置,即子数字第一个元素在数组中的位置
-
length
获取数组长度 如果参数为null,返回0ArrayKit.length(null) = 0 ArrayKit.length([]) = 0 ArrayKit.length([null]) = 1 ArrayKit.length([true, false]) = 2 ArrayKit.length([1, 2, 3]) = 3 ArrayKit.length(["a", "b", "c"]) = 3
- Parameters:
array- 数组对象- Returns:
- 数组长度
- Throws:
IllegalArgumentException- 如果参数不为数组,抛出此异常- See Also:
-