Arrays (Buession Core 2.1.0 API)

java.lang.Object
- org.apache.commons.lang3.ArrayUtils
- - com.buession.core.collect.Arrays

直接已知子类:

ArrayUtils
```
public class Arrays
extends org.apache.commons.lang3.ArrayUtils
```
数组工具类

从以下版本开始:

2.0.0

作者:

Yong.Teng

字段概要

字段
限定符和类型字段和说明

static String DEFAULT_GLUE
- 从类继承的字段 org.apache.commons.lang3.ArrayUtils
  EMPTY_BOOLEAN_ARRAY, EMPTY_BOOLEAN_OBJECT_ARRAY, EMPTY_BYTE_ARRAY, EMPTY_BYTE_OBJECT_ARRAY, EMPTY_CHAR_ARRAY, EMPTY_CHARACTER_OBJECT_ARRAY, EMPTY_CLASS_ARRAY, EMPTY_DOUBLE_ARRAY, EMPTY_DOUBLE_OBJECT_ARRAY, EMPTY_FIELD_ARRAY, EMPTY_FLOAT_ARRAY, EMPTY_FLOAT_OBJECT_ARRAY, EMPTY_INT_ARRAY, EMPTY_INTEGER_OBJECT_ARRAY, EMPTY_LONG_ARRAY, EMPTY_LONG_OBJECT_ARRAY, EMPTY_METHOD_ARRAY, EMPTY_OBJECT_ARRAY, EMPTY_SHORT_ARRAY, EMPTY_SHORT_OBJECT_ARRAY, EMPTY_STRING_ARRAY, EMPTY_THROWABLE_ARRAY, EMPTY_TYPE_ARRAY, INDEX_NOT_FOUND

字段
限定符和类型	字段和说明
`static String`	`DEFAULT_GLUE`

构造器概要

构造器
构造器和说明

Arrays()

构造器
构造器和说明
`Arrays()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static boolean`	`contains(boolean[] a, boolean value)` 检查 boolean 数组中是否存在某个值
`static boolean`	`contains(byte[] a, byte value)` 检查 byte 数组中是否存在某个值
`static boolean`	`contains(byte[] a, int value)` 检查 byte 数组中是否存在某个值
`static boolean`	`contains(byte[] a, long value)` 检查 byte 数组中是否存在某个值
`static boolean`	`contains(byte[] a, short value)` 检查 byte 数组中是否存在某个值
`static boolean`	`contains(char[] a, char value)` 检查 char 数组中是否存在某个值
`static boolean`	`contains(double[] a, double value)` 检查 double 数组中是否存在某个值
`static boolean`	`contains(double[] a, float value)` 检查 double 数组中是否存在某个值
`static boolean`	`contains(float[] a, double value)` 检查 float 数组中是否存在某个值
`static boolean`	`contains(float[] a, float value)` 检查 float 数组中是否存在某个值
`static boolean`	`contains(int[] a, int value)` 检查 int 数组中是否存在某个值
`static boolean`	`contains(int[] a, long value)` 检查 int 数组中是否存在某个值
`static boolean`	`contains(int[] a, short value)` 检查 int 数组中是否存在某个值
`static boolean`	`contains(long[] a, int value)` 检查 long 数组中是否存在某个值
`static boolean`	`contains(long[] a, long value)` 检查 long 数组中是否存在某个值
`static boolean`	`contains(long[] a, short value)` 检查 long 数组中是否存在某个值
`static boolean`	`contains(Object[] a, Object value)` 检查数组中是否存在某个值
`static boolean`	`contains(short[] a, int value)` 检查 short 数组中是否存在某个值
`static boolean`	`contains(short[] a, long value)` 检查 short 数组中是否存在某个值
`static boolean`	`contains(short[] a, short value)` 检查 short 数组中是否存在某个值
`static int`	`indexOf(boolean[] a, boolean value)` 获取指定值在 boolean 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(boolean[] a, boolean value, int startIndex)` 获取指定值在 boolean 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, byte value)` 获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, byte value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, int value)` 获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, int value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, long value)` 获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, long value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, short value)` 获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(byte[] a, short value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(char[] a, char value)` 获取指定值在 char 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(char[] a, char value, int startIndex)` 获取指定值在 char 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(double[] a, double value)` 获取指定值在 double 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(double[] a, double value, int startIndex)` 获取指定值在 double 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(double[] a, float value)` 获取指定值在 double 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(double[] a, float value, int startIndex)` 获取指定值在 double 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(float[] a, double value)` 获取指定值在 float 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(float[] a, double value, int startIndex)` 获取指定值在 float 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(float[] a, float value)` 获取指定值在 float 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(float[] a, float value, int startIndex)` 获取指定值在 float 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, int value)` 获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, int value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, long value)` 获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, long value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, short value)` 获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(int[] a, short value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, int value)` 获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, int value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, long value)` 获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, long value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, short value)` 获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(long[] a, short value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, int value)` 获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, int value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, long value)` 获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, long value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, short value)` 获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`indexOf(short[] a, short value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(boolean[] a, boolean value)` 获取指定值在 boolean 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(boolean[] a, boolean value, int startIndex)` 获取指定值在 boolean 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, byte value)` 获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, byte value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, int value)` 获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, int value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, long value)` 获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, long value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, short value)` 获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(byte[] a, short value, int startIndex)` 获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(char[] a, char value)` 获取指定值在 char 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(char[] a, char value, int startIndex)` 获取指定值在 char 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(double[] a, double value)` 获取指定值在 double 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(double[] a, double value, int startIndex)` 获取指定值在 double 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(double[] a, float value)` 获取指定值在 double 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(double[] a, float value, int startIndex)` 获取指定值在 double 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(float[] a, double value)` 获取指定值在 float 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(float[] a, double value, int startIndex)` 获取指定值在 float 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(float[] a, float value)` 获取指定值在 float 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(float[] a, float value, int startIndex)` 获取指定值在 float 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, int value)` 获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, int value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, long value)` 获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, long value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, short value)` 获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(int[] a, short value, int startIndex)` 获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, int value)` 获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, int value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, long value)` 获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, long value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, short value)` 获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(long[] a, short value, int startIndex)` 获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, int value)` 获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, int value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, long value)` 获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, long value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, short value)` 获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static int`	`lastIndexOf(short[] a, short value, int startIndex)` 获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
`static <S,T> T[]`	`map(S[] arrays, Class<T> clazz, Function<S,T> fn)` 对数组的元素进行操作，返回一个新的数组
`static boolean[]`	`merge(boolean[] a, boolean[]... b)` 合并数组
`static byte[]`	`merge(byte[] a, byte[]... b)` 合并数组
`static char[]`	`merge(char[] a, char[]... b)` 合并数组
`static double[]`	`merge(double[] a, double[]... b)` 合并数组
`static float[]`	`merge(float[] a, float[]... b)` 合并数组
`static int[]`	`merge(int[] a, int[]... b)` 合并数组
`static long[]`	`merge(long[] a, long[]... b)` 合并数组
`static short[]`	`merge(short[] a, short[]... b)` 合并数组
`static <T> T[]`	`merge(T[] a, T[]... b)` 合并数组
`static List<Boolean>`	`toList(boolean[] a)` 将 boolean 型数组转换为 List
`static List<Byte>`	`toList(byte[] a)` 将 byte 型数组转换为 List
`static List<Character>`	`toList(char[] a)` 将 char 型数组转换为 List
`static List<Double>`	`toList(double[] a)` 将 double 型数组转换为 List
`static List<Float>`	`toList(float[] a)` 将 float 型数组转换为 List
`static List<Integer>`	`toList(int[] a)` 将 int 型数组转换为 List
`static List<Long>`	`toList(long[] a)` 将 long 型数组转换为 List
`static <O> List<O>`	`toList(O[] a)` 将数组转换为 List
`static List<Short>`	`toList(short[] a)` 将 short 型数组转换为 List
`static Set<Boolean>`	`toSet(boolean[] a)` 将 boolean 型数组转换为 Set
`static Set<Byte>`	`toSet(byte[] a)` 将 byte 型数组转换为 Set
`static Set<Character>`	`toSet(char[] a)` 将 char 型数组转换为 Set
`static Set<Double>`	`toSet(double[] a)` 将 double 型数组转换为 Set
`static Set<Float>`	`toSet(float[] a)` 将 float 型数组转换为 Set
`static Set<Integer>`	`toSet(int[] a)` 将 int 型数组转换为 Set
`static Set<Long>`	`toSet(long[] a)` 将 long 型数组转换为 Set
`static <O> Set<O>`	`toSet(O[] a)` 将数组转换为 Set
`static Set<Short>`	`toSet(short[] a)` 将 short 型数组转换为 Set
`static String`	`toString(boolean[] a)` 将 boolean 型数组拼接成字符串
`static String`	`toString(boolean[] a, String glue)` 将 boolean 型数组拼接成字符串
`static String`	`toString(byte[] a)` 将 byte 型数组拼接成字符串
`static String`	`toString(byte[] a, String glue)` 将 byte 型数组拼接成字符串
`static String`	`toString(char[] a)` 将 char 型数组拼接成字符串
`static String`	`toString(char[] a, String glue)` 将 char 型数组拼接成字符串
`static String`	`toString(double[] a)` 将 double 型数组拼接成字符串
`static String`	`toString(double[] a, String glue)` 将 double 型数组拼接成字符串
`static String`	`toString(float[] a)` 将 float 型数组拼接成字符串
`static String`	`toString(float[] a, String glue)` 将 float 型数组拼接成字符串
`static String`	`toString(int[] a)` 将 int 型数组拼接成字符串
`static String`	`toString(int[] a, String glue)` 将 int 型数组拼接成字符串
`static String`	`toString(long[] a)` 将 long 型数组拼接成字符串
`static String`	`toString(long[] a, String glue)` 将 long 型数组拼接成字符串
`static <O> String`	`toString(O[] a)` 将 O 型数组拼接成字符串
`static <O> String`	`toString(O[] a, String glue)` 将 O 型数组拼接成字符串
`static String`	`toString(short[] a)` 将 short 型数组拼接成字符串
`static String`	`toString(short[] a, String glue)` 将 short 型数组拼接成字符串
`static String[]`	`toStringArray(boolean[] a)` 将 boolean 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(byte[] a)` 将 byte 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(char[] a)` 将 char 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(double[] a)` 将 double 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(float[] a)` 将 float 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(int[] a)` 将 int 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(long[] a)` 将 long 类型的数组转换成 String 类型的数组
`static String[]`	`toStringArray(short[] a)` 将 short 类型的数组转换成 String 类型的数组

