PrimitiveArrays (langx-java 3.3.2 API)

java.lang.Object
- com.jn.langx.util.collection.PrimitiveArrays

public class PrimitiveArrays
extends Object

Primitive array wrapper

字段概要

字段
限定符和类型	字段和说明
`static Class`	`BOOLEAN_ARRAY_CLASS`
`static Class`	`BYTE_ARRAY_CLASS`
`static Class`	`CHAR_ARRAY_CLASS`
`static Class`	`DOUBLE_ARRAY_CLASS`
`static Class`	`FLOAT_ARRAY_CLASS`
`static Class`	`INT_ARRAY_CLASS`
`static Class`	`LONG_ARRAY_CLASS`
`static Class`	`SHORT_ARRAY_CLASS`

构造器概要

构造器
构造器和说明

PrimitiveArrays()

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

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static boolean`	`equals(boolean[] a, boolean[] a2)` Returns `true` if the two specified arrays of booleans are equal to one another.
`static boolean`	`equals(boolean[] a, Boolean[] a2)`
`static boolean`	`equals(byte[] a, byte[] a2)` Returns `true` if the two specified arrays of bytes are equal to one another.
`static boolean`	`equals(byte[] a, Byte[] a2)`
`static boolean`	`equals(char[] a, char[] a2)` Returns `true` if the two specified arrays of chars are equal to one another.
`static boolean`	`equals(char[] a, Character[] a2)`
`static boolean`	`equals(double[] a, double[] a2)` Returns `true` if the two specified arrays of doubles are equal to one another.
`static boolean`	`equals(double[] a, Double[] a2)`
`static boolean`	`equals(float[] a, float[] a2)` Returns `true` if the two specified arrays of floats are equal to one another.
`static boolean`	`equals(float[] a, Float[] a2)`
`static boolean`	`equals(int[] a, int[] a2)` Returns `true` if the two specified arrays of ints are equal to one another.
`static boolean`	`equals(int[] a, Integer[] a2)`
`static boolean`	`equals(long[] a, long[] a2)` Returns `true` if the two specified arrays of longs are equal to one another.
`static boolean`	`equals(long[] a, Long[] a2)`
`static boolean`	`equals(Object[] a, Object[] a2)` Returns `true` if the two specified arrays of Objects are equal to one another.
`static boolean`	`equals(short[] a, short[] a2)` Returns `true` if the two specified arrays of shorts are equal to one another.
`static boolean`	`equals(short[] a, Short[] a2)`
`static boolean`	`isPrimitiveArray(Class clazz)`
`static boolean[]`	`unwrap(Boolean[] values, boolean resultNullable)` convert a Boolean[] to a boolean[]
`static byte[]`	`unwrap(Byte[] values, boolean resultNullable)` convert a Byte[] to a byte[]
`static char[]`	`unwrap(Character[] values, boolean resultNullable)` convert a Character[] to a char[]
`static double[]`	`unwrap(Double[] values, boolean resultNullable)` convert a Double[] to a double[]
`static float[]`	`unwrap(Float[] values, boolean resultNullable)` convert a Float[] to a float[]
`static int[]`	`unwrap(Integer[] values, boolean resultNullable)` convert a Integer[] to a int[]
`static long[]`	`unwrap(Long[] values, boolean resultNullable)` convert a Long[] to a long[]
`static short[]`	`unwrap(Short[] values, boolean resultNullable)` convert a Short[] to a short[]
`static Boolean[]`	`wrap(boolean[] values, boolean resultNullable)` convert a boolean[] to a Boolean[]
`static Byte[]`	`wrap(byte[] values, boolean resultNullable)` convert a byte[] to a Byte[]
`static Character[]`	`wrap(char[] values, boolean resultNullable)` convert a char[] to a Character[]
`static Double[]`	`wrap(double[] values, boolean resultNullable)` convert a double[] to a Double[]
`static Float[]`	`wrap(float[] values, boolean resultNullable)` convert a float[] to a Float[]
`static Integer[]`	`wrap(int[] values, boolean resultNullable)` convert a int[] to a Integer[]
`static Long[]`	`wrap(long[] values, boolean resultNullable)` convert a long[] to a Long[]
`static <E> E[]`	`wrap(Object o)`
`static Short[]`	`wrap(short[] values, boolean resultNullable)` convert a short[] to a Short[]

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

- 字段详细资料
  - BYTE_ARRAY_CLASS
```
public static final Class BYTE_ARRAY_CLASS
```
  - SHORT_ARRAY_CLASS
```
public static final Class SHORT_ARRAY_CLASS
```
  - INT_ARRAY_CLASS
```
public static final Class INT_ARRAY_CLASS
```
  - LONG_ARRAY_CLASS
```
public static final Class LONG_ARRAY_CLASS
```
  - FLOAT_ARRAY_CLASS
```
public static final Class FLOAT_ARRAY_CLASS
```
  - DOUBLE_ARRAY_CLASS
```
public static final Class DOUBLE_ARRAY_CLASS
```
  - CHAR_ARRAY_CLASS
```
public static final Class CHAR_ARRAY_CLASS
```
  - BOOLEAN_ARRAY_CLASS
```
public static final Class BOOLEAN_ARRAY_CLASS
```
- 构造器详细资料
  - PrimitiveArrays
```
public PrimitiveArrays()
```
- 方法详细资料
  - isPrimitiveArray
```
public static boolean isPrimitiveArray(Class clazz)
```
  - wrap
```
public static <E> E[] wrap(Object o)
```
  - wrap
```
public static Boolean[] wrap(@Nullable
                             boolean[] values,
                             boolean resultNullable)
```
    convert a boolean[] to a Boolean[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static boolean[] unwrap(@Nullable
                               Boolean[] values,
                               boolean resultNullable)
```
    convert a Boolean[] to a boolean[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Character[] wrap(@Nullable
                               char[] values,
                               boolean resultNullable)
```
    convert a char[] to a Character[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static char[] unwrap(@Nullable
                            Character[] values,
                            boolean resultNullable)
```
    convert a Character[] to a char[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Byte[] wrap(@Nullable
                          byte[] values,
                          boolean resultNullable)
```
    convert a byte[] to a Byte[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static byte[] unwrap(@Nullable
                            Byte[] values,
                            boolean resultNullable)
```
    convert a Byte[] to a byte[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Short[] wrap(@Nullable
                           short[] values,
                           boolean resultNullable)
```
    convert a short[] to a Short[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static short[] unwrap(@Nullable
                             Short[] values,
                             boolean resultNullable)
```
    convert a Short[] to a short[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Integer[] wrap(@Nullable
                             int[] values,
                             boolean resultNullable)
```
    convert a int[] to a Integer[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static int[] unwrap(@Nullable
                           Integer[] values,
                           boolean resultNullable)
```
    convert a Integer[] to a int[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Float[] wrap(@Nullable
                           float[] values,
                           boolean resultNullable)
```
    convert a float[] to a Float[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static float[] unwrap(@Nullable
                             Float[] values,
                             boolean resultNullable)
```
    convert a Float[] to a float[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Long[] wrap(@Nullable
                          long[] values,
                          boolean resultNullable)
```
    convert a long[] to a Long[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static long[] unwrap(@Nullable
                            Long[] values,
                            boolean resultNullable)
```
    convert a Long[] to a long[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - wrap
```
public static Double[] wrap(@Nullable
                            double[] values,
                            boolean resultNullable)
```
    convert a double[] to a Double[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - unwrap
```
public static double[] unwrap(@Nullable
                              Double[] values,
                              boolean resultNullable)
```
    convert a Double[] to a double[]
    
    参数:
    
    values - source
    
    resultNullable - whether return null when source is null or not
    
    返回:
    
    result
  - equals
```
public static boolean equals(long[] a,
                             long[] a2)
```
    Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(long[] a,
                             Long[] a2)
```
  - equals
```
public static boolean equals(int[] a,
                             int[] a2)
```
    Returns true if the two specified arrays of ints are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(int[] a,
                             Integer[] a2)
```
  - equals
```
public static boolean equals(short[] a,
                             short[] a2)
```
    Returns true if the two specified arrays of shorts are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(short[] a,
                             Short[] a2)
```
  - equals
```
public static boolean equals(char[] a,
                             char[] a2)
```
    Returns true if the two specified arrays of chars are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(char[] a,
                             Character[] a2)
```
  - equals
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    Returns true if the two specified arrays of bytes are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(byte[] a,
                             Byte[] a2)
```
  - equals
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    Returns true if the two specified arrays of booleans are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
  - equals
```
public static boolean equals(boolean[] a,
                             Boolean[] a2)
```
  - equals
```
public static boolean equals(double[] a,
                             double[] a2)
```
    Returns true if the two specified arrays of doubles are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    Two doubles d1 and d2 are considered equal if:
```
    new Double(d1).equals(new Double(d2))
```
    (Unlike the == operator, this method considers NaN equals to itself, and 0.0d unequal to -0.0d.)
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
    
    另请参阅:
    
    Double.equals(Object)
  - equals
```
public static boolean equals(double[] a,
                             Double[] a2)
```
  - equals
```
public static boolean equals(float[] a,
                             float[] a2)
```
    Returns true if the two specified arrays of floats are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    Two floats f1 and f2 are considered equal if:
```
    new Float(f1).equals(new Float(f2))
```
    (Unlike the == operator, this method considers NaN equals to itself, and 0.0f unequal to -0.0f.)
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal
    
    另请参阅:
    
    Float.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             Float[] a2)
```
  - equals
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    Returns true if the two specified arrays of Objects are equal to one another. The two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. Two objects e1 and e2 are considered equal if (e1==null ? e2==null : e1.equals(e2)). In other words, the two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.
    
    参数:
    
    a - one array to be tested for equality
    
    a2 - the other array to be tested for equality
    
    返回:
    
    true if the two arrays are equal

类 PrimitiveArrays

字段概要

构造器概要

方法概要

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

字段详细资料

BYTE_ARRAY_CLASS

SHORT_ARRAY_CLASS

INT_ARRAY_CLASS

LONG_ARRAY_CLASS

FLOAT_ARRAY_CLASS

DOUBLE_ARRAY_CLASS

CHAR_ARRAY_CLASS

BOOLEAN_ARRAY_CLASS

构造器详细资料

PrimitiveArrays

方法详细资料

isPrimitiveArray

wrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

wrap

unwrap

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals