Arrays1 (orion-kit 2.0.1 API)

java.lang.Object
- cn.orionsec.kit.lang.utils.Arrays1

```
public class Arrays1
extends Object
```
数组工具类

Since:

2019/9/9 10:25
需要注意: 可变参数 Object... Object[] T... T[] 不应该传基本类型的数组, 应该传基本类型的包装类基本类型数组无法转化为包装类型的数组, 从而入参为转化Object, 导致与预期结果不相同

Version:

1.0.0

Author:

Jiahang Li

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[]`	`arraycopy(boolean[] src, int srcPos, boolean[] dest, int destPos, int length)`
`static byte[]`	`arraycopy(byte[] src, int srcPos, byte[] dest, int destPos, int length)` 数组拷贝自动扩容2倍
`static char[]`	`arraycopy(char[] src, int srcPos, char[] dest, int destPos, int length)`
`static double[]`	`arraycopy(double[] src, int srcPos, double[] dest, int destPos, int length)`
`static float[]`	`arraycopy(float[] src, int srcPos, float[] dest, int destPos, int length)`
`static int[]`	`arraycopy(int[] src, int srcPos, int[] dest, int destPos, int length)`
`static long[]`	`arraycopy(long[] src, int srcPos, long[] dest, int destPos, int length)`
`static Object[]`	`arraycopy(Object[] src, int srcPos, Object[] dest, int destPos, int length)`
`static short[]`	`arraycopy(short[] src, int srcPos, short[] dest, int destPos, int length)`
`static <T> T[]`	`arraycopys(T[] src, int srcPos, T[] dest, int destPos, int length, IntFunction<T[]> generator)`
`static boolean`	`arrayEquals(Object o1, Object o2)` 判断数组是否相等
`static Object[]`	`compact(Object[] arr)` 去除数组中的 null
`static <T> T[]`	`compacts(T[] arr, IntFunction<T[]> generator)`
`static boolean`	`contains(boolean[] arr, boolean s)`
`static boolean`	`contains(byte[] arr, byte s)` 判断数组是否包含某个元素
`static boolean`	`contains(char[] arr, char s)`
`static boolean`	`contains(double[] arr, double s)`
`static boolean`	`contains(float[] arr, float s)`
`static boolean`	`contains(int[] arr, int s)`
`static boolean`	`contains(long[] arr, long s)`
`static boolean`	`contains(short[] arr, short s)`
`static <T> boolean`	`contains(T[] arr, T s)`
`static int`	`count(boolean target, boolean... arr)`
`static int`	`count(byte target, byte... arr)`
`static int`	`count(char target, char... arr)`
`static int`	`count(double target, double... arr)`
`static int`	`count(float target, float... arr)`
`static int`	`count(int target, int... arr)`
`static int`	`count(long target, long... arr)`
`static int`	`count(short target, short... arr)`
`static <T> int`	`count(T target, T... arr)` 查询目标元素在数组中出现的次数
`static boolean[]`	`def(boolean[] arr, boolean[] def)`
`static boolean[]`	`def(boolean[] arr, Supplier<boolean[]> def)`
`static byte[]`	`def(byte[] arr, byte[] def)`
`static byte[]`	`def(byte[] arr, Supplier<byte[]> def)`
`static char[]`	`def(char[] arr, char[] def)`
`static char[]`	`def(char[] arr, Supplier<char[]> def)`
`static double[]`	`def(double[] arr, double[] def)`
`static double[]`	`def(double[] arr, Supplier<double[]> def)`
`static float[]`	`def(float[] arr, float[] def)`
`static float[]`	`def(float[] arr, Supplier<float[]> def)`
`static int[]`	`def(int[] arr, int[] def)`
`static int[]`	`def(int[] arr, Supplier<int[]> def)`
`static long[]`	`def(long[] arr, long[] def)`
`static long[]`	`def(long[] arr, Supplier<long[]> def)`
`static short[]`	`def(short[] arr, short[] def)`
`static short[]`	`def(short[] arr, Supplier<short[]> def)`
`static <T> T[]`	`def(T[] arr, Supplier<T[]> def)`
`static <T> T[]`	`def(T[] arr, T[] def)` 如果数组为空返回默认数组
`static boolean[]`	`exclude(boolean[] arr, boolean... es)`
`static byte[]`	`exclude(byte[] arr, byte... es)` 排除数组中指定的值
`static char[]`	`exclude(char[] arr, char... es)`
`static double[]`	`exclude(double[] arr, double... es)`
`static float[]`	`exclude(float[] arr, float... es)`
`static int[]`	`exclude(int[] arr, int... es)`
`static long[]`	`exclude(long[] arr, long... es)`
`static Object[]`	`exclude(Object[] arr, Object... es)` 排除数组中指定的值
`static short[]`	`exclude(short[] arr, short... es)`
`static <T> T[]`	`excludes(T[] arr, IntFunction<T[]> generator, T... es)`
`static <T> T[]`	`excludes(T[] arr, Predicate<T> p, IntFunction<T[]> generator)`
`static boolean`	`first(boolean[] arr)`
`static boolean`	`first(boolean[] arr, boolean def)`
`static byte`	`first(byte[] arr)`
`static byte`	`first(byte[] arr, byte def)`
`static char`	`first(char[] arr)`
`static char`	`first(char[] arr, char def)`
`static double`	`first(double[] arr)`
`static double`	`first(double[] arr, double def)`
`static float`	`first(float[] arr)`
`static float`	`first(float[] arr, float def)`
`static int`	`first(int[] arr)`
`static int`	`first(int[] arr, int def)`
`static long`	`first(long[] arr)`
`static long`	`first(long[] arr, long def)`
`static short`	`first(short[] array)`
`static short`	`first(short[] arr, short def)`
`static <T> T`	`first(T[] arr)` 获取数组第一个元素
`static <T> T`	`first(T[] arr, T def)` 获取数组第一个元素
`static void`	`forEach(Consumer<Boolean> consumer, boolean[] arr)`
`static void`	`forEach(Consumer<Byte> consumer, byte[] arr)`
`static void`	`forEach(Consumer<Character> consumer, char[] arr)`
`static void`	`forEach(Consumer<Double> consumer, double[] arr)`
`static void`	`forEach(Consumer<Float> consumer, float[] arr)`
`static void`	`forEach(Consumer<Integer> consumer, int[] arr)`
`static void`	`forEach(Consumer<Long> consumer, long[] arr)`
`static void`	`forEach(Consumer<Short> consumer, short[] arr)`
`static <T> void`	`forEach(Consumer<T> consumer, T[] arr)` 消费对象
`static boolean`	`get(boolean[] arr, int i)`
`static byte`	`get(byte[] arr, int i)`
`static char`	`get(char[] arr, int i)`
`static double`	`get(double[] arr, int i)`
`static float`	`get(float[] arr, int i)`
`static int`	`get(int[] arr, int i)`
`static long`	`get(long[] arr, int i)`
`static short`	`get(short[] arr, int i)`
`static <T> T`	`get(T[] arr, int i)`
`static <T> T`	`getIfPresent(T[] arr, int i)` 获取元素如果元素存在
`static <T> T`	`gets(Object arr, int i)` 获取数组下标对应的值
`static int`	`hashCode(boolean[] arr)`
`static int`	`hashCode(byte[] arr)`
`static int`	`hashCode(char[] arr)`
`static int`	`hashCode(double[] arr)`
`static int`	`hashCode(float[] arr)`
`static int`	`hashCode(int[] arr)`
`static int`	`hashCode(long[] arr)`
`static int`	`hashCode(Object[] arr)` 获取数组的hashCode
`static int`	`hashCode(short[] arr)`
`static int`	`indexOf(boolean[] arr, boolean s)`
`static int`	`indexOf(boolean[] arr, boolean s, int start)`
`static int`	`indexOf(byte[] arr, byte s)`
`static int`	`indexOf(byte[] arr, byte s, int start)` 查找第一个查询到的元素的位置
`static int`	`indexOf(char[] arr, char s)`
`static int`	`indexOf(char[] arr, char s, int start)`
`static int`	`indexOf(double[] arr, double s)`
`static int`	`indexOf(double[] arr, double s, int start)`
`static int`	`indexOf(float[] arr, float s)`
`static int`	`indexOf(float[] arr, float s, int start)`
`static int`	`indexOf(int[] arr, int s)`
`static int`	`indexOf(int[] arr, int s, int start)`
`static int`	`indexOf(long[] arr, long s)`
`static int`	`indexOf(long[] arr, long s, int start)`
`static int`	`indexOf(short[] arr, short s)`
`static int`	`indexOf(short[] arr, short s, int start)`
`static <T> int`	`indexOf(T[] arr, T s)`
`static <T> int`	`indexOf(T[] arr, T s, int start)`
`static boolean`	`isArray(Object o)` 判断对象是否为数组
`static boolean`	`isBaseArray(Object o)` 判断是否是基本类型的数组
`static boolean`	`isEmpties(Object arr)` 判断数组是否为空
`static boolean`	`isEmpty(boolean[] arr)`
`static boolean`	`isEmpty(byte[] arr)`
`static boolean`	`isEmpty(char[] arr)`
`static boolean`	`isEmpty(double[] arr)`
`static boolean`	`isEmpty(float[] arr)`
`static boolean`	`isEmpty(int[] arr)`
`static boolean`	`isEmpty(long[] arr)`
`static boolean`	`isEmpty(short[] arr)`
`static <T> boolean`	`isEmpty(T[] arr)`
`static boolean`	`isNotBaseArray(Object o)` 判断是否不是基本类型的数组
`static boolean`	`isNotEmpties(Object arr)` 判断数组是否不为空
`static boolean`	`isNotEmpty(boolean[] arr)`
`static boolean`	`isNotEmpty(byte[] arr)`
`static boolean`	`isNotEmpty(char[] arr)`
`static boolean`	`isNotEmpty(double[] arr)`
`static boolean`	`isNotEmpty(float[] arr)`
`static boolean`	`isNotEmpty(int[] arr)`
`static boolean`	`isNotEmpty(long[] arr)`
`static boolean`	`isNotEmpty(short[] arr)`
`static <T> boolean`	`isNotEmpty(T[] arr)`
`static boolean`	`isWrapArray(Object o)` 判断是否是包装类型的数组
`static boolean`	`isWrapBaseArray(Object o)` 判断是否不是包装类型的数组
`static boolean`	`last(boolean[] arr)`
`static boolean`	`last(boolean[] arr, boolean def)`
`static byte`	`last(byte[] arr)`
`static byte`	`last(byte[] arr, byte def)`
`static char`	`last(char[] arr)`
`static char`	`last(char[] arr, char def)`
`static double`	`last(double[] arr)`
`static double`	`last(double[] arr, double def)`
`static float`	`last(float[] arr)`
`static float`	`last(float[] arr, float def)`
`static int`	`last(int[] arr)`
`static int`	`last(int[] arr, int def)`
`static long`	`last(long[] arr)`
`static long`	`last(long[] arr, long def)`
`static short`	`last(short[] arr)`
`static short`	`last(short[] arr, short def)`
`static <T> T`	`last(T[] arr)` 获取数组最后一个元素
`static <T> T`	`last(T[] arr, T def)` 获取数组最后一个元素
`static int`	`lastIndexOf(boolean[] arr, boolean s)`
`static int`	`lastIndexOf(boolean[] arr, boolean s, int start)`
`static int`	`lastIndexOf(byte[] arr, byte s)`
`static int`	`lastIndexOf(byte[] arr, byte s, int start)` 查找最后一个查询到的元素的位置
`static int`	`lastIndexOf(char[] arr, char s)`
`static int`	`lastIndexOf(char[] arr, char s, int start)`
`static int`	`lastIndexOf(double[] arr, double s)`
`static int`	`lastIndexOf(double[] arr, double s, int start)`
`static int`	`lastIndexOf(float[] arr, float s)`
`static int`	`lastIndexOf(float[] arr, float s, int start)`
`static int`	`lastIndexOf(int[] arr, int s)`
`static int`	`lastIndexOf(int[] arr, int s, int start)`
`static int`	`lastIndexOf(long[] arr, long s)`
`static int`	`lastIndexOf(long[] arr, long s, int start)`
`static int`	`lastIndexOf(short[] arr, short s)`
`static int`	`lastIndexOf(short[] arr, short s, int start)`
`static <T> int`	`lastIndexOf(T[] arr, T s)`
`static <T> int`	`lastIndexOf(T[] arr, T s, int start)`
`static int`	`length(boolean[] arr)`
`static int`	`length(byte[] arr)`
`static int`	`length(char[] arr)`
`static int`	`length(double[] arr)`
`static int`	`length(float[] arr)`
`static int`	`length(int[] arr)`
`static int`	`length(long[] arr)`
`static int`	`length(short[] arr)`
`static <T> int`	`length(T[] arr)`
`static int`	`lengths(Object... arr)` 获取数组长度
`static int`	`lens(Object arr)`
`static <I,O> O[]`	`mapper(I[] arr, IntFunction<? extends O[]> generator, Mapper<? super I,? extends O> mapper)` 映射
`static byte`	`max(byte[] arr)` 最大值
`static char`	`max(char[] arr)`
`static double`	`max(double[] arr)`
`static float`	`max(float[] arr)`
`static int`	`max(int[] arr)`
`static long`	`max(long[] arr)`
`static short`	`max(short[] arr)`
`static <T extends Comparable<T>> T`	`max(T[] arr)`
`static <T> T`	`max(T[] arr, Comparator<T> c)`
`static boolean[]`	`merge(boolean[] arr, boolean[]... merge)`
`static byte[]`	`merge(byte[] arr, byte[]... merge)`
`static char[]`	`merge(char[] arr, char[]... merge)`
`static double[]`	`merge(double[] arr, double[]... merge)`
`static float[]`	`merge(float[] arr, float[]... merge)`
`static int[]`	`merge(int[] arr, int[]... merge)`
`static long[]`	`merge(long[] arr, long[]... merge)`
`static Object[]`	`merge(Object[] arr, Object[]... merge)`
`static short[]`	`merge(short[] arr, short[]... merge)`
`static <T> T[]`	`merges(IntFunction<T[]> generator, T[] arr, T[]... merge)` 合并数组
`static byte`	`min(byte[] arr)` 最小值
`static char`	`min(char[] arr)`
`static double`	`min(double[] arr)`
`static float`	`min(float[] arr)`
`static int`	`min(int[] arr)`
`static long`	`min(long[] arr)`
`static short`	`min(short[] arr)`
`static <T extends Comparable<T>> T`	`min(T[] arr)`
`static <T> T`	`min(T[] arr, Comparator<T> c)`
`static <T> T[]`	`newArrays(Class<T> type, int length)` 创建数组
`static <T> T[]`	`newArrays(IntFunction<T[]> generator, int length)` 创建数组
`static boolean[]`	`newBooleans(int len)`
`static byte[]`	`newBytes(int len)` 创建数组
`static char[]`	`newChars(int len)`
`static double[]`	`newDoubles(int len)`
`static float[]`	`newFloats(int len)`
`static int[]`	`newInts(int len)`
`static long[]`	`newLongs(int len)`
`static Object[]`	`newObjects(int len)`
`static short[]`	`newShorts(int len)`
`static boolean[]`	`of(boolean... arr)`
`static byte[]`	`of(byte... arr)` 将可变参数转化为数组
`static char[]`	`of(char... arr)`
`static double[]`	`of(double... arr)`
`static float[]`	`of(float... arr)`
`static int[]`	`of(int... arr)`
`static long[]`	`of(long... arr)`
`static short[]`	`of(short... arr)`
`static <T> T[]`	`of(T... arr)` 不可接收基本类型的数组, 可以使用包装类否则会返回 T[][]
`static Object[]`	`ofs(Object... arr)` 可接收基本类型的数组, 返回Object[]
`static boolean`	`random(boolean[] arr)`
`static byte`	`random(byte[] arr)`
`static char`	`random(char[] arr)`
`static double`	`random(double[] arr)`
`static float`	`random(float[] arr)`
`static int`	`random(int[] arr)`
`static long`	`random(long[] arr)`
`static short`	`random(short[] arr)`
`static <T> T`	`random(T[] arr)`
`static <V,R> R`	`reduce(V[] arr, Reduce<? super V,? extends R> reduce)` 规约
`static boolean[]`	`resize(boolean[] arr, int newSize)`
`static byte[]`	`resize(byte[] arr, int newSize)` 调整数组大小
`static char[]`	`resize(char[] arr, int newSize)`
`static double[]`	`resize(double[] arr, int newSize)`
`static float[]`	`resize(float[] arr, int newSize)`
`static int[]`	`resize(int[] arr, int newSize)`
`static long[]`	`resize(long[] arr, int newSize)`
`static Object[]`	`resize(Object[] arr, int newSize)`
`static short[]`	`resize(short[] arr, int newSize)`
`static <T> T[]`	`resize(T[] arr, int newSize, IntFunction<T[]> generator)`
`static void`	`reverse(boolean[] arr)`
`static void`	`reverse(byte[] arr)` 数组倒排
`static void`	`reverse(char[] arr)`
`static void`	`reverse(double[] arr)`
`static void`	`reverse(float[] arr)`
`static void`	`reverse(int[] arr)`
`static void`	`reverse(long[] arr)`
`static void`	`reverse(short[] arr)`
`static <T> void`	`reverse(T[] arr)`
`static void`	`set(boolean[] arr, int i, boolean value)`
`static void`	`set(byte[] arr, int i, byte value)`
`static void`	`set(char[] arr, int i, char value)`
`static void`	`set(double[] arr, int i, double value)`
`static void`	`set(float[] arr, int i, float value)`
`static void`	`set(int[] arr, int i, int value)`
`static void`	`set(long[] arr, int i, long value)`
`static void`	`set(short[] arr, int i, short value)`
`static <T> void`	`set(T[] arr, int i, T value)`
`static <T> void`	`sets(Object arr, int i, T value)` 设置数组下标对应的值
`static boolean`	`some(boolean target, boolean... arr)`
`static boolean`	`some(byte target, byte... arr)`
`static boolean`	`some(char target, char... arr)`
`static boolean`	`some(double target, double... arr)`
`static boolean`	`some(float target, float... arr)`
`static boolean`	`some(int target, int... arr)`
`static boolean`	`some(long target, long... arr)`
`static boolean`	`some(short target, short... arr)`
`static <T> boolean`	`some(T target, T... arr)` 查询目标元素是否出现在数组中
`static void`	`swap(boolean[] arr, int i, int j)`
`static void`	`swap(byte[] arr, int i, int j)`
`static void`	`swap(char[] arr, int i, int j)`
`static void`	`swap(double[] arr, int i, int j)`
`static void`	`swap(float[] arr, int i, int j)`
`static void`	`swap(int[] arr, int i, int j)`
`static void`	`swap(long[] arr, int i, int j)`
`static void`	`swap(short[] arr, int i, int j)`
`static <T> void`	`swap(T[] arr, int i, int j)`
`static boolean[]`	`toBooleanArray(String s, String split)`
`static byte[]`	`toByteArray(String s, String split)`
`static double[]`	`toDoubleArray(String s, String split)`
`static float[]`	`toFloatArray(String s, String split)`
`static int[]`	`toIntArray(String s, String split)`
`static long[]`	`toLongArray(String s, String split)`
`static short[]`	`toShortArray(String s, String split)`
`static String[]`	`toStringArray(String s, String split)`
`static void`	`unChangeSwap(byte[] arr, int i, int j)` 换位
`static boolean[]`	`unWrap(Boolean[] arr)`
`static byte[]`	`unWrap(Byte[] arr)` 将数组转化为其基本装类
`static char[]`	`unWrap(Character[] arr)`
`static double[]`	`unWrap(Double[] arr)`
`static float[]`	`unWrap(Float[] arr)`
`static int[]`	`unWrap(Integer[] arr)`
`static long[]`	`unWrap(Long[] arr)`
`static Object`	`unWrap(Object arr)`
`static short[]`	`unWrap(Short[] arr)`
`static Boolean[]`	`wrap(boolean[] arr)`
`static Byte[]`	`wrap(byte[] w)` 将数组转化为其包装类
`static Character[]`	`wrap(char[] arr)`
`static Double[]`	`wrap(double[] arr)`
`static Float[]`	`wrap(float[] arr)`
`static Integer[]`	`wrap(int[] arr)`
`static Long[]`	`wrap(long[] arr)`
`static Object`	`wrap(Object arr)`
`static Short[]`	`wrap(short[] w)`

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

Method Detail

newBytes
```
public static byte[] newBytes(int len)
```
创建数组

Parameters:

len - 数组长度

Returns:

数组

newShorts

public static short[] newShorts(int len)

newInts
```
public static int[] newInts(int len)
```

newLongs

public static long[] newLongs(int len)

newFloats

public static float[] newFloats(int len)

newDoubles

public static double[] newDoubles(int len)

newChars

public static char[] newChars(int len)

newBooleans

public static boolean[] newBooleans(int len)

newObjects

public static Object[] newObjects(int len)

newArrays
```
public static <T> T[] newArrays(Class<T> type,
                                int length)
```
创建数组

Type Parameters:

T - ignore

Parameters:

type - 类型

length - 空间

Returns:

数组

newArrays
```
public static <T> T[] newArrays(IntFunction<T[]> generator,
                                int length)
```
创建数组

Type Parameters:

T - ignore

Parameters:

generator - e.g. Integer[]::new

length - 空间

Returns:

数组

isArray
```
public static boolean isArray(Object o)
```
判断对象是否为数组

Parameters:

o - 对象

Returns:

true 数组

isBaseArray
```
public static boolean isBaseArray(Object o)
```
判断是否是基本类型的数组

Parameters:

o - 对象

Returns:

true 是基本类型的数组

isWrapArray
```
public static boolean isWrapArray(Object o)
```
判断是否是包装类型的数组

Parameters:

o - 对象

Returns:

true 是包装类型的数组

isNotBaseArray
```
public static boolean isNotBaseArray(Object o)
```
判断是否不是基本类型的数组

Parameters:

o - 对象

Returns:

true 不是基本类型的数组

isWrapBaseArray
```
public static boolean isWrapBaseArray(Object o)
```
判断是否不是包装类型的数组

Parameters:

o - 对象

Returns:

true 不是包装类型的数组

gets
```
public static <T> T gets(Object arr,
                         int i)
