org.nervousync.utils.ObjectUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of utils-jdk11 Show documentation
Show all versions of utils-jdk11 Show documentation
Java utility collections, development by Nervousync Studio (NSYC)
/*
* Licensed to the Nervousync Studio (NSYC) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.nervousync.utils;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Optional;
import org.nervousync.commons.Globals;
/**
* Object Operate Utilities
* 对象操作工具集
*
* @author Steven Wee [email protected]
* @version $Revision: 1.1.4 $ $Date: Jan 13, 2010 16:26:58 $
*/
public final class ObjectUtils {
/**
* Logger instance
* 日志实例
*/
private static final LoggerUtils.Logger LOGGER = LoggerUtils.getLogger(ObjectUtils.class);
/**
* Constant value of array start character
* 数组起始字符常量值
*/
private static final String ARRAY_START = "[";
/**
* Constant value of array end character
* 数组终止字符常量值
*/
private static final String ARRAY_END = "]";
/**
* Constant value of array separator character
* 数组元素分割字符常量值
*/
private static final String ARRAY_ELEMENT_SEPARATOR = ", ";
/**
* Private constructor for ObjectUtils
* 对象操作工具集的私有构造方法
*/
private ObjectUtils() {
}
/**
* Create a object instance by invoke non-args constructor method
* 通过调用无参构造函数方法创建对象实例
*
* @param define class
* 定义类
* @param clazz define class
* 定义类
*
* @return Created object instance
* 创建的对象实例
*/
public static T newInstance(final Class clazz) {
return newInstance(clazz, new Object[0]);
}
/**
* Create a object instance by invoke constructor method as given parameter values
* 通过给定参数值作为参数来调用构造方法创建对象实例
*
* @param define class
* 定义类
* @param clazz define class
* 定义类
* @param paramValues Parameter values
* 参数值
*
* @return Created object instance
* 创建的对象实例
*/
public static T newInstance(final Class clazz, final Object[] paramValues) {
if (clazz == null) {
return null;
}
Constructor constructor;
try {
if (paramValues == null || paramValues.length == 0) {
constructor = ReflectionUtils.findConstructor(clazz);
if (!Modifier.isPublic(clazz.getModifiers()) || !ReflectionUtils.publicMember(constructor)) {
ReflectionUtils.makeAccessible(constructor);
}
return constructor.newInstance();
} else {
Class[] paramTypes = new Class[paramValues.length];
for (int i = 0; i < paramValues.length; i++) {
paramTypes[i] = paramValues[i].getClass();
}
constructor = ReflectionUtils.findConstructor(clazz, paramTypes);
if (!Modifier.isPublic(clazz.getModifiers()) || !ReflectionUtils.publicMember(constructor)) {
ReflectionUtils.makeAccessible(constructor);
}
return constructor.newInstance(paramValues);
}
} catch (SecurityException | NoSuchMethodException | InstantiationException
| IllegalAccessException | InvocationTargetException e) {
LOGGER.error("Create_Instance_Object_Error");
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Stack_Message_Error", e);
}
}
return null;
}
/**
* Create a proxy object instance
* 创建代理对象实例
*
* @param define class
* 定义类
* @param clazz define class
* 定义类
* @param methodInterceptor method interceptor instance
* 方法拦截器实例
*
* @return Created proxy object instance
* 创建的代理对象实例
*/
public static T newInstance(final Class clazz, final InvocationHandler methodInterceptor) {
return newInstance(clazz, new Class[]{clazz}, methodInterceptor);
}
/**
* Create a proxy object instance
* 创建代理对象实例
*
* @param define class
* 定义类
* @param clazz define class
* 定义类
* @param interfaceClasses Interface class array
* 接口类数组
* @param invocationHandler method interceptor instance
* 方法拦截器实例
*
* @return Created proxy object instance
* 创建的代理对象实例
*/
public static T newInstance(final Class clazz, final Class[] interfaceClasses,
final InvocationHandler invocationHandler) {
if (clazz == null || invocationHandler == null) {
return newInstance(clazz);
}
Class[] interfaces;
if (interfaceClasses == null || interfaceClasses.length == 0) {
interfaces = new Class[]{clazz};
} else {
interfaces = interfaceClasses;
}
return clazz.cast(Proxy.newProxyInstance(clazz.getClassLoader(), interfaces, invocationHandler));
}
/**
* Return whether the given object is empty: that is, null or a collection of zero-length.
* 返回给定对象是否为空：即 null 或长度为零的集合。
*
* @param object the object to check
* 检查对象
*
* @return whether the given object is null or collection is empty
* 给定对象是否为 null 或集合是否为空
*/
public static boolean isNull(final Object object) {
if (object == null) {
return Boolean.TRUE;
}
if (object.getClass().isArray()) {
return (Array.getLength(object) == 0);
} else {
if (object instanceof String) {
return (((String) object).length() == 0);
}
}
return Boolean.FALSE;
}
//---------------------------------------------------------------------
// Convenience methods for content-based equality/hash-code handling
//---------------------------------------------------------------------
/**
* Determine if the given objects are equal.
*
* Returning Boolean.TRUE if both are null
* or Boolean.FALSE if only one is null.
* Compares arrays with Arrays.equals, performing an equality
* check based on the array elements rather than the array reference.
*
* 确定给定的对象是否相等。
*
* 如果两者都为 null，则返回 Boolean.TRUE；
* 如果只有一个为 null，则返回 Boolean.FALSE。
* 将数组与 Arrays.equals 进行比较，根据数组元素而不是数组引用执行相等性检查。
*
* @see java.util.Arrays#equals
*
* @param o1 first Object to compare
* 第一个要比较的对象
* @param o2 second Object to compare
* 第二个要比较的对象
*
* @return whether the given objects are equal
* 给定的对象是否相等
*/
public static boolean nullSafeEquals(final Object o1, final Object o2) {
if (o1 == o2) {
return Boolean.TRUE;
}
if (o1 == null || o2 == null) {
return Boolean.FALSE;
}
if (o1.equals(o2)) {
return Boolean.TRUE;
}
if (o1.getClass().isArray() && o2.getClass().isArray()) {
if (o1 instanceof Object[] && o2 instanceof Object[]) {
return Arrays.equals((Object[]) o1, (Object[]) o2);
}
if (o1 instanceof boolean[] && o2 instanceof boolean[]) {
return Arrays.equals((boolean[]) o1, (boolean[]) o2);
}
if (o1 instanceof byte[] && o2 instanceof byte[]) {
return Arrays.equals((byte[]) o1, (byte[]) o2);
}
if (o1 instanceof char[] && o2 instanceof char[]) {
return Arrays.equals((char[]) o1, (char[]) o2);
}
if (o1 instanceof double[] && o2 instanceof double[]) {
return Arrays.equals((double[]) o1, (double[]) o2);
}
if (o1 instanceof float[] && o2 instanceof float[]) {
return Arrays.equals((float[]) o1, (float[]) o2);
}
if (o1 instanceof int[] && o2 instanceof int[]) {
return Arrays.equals((int[]) o1, (int[]) o2);
}
if (o1 instanceof long[] && o2 instanceof long[]) {
return Arrays.equals((long[]) o1, (long[]) o2);
}
if (o1 instanceof short[] && o2 instanceof short[]) {
return Arrays.equals((short[]) o1, (short[]) o2);
}
}
return Boolean.FALSE;
}
/**
* Return as hash code for the given object; typically the value of Object#hashCode().
*
* If the object is an array, this method will delegate to any of the nullSafeHashCode
* methods for arrays in this class.
* If the object is null, this method returns 0.
*
* 返回给定对象的哈希码；通常是 Object#hashCode() 的值。
*
* 如果对象是数组，则此方法将委托给此类中数组的任何 ObjectUtils#nullSafeHashCode 方法。
* 如果对象为 null，则此方法返回 0。
*
* @see ObjectUtils#nullSafeHashCode(Object[])
* @see ObjectUtils#nullSafeHashCode(boolean[])
* @see ObjectUtils#nullSafeHashCode(byte[])
* @see ObjectUtils#nullSafeHashCode(char[])
* @see ObjectUtils#nullSafeHashCode(double[])
* @see ObjectUtils#nullSafeHashCode(float[])
* @see ObjectUtils#nullSafeHashCode(int[])
* @see ObjectUtils#nullSafeHashCode(long[])
* @see ObjectUtils#nullSafeHashCode(short[])
*
* @param obj given object
* 给定对象
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final Object obj) {
if (obj == null) {
return 0;
}
if (obj.getClass().isArray()) {
if (obj instanceof Object[]) {
return nullSafeHashCode((Object[]) obj);
}
if (obj instanceof boolean[]) {
return nullSafeHashCode((boolean[]) obj);
}
if (obj instanceof byte[]) {
return nullSafeHashCode((byte[]) obj);
}
if (obj instanceof char[]) {
return nullSafeHashCode((char[]) obj);
}
if (obj instanceof double[]) {
return nullSafeHashCode((double[]) obj);
}
if (obj instanceof float[]) {
return nullSafeHashCode((float[]) obj);
}
if (obj instanceof int[]) {
return nullSafeHashCode((int[]) obj);
}
if (obj instanceof long[]) {
return nullSafeHashCode((long[]) obj);
}
if (obj instanceof short[]) {
return nullSafeHashCode((short[]) obj);
}
}
return obj.hashCode();
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final Object[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (Object anArray : array) {
hash = Globals.MULTIPLIER * hash + nullSafeHashCode(anArray);
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果 参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final boolean[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (boolean bool : array) {
hash = Globals.MULTIPLIER * hash + hashCode(bool);
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If byte array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果字节数组为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final byte[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (byte b : array) {
hash = Globals.MULTIPLIER * hash + b;
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final char[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (char c : array) {
hash = Globals.MULTIPLIER * hash + c;
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final double[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (double d : array) {
hash = Globals.MULTIPLIER * hash + hashCode(d);
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final float[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (float f : array) {
hash = Globals.MULTIPLIER * hash + hashCode(f);
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final int[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (int i : array) {
hash = Globals.MULTIPLIER * hash + i;
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final long[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (long l : array) {
hash = Globals.MULTIPLIER * hash + hashCode(l);
}
return hash;
}
/**
* Return a hash code based on the contents of the specified array.
* If argument array is null, this method returns 0.
* 根据指定数组的内容返回哈希码。
* 如果参数 array 为null，则此方法返回0。
*
* @param array specified array
* 指定数组
*
* @return object hash code
* 对象哈希值
*/
public static int nullSafeHashCode(final short[] array) {
if (array == null) {
return 0;
}
int hash = Globals.INITIALIZE_INT_VALUE;
for (short s : array) {
hash = Globals.MULTIPLIER * hash + s;
}
return hash;
}
/**
* Return the same value as Boolean#hashCode().
* 返回与 Boolean#hashCode() 相同的值。
* @see Boolean#hashCode()
*
* @param bool boolean value
* 布尔值
*
* @return object hash code
* 对象哈希值
*/
public static int hashCode(final boolean bool) {
return bool ? 1231 : 1237;
}
/**
* Return the same value as Double#hashCode().
* 返回与 Double#hashCode() 相同的值。
* @see Double#hashCode()
*
* @param dbl double value
* 双精度值
*
* @return object hash code
* 对象哈希值
*/
public static int hashCode(final double dbl) {
return hashCode(Double.doubleToLongBits(dbl));
}
/**
* Return the same value as Float#hashCode().
* 返回与 Float#hashCode() 相同的值。
* @see Float#hashCode()
*
* @param flt float value
* 浮点数值
*
* @return object hash code
* 对象哈希值
*/
public static int hashCode(final float flt) {
return Float.floatToIntBits(flt);
}
/**
* Return the same value as Long#hashCode().
* 返回与 Long#hashCode() 相同的值。
* @see Long#hashCode()
*
* @param lng long value
* 长整形值
*
* @return object hash code
* 对象哈希值
*/
public static int hashCode(final long lng) {
return (int) (lng ^ (lng >>> 32));
}
/**
* Determine the class name for the given object.
* Returns empty string if argument obj is null.
* 确定给定对象的类名。
* 如果参数 obj 为 null，则返回空字符串。
*
* @param obj the object to introspect (maybe null)
* 要获取类名的对象（可能null）
*
* @return the corresponding class name
* 对应的类名
*/
public static String nullSafeClassName(final Object obj) {
return obj != null ? nullSafeClassName(obj.getClass()) : Globals.DEFAULT_VALUE_STRING;
}
/**
* Determine the class name for the given object.
* Returns empty string if argument clazz is null.
* 确定给定对象的类名。
* 如果参数 clazz 为 null，则返回空字符串。
*
* @param clazz the object to introspect (maybe null)
* 要获取类名的对象（可能null）
*
* @return the corresponding class name
* 对应的类名
*/
public static String nullSafeClassName(final Class clazz) {
return (clazz != null ? clazz.getName() : Globals.DEFAULT_VALUE_STRING);
}
//---------------------------------------------------------------------
// Convenience methods for toString output
//---------------------------------------------------------------------
/**
* Return a String representation of the specified Object.
*
* Builds a String representation of the contents in case of an array.
* Returns empty string if argument obj is null.
*
* 返回指定对象的字符串表示形式。
* 如果是数组，则构建内容的字符串表示形式。如果参数 obj 为 null，则返回空字符串。
*
* @param obj the object to build a String representation for
* 为其构建字符串表示的对象
*
* @return a String representation of argument obj
* 参数 obj 的字符串表示形式
*/
public static String nullSafeToString(final Object obj) {
if (obj == null) {
return Globals.DEFAULT_VALUE_STRING;
}
if (obj instanceof String) {
return (String) obj;
}
if (ClassUtils.isPrimitiveArray(obj.getClass())) {
if (obj instanceof boolean[]) {
return nullSafeToString((boolean[]) obj);
}
if (obj instanceof byte[]) {
return nullSafeToString((byte[]) obj);
}
if (obj instanceof char[]) {
return nullSafeToString((char[]) obj);
}
if (obj instanceof double[]) {
return nullSafeToString((double[]) obj);
}
if (obj instanceof float[]) {
return nullSafeToString((float[]) obj);
}
if (obj instanceof int[]) {
return nullSafeToString((int[]) obj);
}
if (obj instanceof long[]) {
return nullSafeToString((long[]) obj);
}
if (obj instanceof short[]) {
return nullSafeToString((short[]) obj);
}
return ARRAY_START + ARRAY_END;
} else if (obj instanceof Class[]) {
return nullSafeToString((Class[]) obj);
} else if (obj.getClass().isArray()) {
return nullSafeToString(CollectionUtils.toArray(obj));
} else if (obj.getClass().isPrimitive()) {
return Optional.ofNullable(ClassUtils.primitiveWrapper(obj.getClass()))
.map(wrapperClass -> ReflectionUtils.findMethod(wrapperClass, "toString", new Class[]{obj.getClass()}))
.map(method -> (String) ReflectionUtils.invokeMethod(method, null, new Object[]{obj}))
.orElse(Globals.DEFAULT_VALUE_STRING);
} else {
return obj.toString();
}
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Class[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Class[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Class[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Class[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果 参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final boolean[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果 参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final boolean[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果 参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final boolean[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果 参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final boolean[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of byte array
* 字节数组的字符串表示形式
*/
public static String nullSafeToString(final byte[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of byte array
* 字节数组的字符串表示形式
*/
public static String nullSafeToString(final byte[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of byte array
* 字节数组的字符串表示形式
*/
public static String nullSafeToString(final byte[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of byte array
* 字节数组的字符串表示形式
*/
public static String nullSafeToString(final byte[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final char[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final char[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final char[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final char[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final double[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final double[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final double[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final double[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final float[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果 argument processCompletion为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final float[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final float[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final float[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final int[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final int[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final int[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final int[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final long[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final long[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final long[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final long[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final short[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final short[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final short[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final short[] array, final String separator,
final boolean processCompletion) {
return nullSafeToString(CollectionUtils.toArray(array), separator, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Object[] array) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements.
* Adjacent elements are separated by the characters ", " (a comma followed by a space).
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由字符 ", "（逗号后跟空格）分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Object[] array, final boolean processCompletion) {
return nullSafeToString(array, ARRAY_ELEMENT_SEPARATOR, processCompletion);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* enclosed in brackets ("[]").
* Adjacent elements are separated by the argument separator characters.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，括在中括号 ("[]") 中。
* 相邻元素由参数 separator 字符分隔。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Object[] array, final String separator) {
return nullSafeToString(array, separator, Boolean.TRUE);
}
/**
* Return a String representation of the contents of the specified array.
*
* The String representation consists of a list of the array's elements,
* Adjacent elements are separated by the argument separator characters.
* Enclosed in brackets ("[]") if argument processCompletion is Boolean.TRUE.
* Returns empty string if argument array is null.
*
* 返回指定数组内容的字符串表示形式。
*
* 字符串表示形式由数组元素列表组成，相邻元素由参数 separator 字符分隔。
* 如果参数 processCompletion 为 Boolean.TRUE 则括在中括号 ("[]") 中。
* 如果参数 array 为 null，则返回空字符串
*
*
* @param array the array to build a String representation for
* 为其构建字符串表示的数组
* @param separator array separator character
* 数组元素分割字符
* @param processCompletion Enclosed result in brackets ("[]")
* 将结果括在中括号 ("[]") 中
*
* @return a String representation of argument array
* 参数 array 的字符串表示形式
*/
public static String nullSafeToString(final Object[] array, final String separator,
final boolean processCompletion) {
if (array == null || array.length == 0) {
return Globals.DEFAULT_VALUE_STRING;
}
StringBuilder stringBuilder = new StringBuilder();
String split = StringUtils.isEmpty(separator) ? ARRAY_ELEMENT_SEPARATOR : separator;
Arrays.asList(array).forEach(object -> stringBuilder.append(split).append(object));
return processCompletion ? stringBuilderCompletion(stringBuilder) : stringBuilder.substring(split.length());
}
/**
* Insert array start character at index 0 and append array end character at end of the argument stringBuilder, and return the final result string.
* 在索引 0 处插入数组起始字符，并在参数 stringBuilder 末尾附加数组结束字符，并返回最终结果字符串。
*
* @param stringBuilder the string builder will process for
* 将处理的字符串生成器
*
* @return the final result string.
* 最终结果字符串
*/
private static String stringBuilderCompletion(final StringBuilder stringBuilder) {
stringBuilder.insert(ARRAY_ELEMENT_SEPARATOR.length(), ARRAY_START).append(ARRAY_END);
return stringBuilder.substring(ARRAY_ELEMENT_SEPARATOR.length());
}
}