从类继承的方法 org.apache.commons.lang3.ArrayUtils
add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, add, addAll, addAll, addAll, addAll, addAll, addAll, addAll, addAll, addAll, addFirst, addFirst, addFirst, addFirst, addFirst, addFirst, addFirst, addFirst, addFirst, clone, clone, clone, clone, clone, clone, clone, clone, clone, contains, get, get, getLength, hashCode, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexesOf, indexOf, indexOf, indexOf, indexOf, insert, insert, insert, insert, insert, insert, insert, insert, insert, isArrayIndexValid, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEquals, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameLength, isSameType, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, nullToEmpty, remove, remove, remove, remove, remove, remove, remove, remove, remove, removeAll, removeAll, removeAll, removeAll, removeAll, removeAll, removeAll, removeAll, removeAll, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeAllOccurrences, removeElement, removeElement, removeElement, removeElement, removeElement, removeElement, removeElement, removeElement, removeElement, removeElements, removeElements, removeElements, removeElements, removeElements, removeElements, removeElements, removeElements, removeElements, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shift, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, subarray, subarray, subarray, subarray, subarray, subarray, subarray, subarray, subarray, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, swap, toArray, toMap, toObject, toObject, toObject, toObject, toObject, toObject, toObject, toObject, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toPrimitive, toString, toString, toStringArray, toStringArray

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - DEFAULT_GLUE
```
public static final String DEFAULT_GLUE
```
    另请参阅:
    
    常量字段值
- 构造器详细资料
  - Arrays
```
public Arrays()
```
- 方法详细资料
  - contains
```
public static boolean contains(byte[] a,
                               byte value)
```
    检查 byte 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(byte[] a,
                               short value)
```
    检查 byte 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(byte[] a,
                               int value)
```
    检查 byte 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(byte[] a,
                               long value)
```
    检查 byte 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(char[] a,
                               char value)
```
    检查 char 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(short[] a,
                               short value)
```
    检查 short 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(short[] a,
                               int value)
```
    检查 short 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(short[] a,
                               long value)
```
    检查 short 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(int[] a,
                               short value)
```
    检查 int 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(int[] a,
                               int value)
```
    检查 int 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(int[] a,
                               long value)
```
    检查 int 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(long[] a,
                               short value)
```
    检查 long 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(long[] a,
                               int value)
```
    检查 long 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(long[] a,
                               long value)
```
    检查 long 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(float[] a,
                               float value)
```
    检查 float 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(float[] a,
                               double value)
```
    检查 float 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(double[] a,
                               float value)
```
    检查 double 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(double[] a,
                               double value)
```
    检查 double 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(boolean[] a,
                               boolean value)
```
    检查 boolean 数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - contains
```
public static boolean contains(Object[] a,
                               Object value)
```
    检查数组中是否存在某个值
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    数组中存在该值，则返回 true；否则，返回 false
  - indexOf
