ArrayUtil (tiny-码云(gitee.com))

java.lang.Object
- org.tinygroup.commons.tools.ArrayUtil

```
public class ArrayUtil
extends Object
```
有关数组处理的工具类。

Author:

renhui

Constructor Summary

Constructors
Constructor and Description

ArrayUtil()

Constructors
Constructor and Description
`ArrayUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`arrayContains(boolean[] array, boolean booleanToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(boolean[] array, boolean[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(byte[] array, byte byteToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(byte[] array, byte[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(char[] array, char charToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(char[] array, char[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(double[] array, double doubleToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(double[] array, double[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(double[] array, double[] arrayToFind, double tolerance)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(double[] array, double doubleToFind, double tolerance)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(float[] array, float floatToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(float[] array, float[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(float[] array, float[] arrayToFind, float tolerance)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(float[] array, float floatToFind, float tolerance)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(int[] array, int intToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(int[] array, int[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(long[] array, long longToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(long[] array, long[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(Object[] array, Object objectToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(Object[] array, Object[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`arrayContains(short[] array, short shortToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`arrayContains(short[] array, short[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static int`	`arrayIndexOf(boolean[] array, boolean booleanToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(boolean[] array, boolean[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(boolean[] array, boolean[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(boolean[] array, boolean booleanToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(byte[] array, byte byteToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(byte[] array, byte[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(byte[] array, byte[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(byte[] array, byte byteToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(char[] array, char charToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(char[] array, char[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(char[] array, char[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(char[] array, char charToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(double[] array, double doubleToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(double[] array, double[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(double[] array, double[] arrayToFind, double tolerance)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(double[] array, double[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(double[] array, double[] arrayToFind, int startIndex, double tolerance)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(double[] array, double doubleToFind, double tolerance)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(double[] array, double doubleToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(double[] array, double doubleToFind, int startIndex, double tolerance)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(float[] array, float floatToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(float[] array, float[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(float[] array, float[] arrayToFind, float tolerance)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(float[] array, float[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(float[] array, float[] arrayToFind, int startIndex, float tolerance)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(float[] array, float floatToFind, float tolerance)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(float[] array, float floatToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(float[] array, float floatToFind, int startIndex, float tolerance)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(int[] array, int intToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(int[] array, int[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(int[] array, int[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(int[] array, int intToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(long[] array, long longToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(long[] array, long[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(long[] array, long[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(long[] array, long longToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(Object[] array, Object objectToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(Object[] array, Object[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(Object[] array, Object objectToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(short[] array, short shortToFind)` 在数组中查找一个元素。
`static int`	`arrayIndexOf(short[] array, short[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(short[] array, short[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`arrayIndexOf(short[] array, short shortToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`arrayLastIndexOf(boolean[] array, boolean booleanToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(boolean[] array, boolean[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(boolean[] array, boolean[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(boolean[] array, boolean booleanToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(byte[] array, byte byteToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(byte[] array, byte[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(byte[] array, byte[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(byte[] array, byte byteToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(char[] array, char charToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(char[] array, char[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(char[] array, char[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(char[] array, char charToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(double[] array, double doubleToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(double[] array, double[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(double[] array, double[] arrayToFind, double tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(double[] array, double[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(double[] array, double[] arrayToFind, int startIndex, double tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(double[] array, double doubleToFind, double tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(double[] array, double doubleToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(double[] array, double doubleToFind, int startIndex, double tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(float[] array, float floatToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(float[] array, float[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(float[] array, float[] arrayToFind, float tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(float[] array, float[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(float[] array, float[] arrayToFind, int startIndex, float tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(float[] array, float floatToFind, float tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(float[] array, float floatToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(float[] array, float floatToFind, int startIndex, float tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(int[] array, int intToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(int[] array, int[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(int[] array, int[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(int[] array, int intToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(long[] array, long longToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(long[] array, long[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(long[] array, long[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(long[] array, long longToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(Object[] array, Object objectToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(Object[] array, Object[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(Object[] array, Object objectToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(short[] array, short shortToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLastIndexOf(short[] array, short[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(short[] array, short[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`arrayLastIndexOf(short[] array, short shortToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`arrayLength(Object array)` 取得数组的长度。
`static void`	`arrayReverse(boolean[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(byte[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(char[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(double[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(float[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(int[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(long[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(Object[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static void`	`arrayReverse(short[] array)` 反转数组的元素顺序。如果数组为`null`，则什么也不做。
`static <T,S extends T> T`	`defaultIfEmptyArray(T array, S defaultValue)` 如果数组是`null`或空数组`[]`，则返回指定数组默认值。
`static boolean`	`isArraySameLength(boolean[] array1, boolean[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(byte[] array1, byte[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(char[] array1, char[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(double[] array1, double[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(float[] array1, float[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(int[] array1, int[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(long[] array1, long[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(Object[] array1, Object[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isArraySameLength(short[] array1, short[] array2)` 判断两个数组是否具有相同的长度。如果数组为`null`则被看作长度为`0`。
`static boolean`	`isEmptyArray(Object array)` 检查数组是否为`null`或空数组`[]`。
`static Object[]`	`toArray(Object value)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ArrayUtil
```
public ArrayUtil()
```
- Method Detail
  - arrayLength
```
public static int arrayLength(Object array)
```
    取得数组的长度。
    此方法比Array.getLength()要快得多。
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    如果为空，或者非数组，则返回0。
  - isEmptyArray
```
public static boolean isEmptyArray(Object array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmptyArray(null)              = true
 ArrayUtil.isEmptyArray(new int[0])        = true
 ArrayUtil.isEmptyArray(new int[10])       = false
 
```
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    如果为空, 则返回true
  - defaultIfEmptyArray
```
public static <T,S extends T> T defaultIfEmptyArray(T array,
                                                    S defaultValue)
```
    如果数组是null或空数组[]，则返回指定数组默认值。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new String[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfEmpty(new String[10], defaultArray) = 数组本身
 
```
    Parameters:
    
    array - 要转换的数组
    
    defaultArray - 默认数组
    
    Returns:
    
    数组本身或默认数组
  - isArraySameLength
```
public static boolean isArraySameLength(Object[] array1,
                                        Object[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(long[] array1,
                                        long[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(int[] array1,
                                        int[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(short[] array1,
                                        short[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(byte[] array1,
                                        byte[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(double[] array1,
                                        double[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(float[] array1,
                                        float[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(boolean[] array1,
                                        boolean[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - isArraySameLength
```
public static boolean isArraySameLength(char[] array1,
                                        char[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    如果两个数组长度相同，则返回true
  - arrayReverse
```
public static void arrayReverse(Object[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(long[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(int[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(short[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(byte[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(double[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(float[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(boolean[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayReverse
```
public static void arrayReverse(char[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。
    
    Parameters:
    
    array - 要反转的数组
  - arrayIndexOf
```
public static int arrayIndexOf(Object[] array,
                               Object objectToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    objectToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(Object[] array,
                               Object[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(Object[] array,
                               Object objectToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    objectToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(Object[] array,
                                   Object objectToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    objectToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(Object[] array,
                                   Object[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(Object[] array,
                                   Object objectToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    objectToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(Object[] array,
                                    Object objectToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    objectToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(Object[] array,
                                    Object[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(long[] array,
                               long longToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    longToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(long[] array,
                               long[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(long[] array,
                               long longToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    longToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(long[] array,
                               long[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(long[] array,
                                   long longToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    longToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(long[] array,
                                   long[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(long[] array,
                                   long longToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    longToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(long[] array,
                                   long[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(long[] array,
                                    long longToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    longToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(long[] array,
                                    long[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(int[] array,
                               int intToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    intToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(int[] array,
                               int[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(int[] array,
                               int intToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    intToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(int[] array,
                               int[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(int[] array,
                                   int intToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    intToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(int[] array,
                                   int[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(int[] array,
                                   int intToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    intToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(int[] array,
                                   int[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(int[] array,
                                    int intToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    intToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(int[] array,
                                    int[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(short[] array,
                               short shortToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    shortToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(short[] array,
                               short[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(short[] array,
                               short shortToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    shortToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(short[] array,
                               short[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(short[] array,
                                   short shortToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    shortToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(short[] array,
                                   short[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(short[] array,
                                   short shortToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    shortToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(short[] array,
                                   short[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(short[] array,
                                    short shortToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    shortToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(short[] array,
                                    short[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(byte[] array,
                               byte byteToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    byteToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(byte[] array,
                               byte[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(byte[] array,
                               byte byteToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    byteToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(byte[] array,
                               byte[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(byte[] array,
                                   byte byteToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    byteToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(byte[] array,
                                   byte[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(byte[] array,
                                   byte byteToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    byteToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(byte[] array,
                                   byte[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(byte[] array,
                                    byte byteToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    byteToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(byte[] array,
                                    byte[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double doubleToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double doubleToFind,
                               double tolerance)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double[] arrayToFind,
                               double tolerance)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double doubleToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double doubleToFind,
                               int startIndex,
                               double tolerance)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(double[] array,
                               double[] arrayToFind,
                               int startIndex,
                               double tolerance)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double doubleToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double doubleToFind,
                                   double tolerance)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double[] arrayToFind,
                                   double tolerance)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double doubleToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double doubleToFind,
                                   int startIndex,
                                   double tolerance)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(double[] array,
                                   double[] arrayToFind,
                                   int startIndex,
                                   double tolerance)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(double[] array,
                                    double doubleToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(double[] array,
                                    double doubleToFind,
                                    double tolerance)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    doubleToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(double[] array,
                                    double[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(double[] array,
                                    double[] arrayToFind,
                                    double tolerance)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float floatToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float floatToFind,
                               float tolerance)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float[] arrayToFind,
                               float tolerance)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float floatToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float floatToFind,
                               int startIndex,
                               float tolerance)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(float[] array,
                               float[] arrayToFind,
                               int startIndex,
                               float tolerance)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float floatToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float floatToFind,
                                   float tolerance)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float[] arrayToFind,
                                   float tolerance)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float floatToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float floatToFind,
                                   int startIndex,
                                   float tolerance)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(float[] array,
                                   float[] arrayToFind,
                                   int startIndex,
                                   float tolerance)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    tolerance - 误差
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(float[] array,
                                    float floatToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(float[] array,
                                    float floatToFind,
                                    float tolerance)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    floatToFind - 要查找的元素
    
    tolerance - 误差
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(float[] array,
                                    float[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(float[] array,
                                    float[] arrayToFind,
                                    float tolerance)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    tolerance - 误差
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(boolean[] array,
                               boolean booleanToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    booleanToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(boolean[] array,
                               boolean[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(boolean[] array,
                               boolean booleanToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    booleanToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(boolean[] array,
                               boolean[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(boolean[] array,
                                   boolean booleanToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    booleanToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(boolean[] array,
                                   boolean[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(boolean[] array,
                                   boolean booleanToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    booleanToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(boolean[] array,
                                   boolean[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(boolean[] array,
                                    boolean booleanToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    booleanToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(boolean[] array,
                                    boolean[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - arrayIndexOf
```
public static int arrayIndexOf(char[] array,
                               char charToFind)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    charToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(char[] array,
                               char[] arrayToFind)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(char[] array,
                               char charToFind,
                               int startIndex)
```
    在数组中查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    charToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayIndexOf
```
public static int arrayIndexOf(char[] array,
                               char[] arrayToFind,
                               int startIndex)
```
    在数组中查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则看作0，超出数组长度的起始索引则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(char[] array,
                                   char charToFind)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    charToFind - 要查找的元素
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(char[] array,
                                   char[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(char[] array,
                                   char charToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    charToFind - 要查找的元素
    
    startIndex - 起始索引
    
    Returns:
    
    该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayLastIndexOf
```
public static int arrayLastIndexOf(char[] array,
                                   char[] arrayToFind,
                                   int startIndex)
```
    在数组中从末尾开始查找一个元素序列。
    如果未找到或数组为null则返回-1。
    
    起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    startIndex - 起始索引
    
    Returns:
    
    该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - arrayContains
```
public static boolean arrayContains(char[] array,
                                    char charToFind)
```
    判断指定对象是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    charToFind - 要查找的元素
    
    Returns:
    
    如果找到则返回true
  - arrayContains
```
public static boolean arrayContains(char[] array,
                                    char[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。
    如果数组为null则返回false。
    
    Parameters:
    
    array - 要扫描的数组
    
    arrayToFind - 要查找的元素序列
    
    Returns:
    
    如果找到则返回true
  - toArray
```
public static Object[] toArray(Object value)
```

Class ArrayUtil

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayUtil

Method Detail

arrayLength

isEmptyArray

defaultIfEmptyArray

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

isArraySameLength

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayReverse

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayContains

arrayContains

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayContains

arrayContains

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayContains

arrayContains

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayContains

arrayContains

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayLastIndexOf

arrayContains

arrayContains

arrayIndexOf

arrayIndexOf

arrayIndexOf

arrayIndexOf