```
获取数组下标对应的值

Type Parameters:

T - ignore

Parameters:

arr - 数组

i - 下标

Returns:

value

getIfPresent
```
public static <T> T getIfPresent(T[] arr,
                                 int i)
```
获取元素如果元素存在

Type Parameters:

T - T

Parameters:

arr - list

i - i

Returns:

T

get

public static <T> T get(T[] arr,
                        int i)

get

public static byte get(byte[] arr,
                       int i)

get

public static short get(short[] arr,
                        int i)

get

public static int get(int[] arr,
                      int i)

get

public static long get(long[] arr,
                       int i)

get

public static float get(float[] arr,
                        int i)

get

public static double get(double[] arr,
                         int i)

get

public static boolean get(boolean[] arr,
                          int i)

get

public static char get(char[] arr,
                       int i)

sets

public static <T> void sets(Object arr,
                            int i,
                            T value)

设置数组下标对应的值

Type Parameters:: T - ignore
Parameters:: arr - 数组; i - 下标; value - 值

set

public static <T> void set(T[] arr,
                           int i,
                           T value)

set

public static void set(byte[] arr,
                       int i,
                       byte value)

set

public static void set(short[] arr,
                       int i,
                       short value)

set

public static void set(int[] arr,
                       int i,
                       int value)

set

public static void set(long[] arr,
                       int i,
                       long value)

set

public static void set(float[] arr,
                       int i,
                       float value)

set

public static void set(double[] arr,
                       int i,
                       double value)

set

public static void set(boolean[] arr,
                       int i,
                       boolean value)

set

public static void set(char[] arr,
                       int i,
                       char value)

random
```
public static <T> T random(T[] arr)
```

random

public static byte random(byte[] arr)

random

public static short random(short[] arr)

random
```
public static int random(int[] arr)
```

random

public static long random(long[] arr)

random

public static float random(float[] arr)

random

public static double random(double[] arr)

random

public static boolean random(boolean[] arr)

random

public static char random(char[] arr)

mapper

public static <I,O> O[] mapper(I[] arr,
                               IntFunction<? extends O[]> generator,
                               Mapper<? super I,? extends O> mapper)

映射

Type Parameters:: I - 输入类型; O - 输出类型
Parameters:: arr - 需要映射的对象; generator - 数组创建接口 e.g. Integer[]::new; mapper - 映射接口
Returns:: 映射结果

reduce
```
public static <V,R> R reduce(V[] arr,
                             Reduce<? super V,? extends R> reduce)