```
public static int indexOf(byte[] a,
                          byte value)
```
    获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          short value)
```
    获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          int value)
```
    获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          long value)
```
    获取指定值在 byte 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          byte value,
                          int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          short value,
                          int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          int value,
                          int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(byte[] a,
                          long value,
                          int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(char[] a,
                          char value)
```
    获取指定值在 char 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(char[] a,
                          char value,
                          int startIndex)
```
    获取指定值在 char 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          short value)
```
    获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          int value)
```
    获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          long value)
```
    获取指定值在 short 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          short value,
                          int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          int value,
                          int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(short[] a,
                          long value,
                          int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          short value)
```
    获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          int value)
```
    获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          long value)
```
    获取指定值在 int 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          short value,
                          int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          int value,
                          int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(int[] a,
                          long value,
                          int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          short value)
```
    获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          int value)
```
    获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          long value)
```
    获取指定值在 long 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          short value,
                          int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          int value,
                          int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(long[] a,
                          long value,
                          int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(float[] a,
                          float value)
```
    获取指定值在 float 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(float[] a,
                          double value)
```
    获取指定值在 float 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(float[] a,
                          float value,
                          int startIndex)
```
    获取指定值在 float 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(float[] a,
                          double value,
                          int startIndex)
```
    获取指定值在 float 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(double[] a,
                          float value)
```
    获取指定值在 double 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(double[] a,
                          double value)
```
    获取指定值在 double 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(double[] a,
                          float value,
                          int startIndex)
```
    获取指定值在 double 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(double[] a,
                          double value,
                          int startIndex)
```
    获取指定值在 double 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(boolean[] a,
                          boolean value)
```
    获取指定值在 boolean 数组中第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - indexOf
```
public static int indexOf(boolean[] a,
                          boolean value,
                          int startIndex)
```
    获取指定值在 boolean 数组中从 startIndex 位置开始，第一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中第一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              byte value)
```
    获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              short value)
```
    获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              int value)
```
    获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              long value)
```
    获取指定值在 byte 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              byte value,
                              int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              short value,
                              int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              int value,
                              int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(byte[] a,
                              long value,
                              int startIndex)
```
    获取指定值在 byte 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(char[] a,
                              char value)
```
    获取指定值在 char 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(char[] a,
                              char value,
                              int startIndex)
```
    获取指定值在 char 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              short value)
```
    获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              int value)
```
    获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              long value)
```
    获取指定值在 short 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              short value,
                              int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              int value,
                              int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(short[] a,
                              long value,
                              int startIndex)
```
    获取指定值在 short 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              short value)
```
    获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              int value)
```
    获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              long value)
```
    获取指定值在 int 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              short value,
                              int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              int value,
                              int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(int[] a,
                              long value,
                              int startIndex)
```
    获取指定值在 int 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              short value)
```
    获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              int value)
```
    获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              long value)
```
    获取指定值在 long 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              short value,
                              int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              int value,
                              int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] a,
                              long value,
                              int startIndex)
```
    获取指定值在 long 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(float[] a,
                              float value)
```
    获取指定值在 float 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(float[] a,
                              double value)
```
    获取指定值在 float 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(float[] a,
                              float value,
                              int startIndex)
```
    获取指定值在 float 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(float[] a,
                              double value,
                              int startIndex)
```
    获取指定值在 float 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(double[] a,
                              float value)
```
    获取指定值在 double 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(double[] a,
                              double value)
```
    获取指定值在 double 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(double[] a,
                              float value,
                              int startIndex)
```
    获取指定值在 double 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(double[] a,
                              double value,
                              int startIndex)
```
    获取指定值在 double 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(boolean[] a,
                              boolean value)
```
    获取指定值在 boolean 数组中最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - lastIndexOf
```
public static int lastIndexOf(boolean[] a,
                              boolean value,
                              int startIndex)
```
    获取指定值在 boolean 数组中从 startIndex 位置开始，最后一次出现处的索引，如果此数组中没有该值，则返回 -1
    
    参数:
    
    a - 待搜索的数组
    
    value - 待搜索的值
    
    startIndex - 开始位置
    
    返回:
    
    指定值在数组中最后一次出现处的索引，未找到则返回 -1
  - toString
```
public static String toString(byte[] a)
```
    将 byte 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(byte[] a,
                              String glue)
```
    将 byte 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(char[] a)
```
    将 char 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(char[] a,
                              String glue)
```
    将 char 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(short[] a)
```
    将 short 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(short[] a,
                              String glue)
```
    将 short 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(int[] a)
