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

Class ArrayValidator

java.lang.Object

org.miaixz.bus.core.center.array.ArrayValidator

Direct Known Subclasses:

PrimitiveArray

public class ArrayValidator
extends Object

Array检查工具类，提供字对象的blank和empty等检查

• empty定义：null or 空字对象：""
• blank定义：null or 空字对象："" or 空格、全角空格、制表符、换行符，等不可见字符

Since:

Java 17+

Author:

Kimi Liu

Constructor Summary

Constructors

Constructor	Description
ArrayValidator()

Method Summary

Modifier and Type	Method	Description
static <T> T[]	defaultIfEmpty(T[] array, T[] defaultArray)	如果给定数组为空，返回默认数组
static int	emptyCount(Object... args)	计算null或空元素对象的个数，通过ObjectValidator.isEmpty(Object) 判断元素
static <T> T	firstMatch(Predicate<T> matcher, T... array)	返回数组中第一个匹配规则的值
static <T> T	firstNonNull(T... array)	返回数组中第一个非空元素
static boolean	hasBlank(CharSequence... args)	指定字符串数组中，是否包含空字符串。
static <T> boolean	hasEmpty(T[] args)	是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
static <T> boolean	hasEmptyVarargs(T... args)	是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
static <T> boolean	hasNonNull(T... array)	是否包含非null元素
static <T> boolean	hasNull(T... array)	是否包含null元素
static <T> int	indexOf(T[] array, Object value)	返回数组中指定元素所在位置，未找到返回Normal.__1
static <T> int	indexOf(T[] array, Object value, int beginIndexInclude)	返回数组中指定元素所在位置，未找到返回Normal.__1
static int	indexOfIgnoreCase(CharSequence[] array, CharSequence value)	返回数组中指定元素所在位置，忽略大小写，未找到返回Normal.__1
static <T> int	indexOfSub(T[] array, int beginInclude, T[] subArray)	查找子数组的位置
static <T> int	indexOfSub(T[] array, T[] subArray)	查找子数组的位置
static boolean	isAllBlank(CharSequence... args)	指定字符串数组中的元素，是否全部为空字符串。
static <T> boolean	isAllEmpty(T[] args)	是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素 如果提供的数组本身为空，则返回true
static <T> boolean	isAllEmptyVarargs(T... args)	是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
static boolean	isAllNotBlank(CharSequence... args)	是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
static boolean	isAllNotEmpty(Object... args)	是否所有元素都不为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
static <T> boolean	isAllNotNull(T... array)	是否所有元素都不为 null
static <T> boolean	isAllNull(T... array)	所有字段是否全为null
static boolean	isArray(Object object)	对象是否为数组对象
static boolean	isEmpty(boolean[] array)	数组是否为空
static boolean	isEmpty(byte[] array)	数组是否为空
static boolean	isEmpty(char[] array)	数组是否为空
static boolean	isEmpty(double[] array)	数组是否为空
static boolean	isEmpty(float[] array)	数组是否为空
static boolean	isEmpty(int[] array)	数组是否为空
static boolean	isEmpty(long[] array)	数组是否为空
static boolean	isEmpty(short[] array)	数组是否为空
static boolean	isEmpty(Object array)	数组是否为空 此方法会匹配单一对象，如果此对象为null则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0的情况下返回false，否则返回true
static <T> boolean	isEmpty(T[] array)	数组是否为空
static boolean	isNotEmpty(boolean[] array)	数组是否为非空
static boolean	isNotEmpty(byte[] array)	数组是否为非空
static boolean	isNotEmpty(char[] array)	数组是否为非空
static boolean	isNotEmpty(double[] array)	数组是否为非空
static boolean	isNotEmpty(float[] array)	数组是否为非空
static boolean	isNotEmpty(int[] array)	数组是否为非空
static boolean	isNotEmpty(long[] array)	数组是否为非空
static boolean	isNotEmpty(short[] array)	数组是否为非空
static boolean	isNotEmpty(Object array)	数组是否为非空 此方法会匹配单一对象，如果此对象为null则返回false 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true 如果此对象为数组对象，数组长度大于0的情况下返回true，否则返回false
static <T> boolean	isNotEmpty(T[] array)	数组是否为非空
static <T extends Comparable<? super T>> boolean	isSorted(T[] array)	检查数组是否有序，升序或者降序
static <T> boolean	isSorted(T[] array, Comparator<? super T> comparator)	检查数组是否有序，升序或者降序，使用指定比较器比较
static boolean	isSortedASC(byte[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(char[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(double[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(float[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(int[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(long[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static boolean	isSortedASC(short[] array)	检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
static <T extends Comparable<? super T>> boolean	isSortedASC(T[] array)	检查数组是否升序，即 array[i].compareTo(array[i + 1]) <= 0
static <T> boolean	isSortedASC(T[] array, Comparator<? super T> comparator)	检查数组是否升序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) <= 0
static boolean	isSortedDESC(byte[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(char[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(double[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(float[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(int[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(long[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static boolean	isSortedDESC(short[] array)	检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
static <T extends Comparable<? super T>> boolean	isSortedDESC(T[] array)	检查数组是否降序，即 array[i].compareTo(array[i + 1]) >= 0
static <T> boolean	isSortedDESC(T[] array, Comparator<? super T> comparator)	检查数组是否降序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) >= 0
static <T> boolean	isSub(T[] array, T[] subArray)	是否是数组的子数组
static boolean	isSubEquals(byte[] array, int offset, byte... subArray)	是否局部匹配，相当于对比以下子串是否相等
static <T> int	lastIndexOf(T[] array, Object value)	返回数组中指定元素最后的所在位置，未找到返回Normal.__1
static <T> int	lastIndexOf(T[] array, Object value, int endInclude)	返回数组中指定元素最后的所在位置，未找到返回Normal.__1
static int	length(Object array)	获取数组长度 如果参数为null，返回0
static <E> int	matchIndex(int beginIndexInclude, Predicate<E> matcher, E... array)	返回数组中第一个匹配规则的值的位置
static <T> int	matchIndex(Predicate<T> matcher, T... array)	返回数组中第一个匹配规则的值的位置
static boolean	regionMatches(byte[] array1, int offset1, byte[] array2, int offset2, int length)	是否局部匹配，相当于对比以下子串是否相等
static String	toString(Object object)	数组或集合转String

Methods inherited from class java.lang.Object

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

Constructor Details

ArrayValidator

public ArrayValidator()

Method Details

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

是否为非空

isArray

public static boolean isArray(Object object)

对象是否为数组对象

Parameters:

object - 对象

Returns:

是否为数组对象，如果为null 返回false

hasBlank

public static boolean hasBlank(CharSequence... args)

指定字符串数组中，是否包含空字符串。

如果指定的字符串数组的长度为 0，或者其中的任意一个元素是空字符串，则返回 true。

• hasBlank() // true
• hasBlank("", null, " ") // true
• hasBlank("123", " ") // true
• hasBlank("123", "abc") // false

注意：该方法与 isAllBlank(CharSequence...) 的区别在于：

• hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
• isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...

Parameters:

args - 字符串列表

Returns:

是否包含空字符串

isAllNotBlank

public static boolean isAllNotBlank(CharSequence... args)

是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素

Parameters:

args - 被检查的对象,一个或者多个

Returns:

是否都不为空

isAllBlank

public static boolean isAllBlank(CharSequence... args)

指定字符串数组中的元素，是否全部为空字符串。

如果指定的字符串数组的长度为 0，或者所有元素都是空字符串，则返回 true。

• isAllBlank() // true
• isAllBlank("", null, " ") // true
• isAllBlank("123", " ") // false
• isAllBlank("123", "abc") // false

注意：该方法与 hasBlank(CharSequence...) 的区别在于：

• hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
• isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...

Parameters:

args - 字符串列表

Returns:

所有字符串是否为空白

isEmpty

public static <T> boolean isEmpty(T[] array)

数组是否为空

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

是否为空

defaultIfEmpty

public static <T> T[] defaultIfEmpty(T[] array,
 T[] defaultArray)

如果给定数组为空，返回默认数组

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

defaultArray - 默认数组

Returns:

非空（empty）的原数组或默认数组

isEmpty

public static boolean isEmpty(Object array)

数组是否为空 此方法会匹配单一对象，如果此对象为null则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0的情况下返回false，否则返回true

Parameters:

array - 数组

Returns:

是否为空

isNotEmpty

public static <T> boolean isNotEmpty(T[] array)

数组是否为非空

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

是否为非空

isNotEmpty

public static boolean isNotEmpty(Object array)

数组是否为非空 此方法会匹配单一对象，如果此对象为null则返回false 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true 如果此对象为数组对象，数组长度大于0的情况下返回true，否则返回false

Parameters:

array - 数组

Returns:

是否为非空

isSorted

public static <T> boolean isSorted(T[] array,
 Comparator<? super T> comparator)

检查数组是否有序，升序或者降序，使用指定比较器比较

若传入空数组或空比较器，则返回false；元素全部相等，返回 true

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

comparator - 比较器，需要自己处理null值比较

Returns:

数组是否有序

isSorted

public static <T extends Comparable<? super T>>
boolean isSorted(T[] array)

检查数组是否有序，升序或者降序

若传入空数组，则返回false；元素全部相等，返回 true

Type Parameters:

T - 数组元素类型，该类型需要实现Comparable接口

Parameters:

array - 数组

Returns:

数组是否有序

Throws:

NullPointerException - 如果数组元素含有null值

isSortedASC

public static boolean isSortedASC(byte[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(byte[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(short[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(short[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(char[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(char[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(int[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(int[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(long[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(long[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(double[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(double[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static boolean isSortedASC(float[] array)

检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否升序

isSortedDESC

public static boolean isSortedDESC(float[] array)

检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false

Parameters:

array - 数组

Returns:

数组是否降序

isSortedASC

public static <T extends Comparable<? super T>>
boolean isSortedASC(T[] array)

检查数组是否升序，即 array[i].compareTo(array[i + 1]) <= 0

若传入空数组，则返回false

Type Parameters:

T - 数组元素类型，该类型需要实现Comparable接口

Parameters:

array - 数组

Returns:

数组是否升序

Throws:

NullPointerException - 如果数组元素含有null值

isSortedDESC

public static <T extends Comparable<? super T>>
boolean isSortedDESC(T[] array)

检查数组是否降序，即 array[i].compareTo(array[i + 1]) >= 0

若传入空数组，则返回false

Type Parameters:

T - 数组元素类型，该类型需要实现Comparable接口

Parameters:

array - 数组

Returns:

数组是否降序

Throws:

NullPointerException - 如果数组元素含有null值

isSortedASC

public static <T> boolean isSortedASC(T[] array,
 Comparator<? super T> comparator)

检查数组是否升序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) <= 0

若传入空数组或空比较器，则返回false

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

comparator - 比较器，需要自己处理null值比较

Returns:

数组是否升序

isSortedDESC

public static <T> boolean isSortedDESC(T[] array,
 Comparator<? super T> comparator)

检查数组是否降序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) >= 0

若传入空数组或空比较器，则返回false

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

comparator - 比较器，需要自己处理null值比较

Returns:

数组是否降序

isAllEmpty

public static <T> boolean isAllEmpty(T[] args)

是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素 如果提供的数组本身为空，则返回true

Type Parameters:

T - 元素类型

Parameters:

args - 被检查的对象,一个或者多个

Returns:

是否都为空

isSubEquals

public static boolean isSubEquals(byte[] array,
 int offset,
 byte... subArray)

是否局部匹配，相当于对比以下子串是否相等

     array1[offset1, subArray.length]
                  ||
               subArray
 

Parameters:

array - 数组

offset - 开始位置

subArray - 子数组

Returns:

是否局部匹配

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,
 int beginInclude,
 T[] subArray)

查找子数组的位置

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

beginInclude - 查找开始的位置（包含）

subArray - 子数组

Returns:

子数组的开始位置，即子数字第一个元素在数组中的位置

isAllEmptyVarargs

@SafeVarargs
public static <T> boolean isAllEmptyVarargs(T... args)

是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素

如果提供的数组本身为空，则返回true

限制条件：args的每个item不能是数组、不能是集合

Type Parameters:

T - 元素类型

Parameters:

args - 被检查的对象,一个或者多个

Returns:

是否都为空

Throws:

IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常

isAllNotEmpty

public static boolean isAllNotEmpty(Object... args)

是否所有元素都不为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素

如果提供的数组本身为空，则返回true

Parameters:

args - 被检查的对象,一个或者多个

Returns:

是否都不为空

hasNull

public static <T> boolean hasNull(T... array)

是否包含null元素

如果数组为null，则返回true，如果数组为空，则返回false

Type Parameters:

T - 数组元素类型

Parameters:

array - 被检查的数组

Returns:

是否包含 null 元素

hasEmpty

public static <T> boolean hasEmpty(T[] args)

是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素

如果提供的数组本身为空，则返回false

Type Parameters:

T - 元素类型

Parameters:

args - 被检查对象

Returns:

是否存在 null 或空对象

hasEmptyVarargs

@SafeVarargs
public static <T> boolean hasEmptyVarargs(T... args)

是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素

如果提供的数组本身为空，则返回false

限制条件：args的每个item不能是数组、不能是集合

Type Parameters:

T - 元素类型

Parameters:

args - 被检查对象

Returns:

是否存在 null 或空对象

Throws:

IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常

isAllNull

public static <T> boolean isAllNull(T... array)

所有字段是否全为null

如果数组为null或者空，则返回 true

Type Parameters:

T - 数组元素类型

Parameters:

array - 被检查的数组

Returns:

所有字段是否全为null

isAllNotNull

public static <T> boolean isAllNotNull(T... array)

是否所有元素都不为 null

如果提供的数组为null，则返回false，如果提供的数组为空，则返回true

Type Parameters:

T - 数组元素类型

Parameters:

array - 被检查的数组

Returns:

是否所有元素都不为 null

hasNonNull

public static <T> boolean hasNonNull(T... array)

是否包含非null元素

如果数组是null或者空，返回false，否则当数组中有非null元素时返回true

Type Parameters:

T - 数组元素类型

Parameters:

array - 被检查的数组

Returns:

是否包含非 null 元素

emptyCount

public static int emptyCount(Object... args)

计算null或空元素对象的个数，通过ObjectValidator.isEmpty(Object) 判断元素

Parameters:

args - 被检查的对象,一个或者多个

Returns:

null或空元素对象的个数

firstNonNull

public static <T> T firstNonNull(T... array)

返回数组中第一个非空元素

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

Returns:

第一个非空元素，如果 不存在非空元素 或 数组为空，返回null

firstMatch

public static <T> T firstMatch(Predicate<T> matcher,
 T... array)

返回数组中第一个匹配规则的值

Type Parameters:

T - 数组元素类型

Parameters:

matcher - 匹配接口，实现此接口自定义匹配规则

array - 数组

Returns:

第一个匹配元素，如果 不存在匹配元素 或 数组为空，返回 null

matchIndex

public static <T> int matchIndex(Predicate<T> matcher,
 T... array)

返回数组中第一个匹配规则的值的位置

Type Parameters:

T - 数组元素类型

Parameters:

matcher - 匹配接口，实现此接口自定义匹配规则

array - 数组

Returns:

第一个匹配元素的位置，Normal.__1表示未匹配到

matchIndex

public static <E> int matchIndex(int beginIndexInclude,
 Predicate<E> matcher,
 E... array)

返回数组中第一个匹配规则的值的位置

Type Parameters:

E - 数组元素类型

Parameters:

beginIndexInclude - 检索开始的位置，不能为负数

matcher - 匹配接口，实现此接口自定义匹配规则

array - 数组

Returns:

第一个匹配元素的位置，Normal.__1表示未匹配到

indexOf

public static <T> int indexOf(T[] array,
 Object value,
 int beginIndexInclude)

返回数组中指定元素所在位置，未找到返回Normal.__1

Type Parameters:

T - 数组类型

Parameters:

array - 数组

value - 被检查的元素

beginIndexInclude - 检索开始的位置

Returns:

数组中指定元素所在位置，未找到返回Normal.__1

indexOf

public static <T> int indexOf(T[] array,
 Object value)

返回数组中指定元素所在位置，未找到返回Normal.__1

Type Parameters:

T - 数组类型

Parameters:

array - 数组

value - 被检查的元素

Returns:

数组中指定元素所在位置，未找到返回Normal.__1

indexOfIgnoreCase

public static int indexOfIgnoreCase(CharSequence[] array,
 CharSequence value)

返回数组中指定元素所在位置，忽略大小写，未找到返回Normal.__1

Parameters:

array - 数组

value - 被检查的元素

Returns:

数组中指定元素所在位置，未找到返回Normal.__1

lastIndexOf

public static <T> int lastIndexOf(T[] array,
 Object value)

返回数组中指定元素最后的所在位置，未找到返回Normal.__1

Type Parameters:

T - 数组类型

Parameters:

array - 数组

value - 被检查的元素

Returns:

数组中指定元素最后的所在位置，未找到返回Normal.__1

lastIndexOf

public static <T> int lastIndexOf(T[] array,
 Object value,
 int endInclude)

返回数组中指定元素最后的所在位置，未找到返回Normal.__1

Type Parameters:

T - 数组类型

Parameters:

array - 数组

value - 被检查的元素

endInclude - 从后向前查找时的起始位置，一般为array.length - 1

Returns:

数组中指定元素最后的所在位置，未找到返回Normal.__1

indexOfSub

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

查找子数组的位置

Type Parameters:

T - 数组元素类型

Parameters:

array - 数组

subArray - 子数组

Returns:

子数组的开始位置，即子数字第一个元素在数组中的位置

regionMatches

public static boolean regionMatches(byte[] array1,
 int offset1,
 byte[] array2,
 int offset2,
 int length)

是否局部匹配，相当于对比以下子串是否相等

     array1[offset1 : offset1 + length]
                  ||
     array2[offset2 : offset2 + length]
 

Parameters:

array1 - 第一个数组

offset1 - 第一个数组开始位置

array2 - 第二个数组

offset2 - 第二个数组开始位置

length - 检查长度

Returns:

是否局部匹配

toString

public static String toString(Object object)

数组或集合转String

Parameters:

object - 集合或数组对象

Returns:

数组字符串，与集合转字符串格式相同

length

public static int length(Object array)
                  throws IllegalArgumentException

获取数组长度 如果参数为null，返回0

 ArrayKit.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:

• Array.getLength(Object)