```
规约

Type Parameters:

V - 数据类型

R - 规约类型

Parameters:

reduce - 规约接口

arr - 需要规约的对象该对象不能为基本类型的数组, 可以为基本类型的变量

Returns:

规约后的数据

compact
```
public static Object[] compact(Object[] arr)
```
去除数组中的 null

Parameters:

arr - 数组

Returns:

处理后的数组, 如果数组没有null则直接返回, 如果数组有null

compacts

public static <T> T[] compacts(T[] arr,
                               IntFunction<T[]> generator)

exclude
```
public static byte[] exclude(byte[] arr,
                             byte... es)
```
排除数组中指定的值

Parameters:

arr - 数组

es - 排除值

Returns:

处理后的数组, 如果数组没有包含的值则直接返回

exclude

public static short[] exclude(short[] arr,
                              short... es)

exclude

public static int[] exclude(int[] arr,
                            int... es)

exclude

public static long[] exclude(long[] arr,
                             long... es)

exclude

public static float[] exclude(float[] arr,
                              float... es)

exclude

public static double[] exclude(double[] arr,
                               double... es)

exclude

public static boolean[] exclude(boolean[] arr,
                                boolean... es)

exclude

public static char[] exclude(char[] arr,
                             char... es)

exclude
```
public static Object[] exclude(Object[] arr,
                               Object... es)
```
排除数组中指定的值

Parameters:

arr - 数组

es - 排除值这个值可以为基本类型的元素, 但是不能是基本类型的数组

Returns:

处理后的数组, 如果数组没有包含的值则直接返回

excludes

@SafeVarargs
public static <T> T[] excludes(T[] arr,
                                             IntFunction<T[]> generator,
                                             T... es)

excludes

public static <T> T[] excludes(T[] arr,
                               Predicate<T> p,
                               IntFunction<T[]> generator)

forEach

public static <T> void forEach(Consumer<T> consumer,
                               T[] arr)

消费对象

Type Parameters:: T - 对象类型
Parameters:: consumer - 消费函数; arr - 元素

forEach

public static void forEach(Consumer<Byte> consumer,
                           byte[] arr)

forEach

public static void forEach(Consumer<Short> consumer,
                           short[] arr)

forEach

public static void forEach(Consumer<Integer> consumer,
                           int[] arr)

forEach

public static void forEach(Consumer<Long> consumer,
                           long[] arr)

forEach

public static void forEach(Consumer<Float> consumer,
                           float[] arr)

forEach

public static void forEach(Consumer<Double> consumer,
                           double[] arr)

forEach

public static void forEach(Consumer<Character> consumer,
                           char[] arr)

forEach

public static void forEach(Consumer<Boolean> consumer,
                           boolean[] arr)

toByteArray

public static byte[] toByteArray(String s,
                                 String split)

toShortArray

public static short[] toShortArray(String s,
                                   String split)

toIntArray

public static int[] toIntArray(String s,
                               String split)

toLongArray

public static long[] toLongArray(String s,
                                 String split)

toFloatArray

public static float[] toFloatArray(String s,
                                   String split)

toDoubleArray

public static double[] toDoubleArray(String s,
                                     String split)

toBooleanArray

public static boolean[] toBooleanArray(String s,
                                       String split)

toStringArray

public static String[] toStringArray(String s,
                                     String split)

of
```
public static byte[] of(byte... arr)
```
将可变参数转化为数组

Parameters:

arr - 可边参数

Returns:

数组

of

public static short[] of(short... arr)

of
```
public static int[] of(int... arr)
```

of
```
public static long[] of(long... arr)
```

of

public static float[] of(float... arr)

of

public static double[] of(double... arr)

of

public static boolean[] of(boolean... arr)

of
```
public static char[] of(char... arr)
```

of
```
@SafeVarargs
public static <T> T[] of(T... arr)
```
不可接收基本类型的数组, 可以使用包装类否则会返回 T[][]

Type Parameters:

T - arr

Parameters:

arr - arr

Returns:

array

ofs
```
public static Object[] ofs(Object... arr)
```
可接收基本类型的数组, 返回Object[]

Parameters:

arr - arr

Returns:

array

isEmpties
```
public static boolean isEmpties(Object arr)
```
判断数组是否为空

Parameters:

arr - 数组

Returns:

true为空

isEmpty

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

isEmpty

public static boolean isEmpty(byte[] arr)

isEmpty

public static boolean isEmpty(short[] arr)

isEmpty

public static boolean isEmpty(int[] arr)

isEmpty

public static boolean isEmpty(long[] arr)

isEmpty

public static boolean isEmpty(float[] arr)

isEmpty

public static boolean isEmpty(double[] arr)

isEmpty

public static boolean isEmpty(boolean[] arr)

isEmpty

public static boolean isEmpty(char[] arr)

isNotEmpties
```
public static boolean isNotEmpties(Object arr)
```
判断数组是否不为空

Parameters:

arr - 数组

Returns:

true不为空

isNotEmpty

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

isNotEmpty

public static boolean isNotEmpty(byte[] arr)

isNotEmpty

public static boolean isNotEmpty(short[] arr)

isNotEmpty

public static boolean isNotEmpty(int[] arr)

isNotEmpty

public static boolean isNotEmpty(long[] arr)

isNotEmpty

public static boolean isNotEmpty(float[] arr)

isNotEmpty

public static boolean isNotEmpty(double[] arr)

isNotEmpty

public static boolean isNotEmpty(boolean[] arr)

isNotEmpty

public static boolean isNotEmpty(char[] arr)

def

public static <T> T[] def(T[] arr,
                          T[] def)

如果数组为空返回默认数组

Parameters:: arr - arr
Returns:: array

def

public static byte[] def(byte[] arr,
                         byte[] def)

def

public static short[] def(short[] arr,
                          short[] def)

def

public static int[] def(int[] arr,
                        int[] def)

def

public static long[] def(long[] arr,
                         long[] def)

def

public static float[] def(float[] arr,
                          float[] def)

def

public static double[] def(double[] arr,
                           double[] def)

def

public static boolean[] def(boolean[] arr,
                            boolean[] def)

def

public static char[] def(char[] arr,
                         char[] def)

def

public static <T> T[] def(T[] arr,
                          Supplier<T[]> def)

def

public static byte[] def(byte[] arr,
                         Supplier<byte[]> def)

def

public static short[] def(short[] arr,
                          Supplier<short[]> def)

def

public static int[] def(int[] arr,
                        Supplier<int[]> def)

def

public static long[] def(long[] arr,
                         Supplier<long[]> def)

def

public static float[] def(float[] arr,
                          Supplier<float[]> def)

def

public static double[] def(double[] arr,
                           Supplier<double[]> def)

def

public static boolean[] def(boolean[] arr,
                            Supplier<boolean[]> def)

def

public static char[] def(char[] arr,
                         Supplier<char[]> def)

lengths
```
public static int lengths(Object... arr)
```
获取数组长度

Parameters:

arr - 数组如果传参是一个基本类型数组, 返回值也是基本类型数组的长度

Returns:

长度
在默认情况下, 如果可变参数o, 传参是基本类型的数组, 使用length属性判断, o.length = 1

lens
```
public static int lens(Object arr)
```

resize

public static byte[] resize(byte[] arr,
                            int newSize)

调整数组大小

Parameters:: arr - 原数组; newSize - 新长度
Returns:: 新数组

resize

public static short[] resize(short[] arr,
                             int newSize)

resize

public static int[] resize(int[] arr,
                           int newSize)

resize

public static long[] resize(long[] arr,
                            int newSize)

resize

public static float[] resize(float[] arr,
                             int newSize)

resize

public static double[] resize(double[] arr,
                              int newSize)

resize

public static boolean[] resize(boolean[] arr,
                               int newSize)

resize

public static char[] resize(char[] arr,
                            int newSize)

resize

public static Object[] resize(Object[] arr,
                              int newSize)

resize

public static <T> T[] resize(T[] arr,
                             int newSize,
                             IntFunction<T[]> generator)

arraycopy
```
public static byte[] arraycopy(byte[] src,
                               int srcPos,
                               byte[] dest,
                               int destPos,
                               int length)
```
数组拷贝自动扩容2倍

Parameters:

src - 原数组

srcPos - 原数组起始位置

dest - 目标数组

destPos - 目标数组起始位置

length - 拷贝原数组几位到目标数组

Returns:

扩容返回新目标数组不扩容返回原目标数组

arraycopy

public static short[] arraycopy(short[] src,
                                int srcPos,
                                short[] dest,
                                int destPos,
                                int length)

arraycopy

public static int[] arraycopy(int[] src,
                              int srcPos,
                              int[] dest,
                              int destPos,
                              int length)

arraycopy

public static long[] arraycopy(long[] src,
                               int srcPos,
                               long[] dest,
                               int destPos,
                               int length)

arraycopy

public static float[] arraycopy(float[] src,
                                int srcPos,
                                float[] dest,
                                int destPos,
                                int length)

arraycopy

public static double[] arraycopy(double[] src,
                                 int srcPos,
                                 double[] dest,
                                 int destPos,
                                 int length)

arraycopy

public static boolean[] arraycopy(boolean[] src,
                                  int srcPos,
                                  boolean[] dest,
                                  int destPos,
                                  int length)

arraycopy

public static char[] arraycopy(char[] src,
                               int srcPos,
                               char[] dest,
                               int destPos,
                               int length)

arraycopy

public static Object[] arraycopy(Object[] src,
                                 int srcPos,
                                 Object[] dest,
                                 int destPos,
                                 int length)

arraycopys

public static <T> T[] arraycopys(T[] src,
                                 int srcPos,
                                 T[] dest,
                                 int destPos,
                                 int length,
                                 IntFunction<T[]> generator)

length

public static <T> int length(T[] arr)

length
```
public static int length(byte[] arr)
```

length

public static int length(short[] arr)

length
```
public static int length(int[] arr)
```

length
```
public static int length(long[] arr)
```

length

public static int length(float[] arr)

length

public static int length(double[] arr)

length
```
public static int length(char[] arr)
```

length

public static int length(boolean[] arr)

wrap
```
public static Byte[] wrap(byte[] w)
```
将数组转化为其包装类

Parameters:

w - 数组

Returns:

包装数组

wrap

public static Short[] wrap(short[] w)

wrap

public static Integer[] wrap(int[] arr)

wrap

public static Long[] wrap(long[] arr)

wrap

public static Float[] wrap(float[] arr)

wrap

public static Double[] wrap(double[] arr)

wrap

public static Boolean[] wrap(boolean[] arr)

wrap

public static Character[] wrap(char[] arr)

wrap

public static Object wrap(Object arr)

unWrap
```
public static byte[] unWrap(Byte[] arr)
```
将数组转化为其基本装类

Parameters:

arr - 数组

Returns:

基本数组

unWrap

public static short[] unWrap(Short[] arr)

unWrap

public static int[] unWrap(Integer[] arr)

unWrap

public static long[] unWrap(Long[] arr)

unWrap

public static float[] unWrap(Float[] arr)

unWrap

public static double[] unWrap(Double[] arr)

unWrap

public static boolean[] unWrap(Boolean[] arr)

unWrap

public static char[] unWrap(Character[] arr)

unWrap

public static Object unWrap(Object arr)

merges

@SafeVarargs
public static <T> T[] merges(IntFunction<T[]> generator,
                                           T[] arr,
                                           T[]... merge)

合并数组

Type Parameters:: T - ignore
Parameters:: generator - e.g. Integer[]::new; arr - 需要合并的数组; merge - 需要合并的数组
Returns:: 合并后的数组

merge

public static byte[] merge(byte[] arr,
                           byte[]... merge)

merge

public static short[] merge(short[] arr,
                            short[]... merge)

merge

public static int[] merge(int[] arr,
                          int[]... merge)

merge

public static long[] merge(long[] arr,
                           long[]... merge)

merge

public static float[] merge(float[] arr,
                            float[]... merge)

merge

public static double[] merge(double[] arr,
                             double[]... merge)

merge

public static boolean[] merge(boolean[] arr,
                              boolean[]... merge)

merge

public static char[] merge(char[] arr,
                           char[]... merge)

merge

public static Object[] merge(Object[] arr,
                             Object[]... merge)

indexOf
```
public static int indexOf(byte[] arr,
                          byte s,
                          int start)
```
查找第一个查询到的元素的位置

Parameters:

arr - 数组

s - 元素

start - 开始向后查找的下标

Returns:

位置

indexOf

public static int indexOf(short[] arr,
                          short s,
                          int start)

indexOf

public static int indexOf(int[] arr,
                          int s,
                          int start)

indexOf

public static int indexOf(long[] arr,
                          long s,
                          int start)

indexOf

public static int indexOf(float[] arr,
                          float s,
                          int start)

indexOf

public static int indexOf(double[] arr,
                          double s,
                          int start)

indexOf

public static int indexOf(char[] arr,
                          char s,
                          int start)

indexOf

public static int indexOf(boolean[] arr,
                          boolean s,
                          int start)

indexOf

public static <T> int indexOf(T[] arr,
                              T s,
                              int start)

indexOf

public static int indexOf(byte[] arr,
                          byte s)

indexOf

public static int indexOf(short[] arr,
                          short s)

indexOf

public static int indexOf(int[] arr,
                          int s)

indexOf

public static int indexOf(long[] arr,
                          long s)

indexOf

public static int indexOf(float[] arr,
                          float s)

indexOf

public static int indexOf(double[] arr,
                          double s)

indexOf

public static int indexOf(char[] arr,
                          char s)

indexOf

public static int indexOf(boolean[] arr,
                          boolean s)

indexOf

public static <T> int indexOf(T[] arr,
                              T s)

lastIndexOf
```
public static int lastIndexOf(byte[] arr,
                              byte s,
                              int start)
```
查找最后一个查询到的元素的位置

Parameters:

arr - 数组

s - 元素

start - 开始向前查找的下标

Returns:

位置

lastIndexOf

public static int lastIndexOf(short[] arr,
                              short s,
                              int start)

lastIndexOf

public static int lastIndexOf(int[] arr,
                              int s,
                              int start)

lastIndexOf

public static int lastIndexOf(long[] arr,
                              long s,
                              int start)

lastIndexOf

public static int lastIndexOf(float[] arr,
                              float s,
                              int start)

lastIndexOf

public static int lastIndexOf(double[] arr,
                              double s,
                              int start)

lastIndexOf

public static int lastIndexOf(char[] arr,
                              char s,
                              int start)

lastIndexOf

public static int lastIndexOf(boolean[] arr,
                              boolean s,
                              int start)

lastIndexOf

public static <T> int lastIndexOf(T[] arr,
                                  T s,
                                  int start)

lastIndexOf

public static int lastIndexOf(byte[] arr,
                              byte s)

lastIndexOf

public static int lastIndexOf(short[] arr,
                              short s)

lastIndexOf

public static int lastIndexOf(int[] arr,
                              int s)

lastIndexOf

public static int lastIndexOf(long[] arr,
                              long s)

lastIndexOf

public static int lastIndexOf(float[] arr,
                              float s)

lastIndexOf

public static int lastIndexOf(double[] arr,
                              double s)

lastIndexOf

public static int lastIndexOf(char[] arr,
                              char s)

lastIndexOf

public static int lastIndexOf(boolean[] arr,
                              boolean s)

lastIndexOf

public static <T> int lastIndexOf(T[] arr,
                                  T s)

contains
```
public static boolean contains(byte[] arr,
                               byte s)
```
判断数组是否包含某个元素

Parameters:

arr - 数组

s - 元素

Returns:

true包含

contains

public static boolean contains(short[] arr,
                               short s)

contains

public static boolean contains(int[] arr,
                               int s)

contains

public static boolean contains(long[] arr,
                               long s)

contains

public static boolean contains(float[] arr,
                               float s)

contains

public static boolean contains(double[] arr,
                               double s)

contains

public static boolean contains(char[] arr,
                               char s)

contains

public static boolean contains(boolean[] arr,
                               boolean s)

contains

public static <T> boolean contains(T[] arr,
                                   T s)

count
```
@SafeVarargs
public static <T> int count(T target,
                                          T... arr)
```
查询目标元素在数组中出现的次数

Parameters:

target - 目标元素

arr - 数组可以传基本类型的元素但是不可以传基本类型的数组

Returns:

次数

count

public static int count(byte target,
                        byte... arr)

count

public static int count(short target,
                        short... arr)

count

public static int count(int target,
                        int... arr)

count

public static int count(long target,
                        long... arr)

count

public static int count(float target,
                        float... arr)

count

public static int count(double target,
                        double... arr)

count

public static int count(boolean target,
                        boolean... arr)

count

public static int count(char target,
                        char... arr)

some
```
@SafeVarargs
public static <T> boolean some(T target,
                                             T... arr)
```
查询目标元素是否出现在数组中

Parameters:

target - 目标元素

arr - 数组, 可以传基本类型的元素, 但是不可以传基本类型的数组

Returns:

true 出现

some

public static boolean some(byte target,
                           byte... arr)

some

public static boolean some(short target,
                           short... arr)

some

public static boolean some(int target,
                           int... arr)

some

public static boolean some(long target,
                           long... arr)

some

public static boolean some(float target,
                           float... arr)

some

public static boolean some(double target,
                           double... arr)

some

public static boolean some(char target,
                           char... arr)

some

public static boolean some(boolean target,
                           boolean... arr)

reverse

public static void reverse(byte[] arr)

数组倒排

Parameters:: arr - 数组

reverse

public static void reverse(short[] arr)

reverse

public static void reverse(int[] arr)

reverse

public static void reverse(long[] arr)

reverse

public static void reverse(float[] arr)

reverse

public static void reverse(double[] arr)

reverse

public static void reverse(char[] arr)

reverse

public static void reverse(boolean[] arr)

reverse

public static <T> void reverse(T[] arr)

first
```
public static <T> T first(T[] arr)
```
获取数组第一个元素

Parameters:

arr - array

Returns:

第一个元素长度为0则抛出异常

first
```
public static byte first(byte[] arr)
```

first

public static short first(short[] array)

first
```
public static int first(int[] arr)
```

first
```
public static long first(long[] arr)
```

first

public static float first(float[] arr)

first

public static double first(double[] arr)

first

public static boolean first(boolean[] arr)

first
```
public static char first(char[] arr)
```

first
```
public static <T> T first(T[] arr,
                          T def)
```
获取数组第一个元素

Parameters:

arr - array

def - 默认值

Returns:

第一个元素

first

public static byte first(byte[] arr,
                         byte def)

first

public static short first(short[] arr,
                          short def)

first

public static int first(int[] arr,
                        int def)

first

public static long first(long[] arr,
                         long def)

first

public static float first(float[] arr,
                          float def)

first

public static double first(double[] arr,
                           double def)

first

public static boolean first(boolean[] arr,
                            boolean def)

first

public static char first(char[] arr,
                         char def)

last
```
public static <T> T last(T[] arr)
```
获取数组最后一个元素

Parameters:

arr - array

Returns:

第一个元素长度为0则抛出异常

last
```
public static byte last(byte[] arr)
```

last

public static short last(short[] arr)

last
```
public static int last(int[] arr)
```

last
```
public static long last(long[] arr)
```

last

public static float last(float[] arr)

last

public static double last(double[] arr)

last

public static boolean last(boolean[] arr)

last
```
public static char last(char[] arr)
```

last
```
public static <T> T last(T[] arr,
                         T def)
```
获取数组最后一个元素

Parameters:

arr - array

def - 默认值

Returns:

第一个元素

last

public static byte last(byte[] arr,
                        byte def)

last

public static short last(short[] arr,
                         short def)

last

public static int last(int[] arr,
                       int def)

last

public static long last(long[] arr,
                        long def)

last

public static float last(float[] arr,
                         float def)

last

public static double last(double[] arr,
                          double def)

last

public static boolean last(boolean[] arr,
                           boolean def)

last

public static char last(char[] arr,
                        char def)

unChangeSwap

public static void unChangeSwap(byte[] arr,
                                int i,
                                int j)

换位

Parameters:: arr - 数组; i - 换位的元素1; j - 换位的元素2

swap

public static void swap(byte[] arr,
                        int i,
                        int j)

swap

public static void swap(short[] arr,
                        int i,
                        int j)

swap

public static void swap(int[] arr,
                        int i,
                        int j)

swap

public static void swap(long[] arr,
                        int i,
                        int j)

swap

public static void swap(float[] arr,
                        int i,
                        int j)

swap

public static void swap(double[] arr,
                        int i,
                        int j)

swap

public static void swap(char[] arr,
                        int i,
                        int j)

swap

public static void swap(boolean[] arr,
                        int i,
                        int j)

swap

public static <T> void swap(T[] arr,
                            int i,
                            int j)

max
```
public static byte max(byte[] arr)
```
最大值

Parameters:

arr - 数组

Returns:

最大值

max
```
public static short max(short[] arr)
```

max
```
public static int max(int[] arr)
```

max
```
public static long max(long[] arr)
```

max
```
public static float max(float[] arr)
```

max

public static double max(double[] arr)

max
```
public static char max(char[] arr)
```

max

public static <T extends Comparable<T>> T max(T[] arr)

max

public static <T> T max(T[] arr,
                        Comparator<T> c)

min
```
public static byte min(byte[] arr)
```
最小值

Parameters:

arr - 数组

Returns:

最小值

min
```
public static short min(short[] arr)
```

min
```
public static int min(int[] arr)
```

min
```
public static long min(long[] arr)
```

min
```
public static float min(float[] arr)
```

min

public static double min(double[] arr)

min
```
public static char min(char[] arr)
```

min

public static <T extends Comparable<T>> T min(T[] arr)

min

public static <T> T min(T[] arr,
                        Comparator<T> c)

hashCode
```
public static int hashCode(Object[] arr)
```
获取数组的hashCode

Parameters:

arr - arr

Returns:

hashCode

hashCode

public static int hashCode(byte[] arr)

hashCode

public static int hashCode(short[] arr)

hashCode

public static int hashCode(int[] arr)

hashCode

public static int hashCode(long[] arr)

hashCode

public static int hashCode(float[] arr)

hashCode

public static int hashCode(double[] arr)

hashCode

public static int hashCode(boolean[] arr)

hashCode

public static int hashCode(char[] arr)

arrayEquals

public static boolean arrayEquals(Object o1,
                                  Object o2)

判断数组是否相等

Parameters:: o1 - o1; o2 - o2
Returns:: ignore

Class Arrays1

Method Summary

Methods inherited from class java.lang.Object

Method Detail

newBytes

newShorts

newInts

newLongs

newFloats

newDoubles

newChars

newBooleans

newObjects

newArrays

newArrays

isArray

isBaseArray

isWrapArray

isNotBaseArray

isWrapBaseArray

gets

getIfPresent

get

get

get

get

get

get

get

get

get

sets

set

set

set

set

set

set

set

set

set

random

random

random

random

random

random

random

random

random

mapper

reduce

compact

compacts

exclude

exclude

exclude

exclude

exclude

exclude

exclude

exclude

exclude

excludes

excludes

forEach

forEach

forEach

forEach

forEach

forEach

forEach

forEach

forEach

toByteArray

toShortArray

toIntArray

toLongArray

toFloatArray

toDoubleArray