```
    将 int 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(int[] a,
                              String glue)
```
    将 int 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(long[] a)
```
    将 long 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(long[] a,
                              String glue)
```
    将 long 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(float[] a)
```
    将 float 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(float[] a,
                              String glue)
```
    将 float 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(double[] a)
```
    将 double 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(double[] a,
                              String glue)
```
    将 double 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(boolean[] a)
```
    将 boolean 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static String toString(boolean[] a,
                              String glue)
```
    将 boolean 型数组拼接成字符串
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toString
```
public static <O> String toString(O[] a)
```
    将 O 型数组拼接成字符串
    
    类型参数:
    
    O - 类
    
    参数:
    
    a - 需要拼接的数组
    
    返回:
    
    拼接后的字符串
  - toString
```
public static <O> String toString(O[] a,
                                  String glue)
```
    将 O 型数组拼接成字符串
    
    类型参数:
    
    O - 类
    
    参数:
    
    a - 需要拼接的数组
    
    glue - 拼接字符串
    
    返回:
    
    拼接后的字符串
  - toList
```
public static List<Byte> toList(byte[] a)
```
    将 byte 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Character> toList(char[] a)
```
    将 char 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Short> toList(short[] a)
```
    将 short 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Integer> toList(int[] a)
```
    将 int 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Long> toList(long[] a)
```
    将 long 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Float> toList(float[] a)
```
    将 float 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Double> toList(double[] a)
```
    将 double 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static List<Boolean> toList(boolean[] a)
```
    将 boolean 型数组转换为 List
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toList
```
public static <O> List<O> toList(O[] a)
```
    将数组转换为 List
    
    类型参数:
    
    O - 类
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Byte> toSet(byte[] a)
```
    将 byte 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Character> toSet(char[] a)
```
    将 char 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Short> toSet(short[] a)
```
    将 short 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Integer> toSet(int[] a)
```
    将 int 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Long> toSet(long[] a)
```
    将 long 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Float> toSet(float[] a)
```
    将 float 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Double> toSet(double[] a)
```
    将 double 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static Set<Boolean> toSet(boolean[] a)
```
    将 boolean 型数组转换为 Set
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toSet
```
public static <O> Set<O> toSet(O[] a)
```
    将数组转换为 Set
    
    类型参数:
    
    O - 类
    
    参数:
    
    a - 需要转换的数组
    
    返回:
    
    转换结果
  - toStringArray
```
public static String[] toStringArray(byte[] a)
```
    将 byte 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - byte 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(char[] a)
```
    将 char 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - char 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(short[] a)
```
    将 short 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - short 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(int[] a)
```
    将 int 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - int 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(long[] a)
```
    将 long 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - long 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(float[] a)
```
    将 float 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - float 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(double[] a)
```
    将 double 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - float 类型的数组
    
    返回:
    
    String 类型的数组
  - toStringArray
```
public static String[] toStringArray(boolean[] a)
```
    将 boolean 类型的数组转换成 String 类型的数组
    
    参数:
    
    a - float 类型的数组
    
    返回:
    
    String 类型的数组
  - merge
```
public static byte[] merge(byte[] a,
                           byte[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static char[] merge(char[] a,
                           char[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static boolean[] merge(boolean[] a,
                              boolean[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static short[] merge(short[] a,
                            short[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static int[] merge(int[] a,
                          int[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static long[] merge(long[] a,
                           long[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static float[] merge(float[] a,
                            float[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static double[] merge(double[] a,
                             double[]... b)
```
    合并数组
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - merge
```
public static <T> T[] merge(T[] a,
                            T[]... b)
```
    合并数组
    
    类型参数:
    
    T - 数据对象类型
    
    参数:
    
    a - 待合并的数组
    
    b - 待合并的数组
    
    返回:
    
    合并后的数组
  - map
```
public static <S,T> T[] map(S[] arrays,
                            Class<T> clazz,
                            Function<S,T> fn)
```
    对数组的元素进行操作，返回一个新的数组
    
    类型参数:
    
    S - 源数组类型
    
    T - 目标数组类型
    
    参数:
    
    arrays - 需操作的数组
    
    clazz - 目标数组类型
    
    fn - Value 操作函数
    
    返回:
    
    新的 Map

类 Arrays

字段概要

从类继承的字段 org.apache.commons.lang3.ArrayUtils

构造器概要

方法概要

从类继承的方法 org.apache.commons.lang3.ArrayUtils

从类继承的方法 java.lang.Object

字段详细资料

DEFAULT_GLUE

构造器详细资料

Arrays

方法详细资料

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

contains

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf