ConvertUtil (feilong-core 2.0.3 API create by feilong)

java.lang.Object
- com.feilong.core.bean.ConvertUtil

public final class ConvertUtil
extends Object

常用类型转换处理.

关于类型转换:

registerPrimitives(boolean throwException)

registerStandard(boolean throwException, boolean defaultNull);

registerOther(boolean throwException);

registerArrays(boolean throwException, int defaultArraySize);

`ConvertUtils` 几个方法的区别:

方法说明

ConvertUtils.convert(Object) 将指定的value转成string.
如果value是array,将会返回数组第一个元素转成string.
将会使用注册的 java.lang.StringConverter,
允许应用定制 Object->String conversions(默认使用简单的使用 toString())
see ConvertUtilsBean.convert(Object)

ConvertUtils.convert(String, Class) 将String value转成指定Class 类型的对象 (如果可能),否则返回string.
see ConvertUtilsBean.convert(String, Class)

ConvertUtils.convert(String[], Class) 将数组转成指定class类型的对象.
如果指定的Class类型是数组类型,那么返回值的类型将是数组的类型.否则将会构造一个指定类型的数组返回.
see ConvertUtilsBean.convert(String[], Class)
see toArray(String[], Class)

ConvertUtils.convert(Object, Class) 将value转成指定Class类型的对象,如果Class的转换器没有注册,那么传入的value原样返回.
see ConvertUtilsBean.convert(Object, Class)
see convert(Object, Class)

方法	说明
`ConvertUtils.convert(Object)`	将指定的value转成string. 如果value是array,将会返回数组第一个元素转成string. 将会使用注册的 `java.lang.StringConverter`, 允许应用定制 Object`->`String conversions(默认使用简单的使用 toString()) see `ConvertUtilsBean.convert(Object)`
`ConvertUtils.convert(String, Class)`	将String value转成指定Class 类型的对象 (如果可能),否则返回string. see `ConvertUtilsBean.convert(String, Class)`
`ConvertUtils.convert(String[], Class)`	将数组转成指定class类型的对象. 如果指定的Class类型是数组类型,那么返回值的类型将是数组的类型.否则将会构造一个指定类型的数组返回. see `ConvertUtilsBean.convert(String[], Class)` see `toArray(String[], Class)`
`ConvertUtils.convert(Object, Class)`	将value转成指定Class类型的对象,如果Class的转换器没有注册,那么传入的value原样返回. see `ConvertUtilsBean.convert(Object, Class)` see `convert(Object, Class)`

standard Converter instances are provided for all of the following destination Classes:

字段说明

BigDecimal no default value

BigInteger no default value

boolean and Boolean default to false

byte and Byte default to zero

char and Character default to a space

Class no default value

double and Double default to zero

float and Float default to zero

int and Integer default to zero

long and Long default to zero

short and Short default to zero

String default to null

File no default value

URL no default value

Date no default value

Time no default value

Timestamp no default value

字段	说明
`BigDecimal`	no default value
`BigInteger`	no default value
boolean and `Boolean`	default to false
byte and `Byte`	default to zero
char and `Character`	default to a space
`Class`	no default value
double and `Double`	default to zero
float and `Float`	default to zero
int and `Integer`	default to zero
long and `Long`	default to zero
short and `Short`	default to zero
`String`	default to null
`File`	no default value
`URL`	no default value
`Date`	no default value
`Time`	no default value
`Timestamp`	no default value

Since:: 1.3.0
Author:: feilong
See Also:: ConvertUtils, AbstractConverter.handleMissing(Class), LocaleConvertUtils

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> T`	`convert(Object toBeConvertedValue, Class<T> targetType)` 将 `toBeConvertedValue` 转成指定 `targetType` 类型的对象.
`static void`	`registerSimpleDateLocaleConverter(String pattern)` Register simple date locale converter.
`static void`	`registerStandardDefaultNull()` Register standard default null.
`static <T> T[]`	`toArray(Collection<T> collection, Class<T> arrayComponentType)` 将集合 `collection` 转成数组.
`static <T> T[]`	`toArray(String[] toBeConvertedValue, Class<T> targetType)` 将字符串数组 `toBeConvertedValue` 转成指定类型 `targetType` 的数组.
`static <T> T[]`	`toArray(T... arrays)` 将动态数组转成数组.
`static BigDecimal`	`toBigDecimal(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转换成 `BigDecimal`.
`static Boolean`	`toBoolean(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转换成 `Boolean`类型.
`static <T> Enumeration<T>`	`toEnumeration(Collection<T> collection)` 将集合 `collection` 转成`Enumeration`.
`static Integer`	`toInteger(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转换成 `Integer`类型.
`static Integer`	`toInteger(Object toBeConvertedValue, Integer defaultValue)` 将 `toBeConvertedValue` 转换成 `Integer`类型,如果转换不了返回默认值 `defaultValue`.
`static Integer[]`	`toIntegers(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转成`Integer` 数组.
`static <T> Iterator<T>`	`toIterator(Object toBeConvertedValue)` 将 `toBeConvertedValue`转成`Iterator`类型.
`static <T> List<T>`	`toList(Collection<T> collection)` 将集合 `collection` 转成 list.
`static <T> List<T>`	`toList(Enumeration<T> enumeration)` 将枚举 `enumeration` 转成 `List`.
`static <T> List<T>`	`toList(T... arrays)` 数组转成 (`ArrayList`).
`static Locale`	`toLocale(Object locale)` 将对象转成 `Locale`.
`static Long`	`toLong(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转换成 `Long`类型.
`static Long[]`	`toLongs(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转成Long 数组.
`static <V,K,E extends Map.Entry<K,V>> Map<K,V>`	`toMap(Collection<E> mapEntryCollection)` 将 `mapEntryCollection` 转成map (`LinkedHashMap`).
`static <K,V> Map<K,V>`	`toMap(K key, V value)` 将 `key` 和 `value` 直接转成map.
`static <K,V> Map<K,V>`	`toMap(K key1, V value1, K key2, V value2)` 将 `key1` 和 `value1`/`key2` 和 `value2` 直接转成map.
`static <K,V,I,J> Map<I,J>`	`toMap(Map<K,V> inputMap, Class<I> keyTargetType, Class<J> valueTargetType)` 将诸如 Map`<String, String>` 类型转成 Map`<Integer, Integer>` 类型.
`static <K,V,J> Map<K,J>`	`toMap(Map<K,V> inputMap, Class<J> valueTargetType)` 将诸如 Map`<String, String>` 类型转成 Map`<String, Integer>` 类型.
`static <K,V,I,J> Map<I,J>`	`toMap(Map<K,V> inputMap, Transformer<K,I> keyTransformer, Transformer<V,J> valueTransformer)` 将诸如 Map`<String, String>` 类型转成 Map`<Integer, Integer>` 类型.
`static Map<String,String>`	`toMap(Properties properties)` 将 `properties` 转换成map.
`static <V,K> Map<K,V>`	`toMapUseEntrys(Map.Entry<K,V>... mapEntrys)` 将 `Map.Entry`数组转成map (`LinkedHashMap`).
`static Properties`	`toProperties(Map<String,String> map)` 将map转成 `Properties`.
`static <T> Set<T>`	`toSet(T... arrays)` 数组转成 Set (`LinkedHashSet`).
`static String`	`toString(Collection<?> collection, String connector)` 将集合 `collection` 使用拼接 `connector` 拼接成字符串.
`static String`	`toString(Collection<?> collection, ToStringConfig toStringConfig)` 将集合 `collection` 使用拼接配置 toStringConfig 拼接成字符串.
`static String`	`toString(Object toBeConvertedValue)` 把对象 `toBeConvertedValue` 转换成字符串.
`static String`	`toString(Object[] arrays, String connector)` 将数组 `arrays` 通过 `connector` 拼接成字符串.
`static String`	`toString(Object[] arrays, ToStringConfig toStringConfig)` 将数组 `arrays` 通过`ToStringConfig` 拼接成字符串.
`static String[]`	`toStrings(Object toBeConvertedValue)` 将 `toBeConvertedValue` 转成`String`数组.

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

Method Detail

registerStandardDefaultNull
```
public static void registerStandardDefaultNull()
```
Register standard default null.

Since:

1.11.2

See Also:
registerPrimitives(boolean throwException), registerStandard(boolean throwException, boolean defaultNull), registerOther(boolean throwException), registerArrays(boolean throwException, int defaultArraySize), ConvertUtilsBean.deregister(Class)

registerSimpleDateLocaleConverter
```
public static void registerSimpleDateLocaleConverter(String pattern)
```
Register simple date locale converter.

Parameters:
pattern - the pattern
Since:

1.11.2

toBoolean
```
public static Boolean toBoolean(Object toBeConvertedValue)
```
将 toBeConvertedValue 转换成 Boolean类型.
示例:
```
 
 ConvertUtil.toBoolean(null)      =   null
 
 ConvertUtil.toBoolean(1L)        =   true
 ConvertUtil.toBoolean("1")       =   true
 ConvertUtil.toBoolean("9")       =   null
 ConvertUtil.toBoolean("1,2,3")   =   null
 
```
逻辑及规则:
- 如果 "true", "yes", "y", "on", "1" (忽视大小写), 返回 true
- 如果 "false", "no", "n", "off", "0" (忽视大小写), 返回 false
- 其他抛出 conversionException, 但是在 handleError(Class, Object, Throwable) 方法里面返回默认值是 null
你也可以调用 BooleanConverter(String[], String[], Object) 设置 trueStrings 和 falseStrings
和 Boolean.parseBoolean(String)的区别:

Boolean.parseBoolean(String),仅当 (String != null) 并且 String.equalsIgnoreCase("true") 返回 true
Parameters:
toBeConvertedValue - object

Returns:
如果 toBeConvertedValue 是null,返回null
See Also:
convert(Object, Class), BooleanConverter, BooleanUtils, Boolean.parseBoolean(String)

toInteger

public static Integer toInteger(Object toBeConvertedValue)

将 toBeConvertedValue 转换成 Integer类型.

示例:

 
 ConvertUtil.toInteger(null)                  = null
 ConvertUtil.toInteger("aaaa")                = null
 ConvertUtil.toInteger(8L)                    = 8
 ConvertUtil.toInteger("8")                   = 8
 ConvertUtil.toInteger(new BigDecimal("8"))   = 8
 
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) L227:
 ConvertUtil.toInteger(new String[] { "1", "2", "3" }) = 1
 
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) Line234:
 ConvertUtil.toInteger(toList("1", "2")) = 1
 

该方法非常适用获取request请求的分页参数

示例:

原来的写法:

 
 public static Integer getCurrentPageNo(HttpServletRequest request,String pageParamName){
     String pageNoString = RequestUtil.getParameter(request, pageParamName);
     try{
         int pageNo = Integer.parseInt(pageNoString);
         return pageNo;
     }catch (Exception e){
         LOGGER.error(e.getClass().getName(), e);
     }
     return 1; // 不带这个参数或者转换异常返回1
 }

现在可以更改成:

 
 public static Integer getCurrentPageNo(HttpServletRequest request,String pageParamName){
     String pageNoString = RequestUtil.getParameter(request, pageParamName);
     Integer pageNo = ConvertUtil.toInteger(pageNoString);
     return null == pageNo ? 1 : pageNo;
 }

当然对于这种场景,最快捷的:调用支持默认值的 toInteger(Object, Integer) 方法

 
 public static Integer getCurrentPageNo(HttpServletRequest request,String pageParamName){
     String pageNoString = RequestUtil.getParameter(request, pageParamName);
     return ConvertUtil.toInteger(pageNoString, 1);
 }

Parameters:: toBeConvertedValue - 值
Returns:: 如果 toBeConvertedValue 是null,返回 null
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换
如果找不到转换器或者转换的时候出现了异常,返回 null
See Also:: IntegerConverter, NumberUtils.toInt(String), toInteger(Object, Integer)

toInteger

public static Integer toInteger(Object toBeConvertedValue,
                Integer defaultValue)

将 toBeConvertedValue 转换成 Integer类型,如果转换不了返回默认值 defaultValue.

示例:

 ConvertUtil.toInteger(null,null)               = null
 ConvertUtil.toInteger(null,1)                  = 1
 ConvertUtil.toInteger("aaaa",1)                = 1
 ConvertUtil.toInteger(8L,1)                    = 8
 ConvertUtil.toInteger("8",1)                   = 8
 ConvertUtil.toInteger(new BigDecimal("8"),1)   = 8
 
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) L227:
 ConvertUtil.toInteger(new String[] { "1", "2", "3" }, 8) = 1
 
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) Line234:
 ConvertUtil.toInteger(toList("1", "2"), 8) = 1
 

该方法非常适用获取request请求的分页参数

示例:

原来的写法:

 
 public static Integer getCurrentPageNo(HttpServletRequest request,String pageParamName){
     String pageNoString = RequestUtil.getParameter(request, pageParamName);
     try{
         int pageNo = Integer.parseInt(pageNoString);
         return pageNo;
     }catch (Exception e){
         LOGGER.error(e.getClass().getName(), e);
     }
     return 1; // 不带这个参数或者转换异常返回1
 }

现在可以更改成:

 
 public static Integer getCurrentPageNo(HttpServletRequest request,String pageParamName){
     String pageNoString = RequestUtil.getParameter(request, pageParamName);
     return ConvertUtil.toInteger(pageNoString, 1);
 }

Parameters:: toBeConvertedValue - 值; defaultValue - 默认值
Returns:: 如果 toBeConvertedValue 是null,返回 defaultValue
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换
如果找不到转换器或者转换的时候出现了异常,返回 defaultValue
Since:: 1.6.1
See Also:: IntegerConverter, ObjectUtils.defaultIfNull(Object, Object)

toLong
```
public static Long toLong(Object toBeConvertedValue)
```
将 toBeConvertedValue 转换成 Long类型.
示例:
```
 ConvertUtil.toLong(null)                     = null
 ConvertUtil.toLong("aaaa")                   = null
 ConvertUtil.toLong(8)                        = 8L
 ConvertUtil.toLong("8")                      = 8L
 ConvertUtil.toLong(new BigDecimal("8"))      = 8L
 
```
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) L227:
```
 ConvertUtil.toLong(new String[] { "1", "2", "3" }) = 1L
 
```
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) Line234:
```
 ConvertUtil.toLong(toList("1", "2")) = 1L
 
```
Parameters:
toBeConvertedValue - 包含数字的对象.

Returns:
如果 toBeConvertedValue 是null,返回 null
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换
如果找不到转换器或者转换的时候出现了异常,返回 null
See Also:
convert(Object, Class), LongConverter, NumberUtils.toLong(String)

toBigDecimal
```
public static BigDecimal toBigDecimal(Object toBeConvertedValue)
```
将 toBeConvertedValue 转换成 BigDecimal.
示例:
```
 ConvertUtil.toBigDecimal(null)                     = null
 ConvertUtil.toBigDecimal("aaaa")                   = null
 ConvertUtil.toBigDecimal(8)                        = BigDecimal.valueOf(8)
 ConvertUtil.toBigDecimal("8")                      = BigDecimal.valueOf(8)
 ConvertUtil.toBigDecimal(new BigDecimal("8"))      = BigDecimal.valueOf(8)
 
```
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) L227:
```
 ConvertUtil.toBigDecimal(new String[] { "1", "2", "3" }) = BigDecimal.valueOf(1)
 
```
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换,参见 AbstractConverter.convertArray(Object) Line234:
```
 ConvertUtil.toBigDecimal(toList("1", "2")) = BigDecimal.valueOf(1)
 
```
Double 转成 BigDecimal注意点:
推荐使用 BigDecimal.valueOf(double),不建议使用 new BigDecimal(double),参见 JDK API
- new BigDecimal(0.1) ====> 0.1000000000000000055511151231257827021181583404541015625
- BigDecimal.valueOf(0.1) ====> 0.1
本方法底层调用的是 NumberConverter#toNumber(Class, Class, Number),正确的处理了 Double 转成 BigDecimal
Parameters:
toBeConvertedValue - 值

Returns:
如果 toBeConvertedValue 是null,返回 null
如果传入的参数 toBeConvertedValue 是数组,那么取第一个元素进行转换
如果传入的参数 toBeConvertedValue 是集合,那么取第一个元素进行转换
如果找不到转换器或者转换的时候出现了异常,返回 null
See Also:
convert(Object, Class), NumberConverter.toNumber(Class, Class, Number), BigDecimalConverter

toIntegers
```
public static Integer[] toIntegers(Object toBeConvertedValue)
```
将 toBeConvertedValue 转成Integer 数组.
说明:
核心实现,参见 ArrayConverter.convertToType(Class, Object)
如果参数 toBeConvertedValue是 数组 或者 Collection
参见ArrayConverter#convertToType(Class,Object)
会构造一个Integer数组,长度就是 toBeConvertedValue的大小或者长度,然后迭代toBeConvertedValue依次逐个进行转换

示例:

ConvertUtil.toIntegers(new String[] { "1", "2", "3" }) = [1,2,3] ConvertUtil.toIntegers(toList("1", "2", "3")) = [1,2,3]
如果参数 toBeConvertedValue不是数组也不是Collection
那么首先会调用 ArrayConverter.convertToCollection(Class, Object) 将 toBeConvertedValue转成集合,转换逻辑参见 ArrayConverter.convertToCollection(Class, Object):

如果 toBeConvertedValue是Number, Boolean 或者 Date ,那么构造只有一个 toBeConvertedValue 元素的 List返回.

其他类型将转成字符串,然后调用 ArrayConverter.parseElements(Class, String)转成list.
具体转换逻辑为:

字符串期望是一个逗号分隔的字符串.

字符串可以被'{' 开头和 '}'结尾的分隔符包裹,程序内部会自动截取.

会去除前后空白.

Elements in the list may be delimited by single or double quotes. Within a quoted elements, the normal Java escape sequences are valid.

得到list之后,会构造一个Integer数组,长度就是 toBeConvertedValue的大小或者长度,然后迭代toBeConvertedValue依次逐个进行转换

示例:

ConvertUtil.toIntegers("1,2,3") = new Integer[] { 1, 2, 3 } ConvertUtil.toIntegers("{1,2,3}") = new Integer[] { 1, 2, 3 } ConvertUtil.toIntegers("{ 1 ,2,3}") = new Integer[] { 1, 2, 3 } ConvertUtil.toIntegers("1,2, 3") = new Integer[] { 1, 2, 3 } ConvertUtil.toIntegers("1,2 , 3") = new Integer[] { 1, 2, 3 }
每个元素转换成 Integer的时候,会调用 NumberConverter.convertToType(Class, Object),具体的规则是:
1.如果元素是 Number类型

那么会调用 NumberConverter.toNumber(Class, Class, Number)

2.如果元素是 Boolean类型

那么 true被转成1,false 转成 0

3.其他情况

将元素转成字符串,并trim,再进行转换

4.元素是null的情况

如果有元素是null,那么会调用 AbstractConverter.convert(Class, Object),会调用 AbstractConverter.handleMissing(Class) 方法,没有默认值的话,会抛出异常,然后catch之后返回 empty Integer 数组

示例:
```
 ConvertUtil.toIntegers(toList("1", "2", " 3"))        = new Integer[] { 1, 2, 3 }
 ConvertUtil.toIntegers(toArray(true, false, false))                                  = new Integer[] { 1, 0, 0 }
 ConvertUtil.toIntegers(new String[] { "1", null, "2", "3" })                         = new Integer[] {}
 
```
Parameters:
toBeConvertedValue - 需要被转换的值

Returns:
如果 toBeConvertedValue 是null,返回 null
See Also:
convert(Object, Class), ArrayConverter

toLongs
```
public static Long[] toLongs(Object toBeConvertedValue)
```
将 toBeConvertedValue 转成Long 数组.
说明:
核心实现,参见 ArrayConverter.convertToType(Class, Object)
如果参数 toBeConvertedValue是 数组 或者 Collection
参见ArrayConverter#convertToType(Class,Object)
会构造一个Long数组,长度就是 toBeConvertedValue的大小或者长度,然后迭代toBeConvertedValue依次逐个进行转换

示例:

ConvertUtil.toLongs(new String[] { "1", "2", "3" } = [1L,2L,3L] ConvertUtil.toLongs(toList("1", "2", "3")) = [1L,2L,3L]
如果参数 toBeConvertedValue不是数组也不是Collection
那么首先会调用 ArrayConverter.convertToCollection(Class, Object) 将 toBeConvertedValue转成集合,转换逻辑参见 ArrayConverter.convertToCollection(Class, Object):

如果 toBeConvertedValue是Number, Boolean 或者 Date ,那么构造只有一个 toBeConvertedValue 元素的 List返回.

其他类型将转成字符串,然后调用 ArrayConverter.parseElements(Class, String)转成list.
具体转换逻辑为:

字符串期望是一个逗号分隔的字符串.

字符串可以被'{' 开头和 '}'结尾的分隔符包裹,程序内部会自动截取.

会去除前后空白.

Elements in the list may be delimited by single or double quotes. Within a quoted elements, the normal Java escape sequences are valid.

得到list之后,会构造一个Long数组,长度就是 toBeConvertedValue的大小或者长度,然后迭代toBeConvertedValue依次逐个进行转换

示例:

ConvertUtil.toLongs("1,2,3") = new Long[] { 1L, 2L, 3L } ConvertUtil.toLongs("{1,2,3}") = new Long[] { 1L, 2L, 3L } ConvertUtil.toLongs("{ 1 ,2,3}") = new Long[] { 1L, 2L, 3L } ConvertUtil.toLongs("1,2, 3") = new Long[] { 1L, 2L, 3L } ConvertUtil.toLongs("1,2 , 3") = new Long[] { 1L, 2L, 3L }
每个元素转换成 Integer的时候,会调用 NumberConverter.convertToType(Class, Object),具体的规则是:
1.如果元素是 Number类型

那么会调用 NumberConverter.toNumber(Class, Class, Number)

2.如果元素是 Boolean类型

那么 true被转成1L,false 转成 0L

3.其他情况

将元素转成字符串,并trim,再进行转换

4.元素是null的情况

如果有元素是null,那么会调用 AbstractConverter.convert(Class, Object),会调用 AbstractConverter.handleMissing(Class) 方法,没有默认值的话,会抛出异常,然后catch之后返回 empty Integer 数组

示例:
```
 ConvertUtil.toLongs(toList("1", "2", " 3"))        = new Long[] { 1L, 2L, 3L }
 ConvertUtil.toLongs(toArray(true, false, false))                                  = new Long[] { 1L, 0L, 0L }
 ConvertUtil.toLongs(new String[] { "1", null, "2", "3" })                         = new Long[] {}
 
```
特别适合以下形式的代码:
```
 
 protected long[] getOrderIdLongs(String orderIds){
     // 确认交易时候插入数据库的时候,不应该会出现空的情况
     String[] orderIdArray = orderIds.split(",");
     int orderLength = orderIdArray.length;
     long[] ids = new long[orderLength];
     for (int i = 0, j = orderLength; i < j; ++i){
         ids[i] = Long.parseLong(orderIdArray[i]);
     }
     return ids;
 }
 
 
```
可以重构成:
```
 
 protected long[] getOrderIdLongs(String orderIds){
     return toLongs(orderIds);
 }
 
```
Parameters:
toBeConvertedValue - the to be converted value

Returns:
如果 toBeConvertedValue 是null,返回 null
See Also:
ConvertUtils.convert(Object, Class), ArrayConverter, convert(Object, Class)

toString
```
public static String toString(Object toBeConvertedValue)
```
把对象 toBeConvertedValue 转换成字符串.
示例:
```
 ConvertUtil.toString(1)                  =   "1"
 ConvertUtil.toString(toLong(8L))         =   "8"
 ConvertUtil.toString(toBigDecimal(1.0))  =   "1.00"
 ConvertUtil.toString(new Double(1.0))  =   "1.00"
 ConvertUtil.toString(new Float(1.0))  =   "1.00"
 
 ConvertUtil.toString(toList("张飞", "关羽", "", "赵云"))  =   "张飞,关羽,,赵云"
 ConvertUtil.toString(toArray("张飞", "关羽", "", "赵云"))  =   "张飞,关羽,,赵云"
 ConvertUtil.toString(toArray(null, "关羽", "", "赵云"))  =   ",关羽,,赵云"
 
```
Parameters:
toBeConvertedValue - 参数值

Returns:
如果 toBeConvertedValue 是null,返回 null
如果 toBeConvertedValue 是 CharSequence,直接 toString返回
如果 toBeConvertedValue 是数组,那么调用 toString(Object[], String)
如果 toBeConvertedValue 是 Collection,那么调用 toString(Object[], String)
如果 toBeConvertedValue 是 Date,那么返回 DatePattern.COMMON_DATE_AND_TIME 格式字符串
如果 toBeConvertedValue 是 BigDecimal或者是Float或者是 Double,那么返回 NumberPattern.TWO_DECIMAL_POINTS 2 位小数点格式字符串
其他调用 convert(Object, Class)
Since:

1.14.0 call ToStringHandler.toStringValue(Object)

See Also:
ArrayConverter.convertToString(Object), ConvertUtils.convert(Object), ConvertUtilsBean.convert(Object), StringConverter, Arrays.toString(Object[])

toString
```
public static String toString(Collection<?> collection,
              String connector)
```
将集合 collection 使用拼接 connector 拼接成字符串.
示例:
```
 List<String> list = com.feilong.core.bean.ConvertUtil.toList("feilong", "", "xinge");
 ConvertUtil.toString(list,",");
 
```
输出:
```
 feilong,,xinge
 
```
你还可以使用这个方法来将集合换行输出,比如:
```
 List<String> list = toList("飞龙", "小金", "四金", "金金金金");
 
 LOGGER.debug(ConvertUtil.toString(list, System.lineSeparator()));
 
```
输出:
```
 飞龙
 小金
 四金
 金金金金
 
```
说明
1. 如果有元素是null,使用StringUtils.EMPTY替代拼接
2. 最后一个元素后面不拼接拼接符
Parameters:
collection - 集合,建议元素泛型不要使用自定义的对象(比如UserCommand等),因为这个方法是迭代collection,拿每个元素的字符串格式进行拼接
connector - the connector

Returns:
如果 collection 是null或者empty,返回 StringUtils.EMPTY
Since:

1.11.0

See Also:
"org.springframework.util.StringUtils#collectionToDelimitedString(Collection, String, String, String)", IteratorUtils.toString(Iterator), StringUtils.join(Iterable, String)

toString
```
public static String toString(Object[] arrays,
              String connector)
```
将数组 arrays 通过 connector 拼接成字符串.
示例:
```
 ConvertUtil.toString(null,",")               =   ""
 ConvertUtil.toString(toArray(),",")          =   ""
 
 ConvertUtil.toString(toArray("a","b"),",")   =   "a,b"
 
 Integer[] array3 = { 2, null, 1, null };
 ConvertUtil.toString(array3,",")             =   "2,,1,"
 
```
如果原始类型数组需要转换:
需要先使用下列的方式先转成包装类型数组
说明
1. 如果有元素是null,使用StringUtils.EMPTY替代拼接
2. 最后一个元素后面不拼接拼接符
Parameters:
arrays - 支持包装类型,不直接支持原始类型
connector - the connector

Returns:
如果 arrays 是null 或者Empty,返回 StringUtils.EMPTY
Since:

1.11.0

See Also:
ToStringStyle, StringUtils.join(Object[], String)

toString
```
public static String toString(Collection<?> collection,
              ToStringConfig toStringConfig)
```
将集合 collection 使用拼接配置 toStringConfig 拼接成字符串.
示例:
```
 List<String> list = new ArrayList<>();
 list.add("feilong");
 list.add("");
 list.add("xinge");
 
 ToStringConfig toStringConfig = new ToStringConfig(",");
 toStringConfig.setIsJoinNullOrEmpty(false);
 
 ConvertUtil.toString(list,toStringConfig);
 
```
输出:
```
 feilong,xinge
 
```
你还可以使用这个方法来将集合换行输出,比如:
```
 List<String> list = toList("飞龙", "小金", "四金", "金金金金");
 
 ToStringConfig toStringConfig = new ToStringConfig(System.lineSeparator());
 LOGGER.debug(ConvertUtil.toString(list, toStringConfig));
 
```
输出:
```
 飞龙
 小金
 四金
 金金金金
 
```
关于 default ToStringConfig:
如果参数 toStringConfig 是null,则使用默认的规则:
1. 连接符使用ToStringConfig.DEFAULT_CONNECTOR
2. 拼接null或者empty元素
3. 如果元素是null,使用StringUtils.EMPTY替代拼接
4. 最后一个元素后面不拼接拼接符
关于 ToStringConfig prefix(since 1.12.9):
如果你需要在拼接每个元素的时候,给每个元素加上前缀, 比如 solr 查询, 运营人员配置了一些商品code ,1533312,1533292,1785442, 此时你需要生成 code:1533312 OR code:1533292 OR code:1785442 字符串去solr 中查询

此时你可以这么调用
```
 
 String configItemCodes = "1533312,1533292,1785442";
 String[] tokenizeToStringArray = StringUtil.tokenizeToStringArray(configItemCodes, ",");
 List<String> list = toList(tokenizeToStringArray);
 ToStringConfig toStringConfig = new ToStringConfig(" OR ", false, "code:");
 String string = ConvertUtil.toString(list, toStringConfig);
 
```
返回:
code:1533312 OR code:1533292 OR code:1785442
Parameters:
collection - 集合,建议元素泛型不要使用自定义的对象(比如UserCommand等),因为这个方法是迭代collection,拿每个元素的字符串格式进行拼接
toStringConfig - 连接字符串实体

Returns:
如果 collection 是null或者empty,返回 StringUtils.EMPTY
如果 toStringConfig 是null,使用默认 ToStringConfig.DEFAULT_CONNECTOR以及 joinNullOrEmpty 进行连接
都不是null,会循环,拼接toStringConfig.getConnector()
Since:

1.8.4 change param order

See Also:
"org.springframework.util.StringUtils#collectionToDelimitedString(Collection, String, String, String)", IteratorUtils.toString(Iterator), StringUtils.join(Iterable, String)

toString
```
public static String toString(Object[] arrays,
              ToStringConfig toStringConfig)
```
将数组 arrays 通过ToStringConfig 拼接成字符串.
示例:
```
 ConvertUtil.toString(toArray("a","b"),new ToStringConfig())       =   "a,b"
 
 ToStringConfig toStringConfig=new ToStringConfig(",");
 toStringConfig.setIsJoinNullOrEmpty(false);
 ConvertUtil.toString(toArray("a","b",null),new ToStringConfig())  =   "a,b"
 
```
如果原始类型数组需要转换:
需要先使用下列的方式先转成包装类型数组
关于 default ToStringConfig:
如果参数 toStringConfig 是null,则使用默认的规则:
1. 连接符使用ToStringConfig.DEFAULT_CONNECTOR
2. 拼接null或者empty元素
3. 如果元素是null,使用StringUtils.EMPTY替代拼接
4. 最后一个元素后面不拼接拼接符
关于 ToStringConfig prefix(since 1.12.9):
如果你需要在拼接每个元素的时候,给每个元素加上前缀, 比如 solr 查询, 运营人员配置了一些商品code ,1533312,1533292,1785442, 此时你需要生成 code:1533312 OR code:1533292 OR code:1785442 字符串去solr 中查询

此时你可以这么调用
```
 
 String configItemCodes = "1533312,1533292,1785442";
 String[] tokenizeToStringArray = StringUtil.tokenizeToStringArray(configItemCodes, ",");
 ToStringConfig toStringConfig = new ToStringConfig(" OR ", false, "code:");
 String string = ConvertUtil.toString(tokenizeToStringArray, toStringConfig);
 
```
返回:
code:1533312 OR code:1533292 OR code:1785442
Parameters:
arrays - 支持包装类型,不直接支持原始类型
toStringConfig - the to string config

Returns:
如果 arrays 是null 或者Empty,返回 StringUtils.EMPTY
如果 toStringConfig 是null,使用默认 ToStringConfig.DEFAULT_CONNECTOR以及 joinNullOrEmpty 进行连接
否则循环,拼接 ToStringConfig.getConnector()
Since:

1.8.4 change param order

See Also:
ToStringStyle, StringUtils.join(Object[], String), StringUtils.join(Iterable, String)

toEnumeration
```
public static <T> Enumeration<T> toEnumeration(Collection<T> collection)
```
将集合 collection 转成Enumeration.
说明:
1. 一般情况,你可能不需要这个方法,不过在一些API的时候,需要Enumeration参数,此时调用这个方法来进行转换会比较方便
示例:
```
 ConvertUtil.toEnumeration(null) = Collections.emptyEnumeration()
 
```
Type Parameters:
T - the generic type
Parameters:
collection - 集合

Returns:
如果 collection 是null,返回 Collections.emptyEnumeration()
否则返回Collections.enumeration(Collection)
Since:

1.4.0

See Also:
Collections.enumeration(Collection)

toMap

public static <K,V> Map<K,V> toMap(K key,
                   V value)

将 key 和 value 直接转成map.

说明:

返回是的是 LinkedHashMap
非常适合单key的场景,比如
 Map<String, String> paramMap = newHashMap();
 paramMap.put("name", "jinxin");
 request.setParamMap(paramMap);
 
上面的3行代码可以重写成
 request.setParamMap(toMap("name", "jinxin"));
 
一行代码就搞定了,很简洁,有木有~~

示例:

 LOGGER.debug(JsonUtil.format(ConvertUtil.toMap("张飞", "丈八蛇矛")));

返回:

 {"张飞": "丈八蛇矛"}

重构:

对于以下代码:

 private List<ShopCommand> loadShopCommandList(){
     Map<String, Object> paraMap = newHashMap();
     paraMap.put("orgTypeId", OrgType.ID_SHOP_TYPE);
 
     return shopCommandDao.findShopListByOrgaTypeId(paraMap);
 }

可以重构成:

 private List<ShopCommand> loadShopCommandList(){
   Map<String, Object> paraMap = ConvertUtil.toMap("orgTypeId", (Object) OrgType.ID_SHOP_TYPE);
     return shopCommandDao.findShopListByOrgaTypeId(paraMap);
 }

Type Parameters:: K - the key type; V - the value type
Parameters:: key - the key; value - the value
Returns:: 将 key 和 value 直接转成map
Since:: 1.7.1
See Also:: ArrayUtils.toMap(Object[]), Collections.singletonMap(Object, Object), "com.google.common.collect.ImmutableMap#of(K, V)"

toMap

public static <K,V> Map<K,V> toMap(K key1,
                   V value1,
                   K key2,
                   V value2)

将 key1 和 value1/key2 和 value2 直接转成map.

说明:

返回是的是 LinkedHashMap
非常适合2个key的场景,比如
 Map<String, String> paramMap =newHashMap();
 paramMap.put("name", "jinxin");
 paramMap.put("age", "18");
 request.setParamMap(paramMap);
 
上面的3行代码可以重写成
 request.setParamMap(toMap("name", "jinxin", "age", "18"));
 
一行代码就搞定了,很简洁,有木有~~

重构:

对于以下代码:

 Map<String, Long> map = newHashMap();
 map.put("itemId", itemId);
 map.put("memberId", memberId);
 memberFavoritesDao.findMemberFavoritesByMemberIdAndItemId(map);

可以重构成:

 Map<String, Long> map = ConvertUtil.toMap("itemId", itemId, "memberId", memberId);
 memberFavoritesDao.findMemberFavoritesByMemberIdAndItemId(map);

Type Parameters:: K - the key type; V - the value type
Parameters:: key1 - the key 1; value1 - the value 1; key2 - the key 2; value2 - the value 2
Returns:: 将 key1 和 value1/key2 和 value2 直接转成map
Since:: 1.9.5
See Also:: ArrayUtils.toMap(Object[]), Collections.singletonMap(Object, Object), "com.google.common.collect.ImmutableMap#of(K, V)"

toMap
```
public static Map<String,String> toMap(Properties properties)
```
将 properties 转换成map.
示例:
```
 Properties properties = new Properties();
 
 properties.setProperty("name", "feilong");
 properties.setProperty("age", "18");
 properties.setProperty("country", "china");
 
 LOGGER.debug(JsonUtil.format(toMap(properties)));
 
```
返回:
```
 {
 "age": "18",
 "country": "china",
 "name": "feilong"
 }
 
```
说明:
1. 返回的map 经过了 SortUtil.sortMapByKeyAsc(Map)排序处理,方便输出日志
关于 Properties

Properties 是 Map的实现类 ,其 key和value 是String 类型.

因此Properties 可以强制转换成map
Parameters:
properties - the properties

Returns:
如果 properties 是null或者empty,返回 Collections.emptyMap()
Since:

1.7.1

See Also:
MapUtils.toProperties(Map)

toMap
```
public static <K,V,J> Map<K,J> toMap(Map<K,V> inputMap,
                     Class<J> valueTargetType)
```
将诸如 Map<String, String> 类型转成 Map<String, Integer> 类型.
说明:
1. 适合只是简单的将key value类型转换,而不需要自己再构建Transformer,再去调用 toMap(Map, Transformer, Transformer) ,简化操作
2. 返回的是 LinkedHashMap,顺序依照入参 inputMap
3. 返回的是新的map,原来的toMap参数不受影响
4. 也支持诸如 Map<String, Integer> 转 Map<String, String> (key和value 使用不同的转换器)
5. 也支持诸如 Map<String, String> 转 Map<String, Integer[]> (单值转数组)
6. 也支持诸如 Map<String[], String[]> 转 Map<String[], Long[]> (数组转数组)
示例:
场景1: 将Map<String, String> 转 Map<String, Integer> 类型
```
 
 Map<String, String> map = toMap("1", "2");
 Map<String, Integer> returnMap = toMap(map, Integer.class);
 
 // 输出测试
 for (Map.Entry<String, Integer> entry : returnMap.entrySet()){
     String key = entry.getKey();
     Integer value = entry.getValue();
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }
 
 
```
返回:
```
 key:["1"],value:[2]
 
```
场景2: Map<String, String> 转 Map<String, Integer[]>
```
 
 Map<String, String> map = toMap("1", "2,2");
 
 //key和value转成不同的类型
 Map<String, Integer[]> returnMap = toMap(map,  Integer[].class);
 
 // 输出测试
 for (Map.Entry<String, Integer[]> entry : returnMap.entrySet()){
     String key = entry.getKey();
     Integer[] value = entry.getValue();
 
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }
 
 
```
返回:
```
 key:["1"],value:[[2, 2]]
 
```
场景3: Map<String[], String[]> 转 Map<String[], Long[]>
```
 
 Map<String[], String[]> map = toMap(toArray("1"), toArray("2", "8"));
 
 //key和value转成不同的类型
 Map<String[], Long[]> returnMap = toMap(map, Long[].class);
 
 assertThat(returnMap, allOf(hasEntry(toArray("1"), toArray(2L, 8L))));
 
```
Type Parameters:
K - the key type
V - the value type
J - 返回的map ,value的类型
Parameters:
inputMap - the input map
valueTargetType - value 需要转换成什么类型,类型可以和原map的类型相同或者可以设置为null,均表示返回的map使用inputMap原样的value,不会进行类型转换

Returns:
如果 inputMap 是null或者empty,返回 Collections.emptyMap()
如果 valueTargetType 是null,那么value 直接使用inputMap的 value
Since:

1.10.5

See Also:
toMap(Map, Class, Class), issues661

toMap
```
public static <K,V,I,J> Map<I,J> toMap(Map<K,V> inputMap,
                       Class<I> keyTargetType,
                       Class<J> valueTargetType)
```
将诸如 Map<String, String> 类型转成 Map<Integer, Integer> 类型.
说明:
1. 适合只是简单的将key value类型转换,而不需要自己再构建Transformer,再去调用 toMap(Map, Transformer, Transformer) ,简化操作
2. 返回的是 LinkedHashMap,顺序依照入参 inputMap
3. 返回的是新的map,原来的toMap参数不受影响
4. 也支持诸如 Map<String, Integer> 转 Map<Integer, String> (key和value 使用不同的转换器)
5. 也支持诸如 Map<String, String> 转 Map<Integer, Integer[]> (单值转数组)
6. 也支持诸如 Map<String[], String[]> 转 Map<Integer[], Long[]> (数组转数组)
示例:
场景1: 将Map<String, String> 转 Map<Integer, Integer> 类型
```
 
 Map<String, String> map = toMap("1", "2");
 Map<Integer, Integer> returnMap = toMap(map, Integer.class, Integer.class);
 
 // 输出测试
 for (Map.Entry<Integer, Integer> entry : returnMap.entrySet()){
     Integer key = entry.getKey();
     Integer value = entry.getValue();
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }
 
 
```
返回:
```
 key:[1],value:[2]
 
```
场景2: Map<String, String> 转 Map<Integer, Integer[]>
```
 
 Map<String, String> map = toMap("1", "2,2");
 
 //key和value转成不同的类型
 Map<Integer, Integer[]> returnMap = toMap(map, Integer.class, Integer[].class);
 
 // 输出测试
 for (Map.Entry<Integer, Integer[]> entry : returnMap.entrySet()){
     Integer key = entry.getKey();
     Integer[] value = entry.getValue();
 
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }
 
 
```
返回:
```
 key:[1],value:[[2, 2]]
 
```
场景3: Map<String[], String[]> 转 Map<Integer[], Long[]>
```
 
 Map<String[], String[]> map = toMap(toArray("1"), toArray("2", "8"));
 
 //key和value转成不同的类型
 Map<Integer[], Long[]> returnMap = toMap(map, Integer[].class, Long[].class);
 
 assertThat(returnMap, allOf(hasEntry(toArray(1), toArray(2L, 8L))));
 
```
Type Parameters:
K - the key type
V - the value type
I - 返回的map ,key的类型
J - 返回的map ,value的类型
Parameters:
inputMap - the input map
keyTargetType - key需要转换成什么类型,类型可以和原map的类型相同或者可以设置为null,均表示返回的map使用inputMap原样的key,不会进行类型转换
valueTargetType - value 需要转换成什么类型,类型可以和原map的类型相同或者可以设置为null,均表示返回的map使用inputMap原样的value,不会进行类型转换

Returns:
如果 inputMap 是null或者empty,返回 Collections.emptyMap()
如果 keyTargetType 是null,那么key直接使用inputMap的key
如果 valueTargetType 是null,那么value 直接使用inputMap的 value
Since:

1.9.2

See Also:
toMap(Map, Transformer, Transformer), issues497

toMap

public static <K,V,I,J> Map<I,J> toMap(Map<K,V> inputMap,
                       Transformer<K,I> keyTransformer,
                       Transformer<V,J> valueTransformer)

将诸如 Map<String, String> 类型转成 Map<Integer, Integer> 类型.

说明:

适合复杂的类型转换场景,如果只是简单的类型转换,你可以直接调用 toMap(Map, Class, Class)

返回的是 LinkedHashMap,顺序依照入参 inputMap

返回的是新的map,原来的toMap参数不受影响

也支持诸如 Map<String, Integer> 转 Map<Integer, String> (key和value 使用不同的转换器)

也支持诸如 Map<String, String> 转 Map<Integer, Integer[]> (单值转数组)

也支持诸如 Map<String[], String[]> 转 Map<Integer[], Long[]> (数组转数组)

示例:

场景1: 将Map<String, String> 转 Map<Integer, Integer> 类型

 
 Map<String, String> map = toMap("1", "2");
 
 //key和value 都转成integer 使用相同的转换器
 Transformer<String, Integer> transformer = new SimpleClassTransformer<>(Integer.class);
 
 Map<Integer, Integer> returnMap = toMap(map, transformer, transformer);
 
 // 输出测试
 for (Map.Entry<Integer, Integer> entry : returnMap.entrySet()){
     Integer key = entry.getKey();
     Integer value = entry.getValue();
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }

返回:

 key:[1],value:[2]

场景2: Map<String, String> 转 Map<Integer, Integer[]>

 
 Map<String, String> map = toMap("1", "2,2");
 
 Transformer<String, Integer> keyTransformer = new SimpleClassTransformer<>(Integer.class);
 Transformer<String, Integer[]> valueTransformer = new SimpleClassTransformer<>(Integer[].class);
 
 //key和value转成不同的类型
 Map<Integer, Integer[]> returnMap = toMap(map, keyTransformer, valueTransformer);
 
 // 输出测试
 for (Map.Entry<Integer, Integer[]> entry : returnMap.entrySet()){
     Integer key = entry.getKey();
     Integer[] value = entry.getValue();
 
     LOGGER.debug("key:[{}],value:[{}]", key, value);
 }

返回:

 key:[1],value:[[2, 2]]

场景3: Map<String[], String[]> 转 Map<Integer[], Long[]>

 
 Map<String[], String[]> map = toMap(toArray("1"), toArray("2", "8"));
 
 Transformer<String[], Integer[]> keyTransformer = new SimpleClassTransformer<>(Integer[].class);
 Transformer<String[], Long[]> valueTransformer = new SimpleClassTransformer<>(Long[].class);
 
 //key和value转成不同的类型
 Map<Integer[], Long[]> returnMap = toMap(map, keyTransformer, valueTransformer);
 
 assertThat(returnMap, allOf(hasEntry(toArray(1), toArray(2L, 8L))));

Type Parameters:: K - the key type; V - the value type; I - 返回的map ,key的类型; J - 返回的map ,value的类型
Parameters:: inputMap - the input map; keyTransformer - key 转换器,如果是null,那么key直接使用inputMap的key; valueTransformer - value 转换器,如果是null,那么value直接使用inputMap的value
Returns:: 如果 inputMap 是null或者empty,返回 Collections.emptyMap()
如果 keyTransformer 是null,那么key直接使用inputMap的key
如果 valueTransformer 是null,那么value 直接使用inputMap的 value
Since:: 1.9.2
See Also:: MapUtils.transformedMap(Map, Transformer, Transformer), TransformedMap, issues497

toMap

public static <V,K,E extends Map.Entry<K,V>> Map<K,V> toMap(Collection<E> mapEntryCollection)

将 mapEntryCollection 转成map (LinkedHashMap).

说明:

返回是的是 LinkedHashMap,顺序依照参数 mapEntryCollection,key是 Map.Entry.getKey(),value 是 Map.Entry.getValue()

Map.Entry 已知实现类,你可以使用 Pair,或者 AbstractMap.SimpleEntry

`Pair` 示例:

 Map<String, String> map = toMap(toList(//
                 Pair.of("张飞", "丈八蛇矛"),
                 Pair.of("关羽", "青龙偃月刀"),
                 Pair.of("赵云", "龙胆枪"),
                 Pair.of("刘备", "双股剑")));
 LOGGER.debug(JsonUtil.format(map));

返回:

 {
 "张飞": "丈八蛇矛",
 "关羽": "青龙偃月刀",
 "赵云": "龙胆枪",
 "刘备": "双股剑"
 }

`AbstractMap.SimpleEntry` 示例:

 Map<String, String> map = ConvertUtil.toMap(
                 toList(
                                 new SimpleEntry<>("张飞", "丈八蛇矛"),
                                 new SimpleEntry<>("关羽", "青龙偃月刀"),
                                 new SimpleEntry<>("赵云", "龙胆枪"),
                                 new SimpleEntry<>("刘备", "双股剑")));
 LOGGER.debug(JsonUtil.format(map));

返回:

 {
 "张飞": "丈八蛇矛",
 "关羽": "青龙偃月刀",
 "赵云": "龙胆枪",
 "刘备": "双股剑"
 }

Type Parameters:: V - the value type; K - the key type; E - the element type
Parameters:: mapEntryCollection - the map entry collection
Returns:: 如果 mapEntryCollection 是null,返回 Collections.emptyMap()
如果 mapEntryCollection 有元素是null,将会抛出异常 IllegalArgumentException
Since:: 1.7.1
See Also:: ArrayUtils.toMap(Object[])

toMapUseEntrys

@SafeVarargs
public static <V,K> Map<K,V> toMapUseEntrys(Map.Entry<K,V>... mapEntrys)

将 Map.Entry数组转成map (LinkedHashMap).

说明:

返回是的是 LinkedHashMap,顺序依照参数 Map.Entry数组顺序,key是 Map.Entry.getKey(),value 是 Map.Entry.getValue()

Map.Entry 已知实现类,你可以使用 Pair,或者 AbstractMap.SimpleEntry

`Pair` 示例:

 Map<String, String> map = ConvertUtil.toMapUseEntrys(
                 Pair.of("张飞", "丈八蛇矛"),
                 Pair.of("关羽", "青龙偃月刀"),
                 Pair.of("赵云", "龙胆枪"),
                 Pair.of("刘备", "双股剑"));
 LOGGER.debug(JsonUtil.format(map));

返回:

 {
 "张飞": "丈八蛇矛",
 "关羽": "青龙偃月刀",
 "赵云": "龙胆枪",
 "刘备": "双股剑"
 }

`AbstractMap.SimpleEntry` 示例:

 
 Map<String, String> map = ConvertUtil.toMapUseEntrys(
                 new SimpleEntry<>("张飞", "丈八蛇矛"),
                 new SimpleEntry<>("关羽", "青龙偃月刀"),
                 new SimpleEntry<>("赵云", "龙胆枪"),
                 new SimpleEntry<>("刘备", "双股剑"));
 LOGGER.debug(JsonUtil.format(map));

返回:

 {
 "张飞": "丈八蛇矛",
 "关羽": "青龙偃月刀",
 "赵云": "龙胆枪",
 "刘备": "双股剑"
 }

重构:

以前初始化全局map的时候,你可能会这么写

 
 // 除数和单位的map,必须是有顺序的 从大到小.
 private static final Map<Long, String> DIVISOR_AND_UNIT_MAP = new LinkedHashMap<>();
 
 static{
     DIVISOR_AND_UNIT_MAP.put(FileUtils.ONE_TB, "TB");//(Terabyte,太字节,或百万兆字节)=1024GB,其中1024=2^10(2的10次方)
     DIVISOR_AND_UNIT_MAP.put(FileUtils.ONE_GB, "GB");//(Gigabyte,吉字节,又称“千兆”)=1024MB
     DIVISOR_AND_UNIT_MAP.put(FileUtils.ONE_MB, "MB");//(Megabyte,兆字节,简称“兆”)=1024KB
     DIVISOR_AND_UNIT_MAP.put(FileUtils.ONE_KB, "KB");//(Kilobyte 千字节)=1024B
 }

现在你可以重构成:

 
 // 除数和单位的map,必须是有顺序的 从大到小.
 private static final Map<Long, String> DIVISOR_AND_UNIT_MAP = ConvertUtil.toMapUseEntrys(
                 Pair.of(FileUtils.ONE_TB, "TB"), //(Terabyte,太字节,或百万兆字节)=1024GB,其中1024=2^10(2的10次方) 
                 Pair.of(FileUtils.ONE_GB, "GB"), //(Gigabyte,吉字节,又称“千兆”)=1024MB
                 Pair.of(FileUtils.ONE_MB, "MB"), //(Megabyte,兆字节,简称“兆”)=1024KB
                 Pair.of(FileUtils.ONE_KB, "KB")); //(Kilobyte 千字节)=1024B

代码更加简洁

Type Parameters:: V - the value type; K - the key type
Parameters:: mapEntrys - the entrys
Returns:: 如果 entrys 是null,返回 Collections.emptyMap()
如果 entrys 有元素是null,将会抛出异常 IllegalArgumentException
Since:: 1.7.1, 1.9.5 change name
See Also:: ImmutablePair.ImmutablePair(Object, Object), Pair.of(Object, Object)

toProperties
```
public static Properties toProperties(Map<String,String> map)
```
将map转成 Properties.
说明:
1. 由于 Properties 只能保存非空的key和value,因此如果map 有key或者value是null,将会抛出NullPointerException
示例:
```
 Map<String, String> map = toMap("name", "feilong");
 Properties properties = ConvertUtil.toProperties(map);
 
 LOGGER.debug(JsonUtil.format(properties));
 
```
返回:
```
 {"name": "feilong"}
 
```
Parameters:
map - the map

Returns:
如果 map 是null,返回 empty Properties
Since:

1.7.3

See Also:
MapUtils.toProperties(Map)

toList
```
public static <T> List<T> toList(Enumeration<T> enumeration)
```
将枚举 enumeration 转成 List.
示例:
```
 toList((Enumeration<String>) null) = emptyList()
 
```
Type Parameters:
T - the generic type
Parameters:
enumeration - the enumeration

Returns:
如果 enumeration 是null,返回 Collections.emptyList()
否则返回 Collections.list(Enumeration)
Since:

1.0.7

See Also:
Collections.emptyList(), Collections.EMPTY_LIST, Collections.list(Enumeration), EnumerationUtils.toList(Enumeration)

toList
```
public static <T> List<T> toList(Collection<T> collection)
```
将集合 collection 转成 list.
说明:
1. 此方法很适合快速的将set转成list这样的操作
示例:
```
 Set<String> set = new LinkedHashSet<>();
 Collections.addAll(set, "a", "a", "b", "b");
 LOGGER.debug("{}", toList(set));
 
```
返回:
```
 [a,b]
 
```
Type Parameters:
T - the generic type
Parameters:
collection - the collection

Returns:
如果 collection 是null,返回 Collections.emptyList()
如果 collection instanceof List,那么强转成 list返回
否则返回 new ArrayList(collection)
Since:

1.6.1

See Also:
IterableUtils.toList(Iterable), IteratorUtils.toList(Iterator)

toList
```
@SafeVarargs
public static <T> List<T> toList(T... arrays)
```
数组转成 (ArrayList).
说明:
1. 此方法返回的list可以进行add等操作
2. 如果直接使用Arrays#asList(Object...)返回的list没有实现 Collection#add(Object)等方法,执行list.add("c");操作的话会导致异常!
3. 而本方法使用 ArrayList.ArrayList(java.util.Collection) 来进行重新封装返回,可以执行正常的list操作
特别适合:
如果你要通过以下方式来构造list:
```
 
 List<String> list = new ArrayList<>();
 list.add("feilong1");
 list.add("feilong2");
 list.add("feilong2");
 list.add("feilong3");
 
 
```
此时你可以使用:
```
 List<String> list = toList("feilong1", "feilong2", "feilong2", "feilong3");
 
```
代码会更简洁
甚至于:
有很多时候,参数需要一个对象list,构造的时候,你需要这样
```
 
 List<UserAddress> userAddresseList = new ArrayList<>();
 UserAddress userAddress = new UserAddress();
 userAddress.setAddress("上海");
 userAddresseList.add(userAddress);
 
 
```
你可以重构成:
```
 UserAddress userAddress = new UserAddress();
 userAddress.setAddress("上海");
 List<UserAddress> userAddresseList = toList(userAddress);
 
```
Type Parameters:
T - the generic type
Parameters:
arrays - T数组

Returns:
如果 arrays 是null或者empty,返回 Collections.emptyList()
提别提醒:注意动态数组(Varargs)的陷阱:
```
         assertEquals(emptyList(), toList((User[]) null));
         
         //-------------------------------------------------
 
         List<User> list = newArrayList();
         list.add(null);
 
         assertEquals(list, toList((User) null));
         
```
否则返回 new ArrayList<T>(Arrays.asList(arrays));
See Also:
Arrays.asList(Object...), Collections.singleton(Object), Collections.addAll(Collection, Object...), Collections.singletonList(Object), "org.springframework.util.CollectionUtils#arrayToList(Object)"

toSet

@SafeVarargs
public static <T> Set<T> toSet(T... arrays)

数组转成 Set (LinkedHashSet).

说明:

此方法返回的是LinkedHashSet

特别适合:

如果你要通过以下方式来构造Set:

 
 Set<String> set = new LinkedHashSet<>();
 set.add("feilong1");
 set.add("feilong2");
 set.add("feilong2");
 set.add("feilong3");

此时你可以使用:

 Set<String> set = toSet("feilong1", "feilong2", "feilong2", "feilong3");

代码会更简洁

甚至于:

有很多时候,参数需要一个对象Set,构造的时候,你需要这样

 Set<UserAddress> userAddresseSet = new LinkedHashSet<>();
 UserAddress userAddress = new UserAddress();
 userAddress.setAddress("上海");
 userAddresseSet.add(userAddress);

你可以重构成:

 UserAddress userAddress = new UserAddress();
 userAddress.setAddress("上海");
 Set<UserAddress> userAddresseSet = toSet(userAddress);

Type Parameters:

T - the generic type

Parameters:

arrays - the arrays

Returns:

如果 arrays 是null或者empty,返回 Collections.emptySet()
提别提醒:注意动态数组(Varargs)的陷阱:

         assertEquals(emptySet(), toSet((User[]) null));
         
         //-------------------------------------------------
 
         Set<User> set = new LinkedHashSet<>();
         set.add(null);
 
         assertEquals(list, toSet((User) null));

否则返回 new LinkedHashSet<T>(Arrays.asList(arrays));

Since:

1.9.6

See Also:

"com.google.common.collect.Sets#newHashSet(E...)"

toArray

@SafeVarargs
public static <T> T[] toArray(T... arrays)

将动态数组转成数组.

示例:

 String[] array = ConvertUtil.toArray("1", "2");                  =   ["1", "2"];
 
 String[] emptyArray = ConvertUtil.<String>toArray();     =   [] ; //= new String[] {};
 Integer[] emptyArray = ConvertUtil.<Integer>toArray();   =   [] ; //= new Integer[] {};
 
 //注意
 String[] nullArray = ConvertUtil.toArray(null)                   =   null;
 ConvertUtil.toArray((String) null)                               =   new String[] { null }

注意:

数组是具体化的(reified),而泛型在运行时是被擦除的(erasure)。
数组是在运行时才去判断数组元素的类型约束,而泛型正好相反,在运行时,泛型的类型信息是会被擦除的,只有编译的时候才会对类型进行强化。
泛型擦除的规则:

所有参数化容器类都被擦除成非参数化的(raw type); 如 List<E>、List<List<E>>都被擦除成 List

所有参数化数组都被擦除成非参数化的数组;如 List<E>[],被擦除成 List[]

Raw type 的容器类,被擦除成其自身,如 List<E>被擦除成 List

原生类型(int,String 还有 wrapper 类)都擦除成他们的自身

参数类型 E,如果没有上限,则被擦除成 Object

所有约束参数如<? Extends E>、<X extends E>都被擦除成 E

如果有多个约束,擦除成第一个,如<T extends Object & E>,则擦除成 Object

这将会导致下面的代码:
 
 public static <K, V> Map<K, V[]> toArrayValueMap(Map<K, V> singleValueMap){
     Map<K, V[]> arrayValueMap = newLinkedHashMap(singleValueMap.size());//保证顺序和参数singleValueMap顺序相同
     for (Map.Entry<K, V> entry : singleValueMap.entrySet()){
         arrayValueMap.put(entry.getKey(), toArray(entry.getValue()));//注意此处的Value不要声明成V,否则会变成Object数组
     }
     return arrayValueMap;
 }
 
调用的时候,
 Map<String, String> singleValueMap = MapUtil.newLinkedHashMap(2);
 singleValueMap.put("province", "江苏省");
 singleValueMap.put("city", "南通市");
 
 Map<String, String[]> arrayValueMap = MapUtil.toArrayValueMap(singleValueMap);
 String[] strings = arrayValueMap.get("province");//此时返回的是 Object[]
 
会出现异常
 java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
 

Type Parameters:: T - the generic type
Parameters:: arrays - the arrays
Returns:: 如果 arrays 是null,返回null
Since:: commons-lang 3, 1.6.0
See Also:: ArrayUtils.toArray(Object...)

toArray
```
public static <T> T[] toArray(Collection<T> collection,
              Class<T> arrayComponentType)
```
将集合 collection 转成数组.
示例:
```
 List<String> list = new ArrayList<>();
 list.add("xinge");
 list.add("feilong");
 
```
以前你需要写成:
```
 list.toArray(new String[list.size()]);
 
```
现在你只需要写成:
```
 String[] array = ConvertUtil.toArray(list, String.class);
 LOGGER.info(JsonUtil.format(array));
 
```
返回:
```
 ["xinge","feilong"]
 
```
Type Parameters:
T - the generic type
Parameters:
collection - collection
arrayComponentType - 数组组件类型的 Class

Returns:
如果 collection 是null,直接返回null
如果 arrayComponentType 是null,抛出 NullPointerException
Since:

1.2.2

See Also:
Array.newInstance(Class, int), Array.newInstance(Class, int...), Collection.toArray(), Collection.toArray(Object[]), List.toArray(), List.toArray(Object[]), Vector.toArray(), Vector.toArray(Object[]), LinkedList.toArray(), LinkedList.toArray(Object[]), ArrayList.toArray(), ArrayList.toArray(Object[]), IteratorUtils.toArray(Iterator,Class), "org.springframework.util.StringUtils#toStringArray(Collection)"

toArray
```
public static <T> T[] toArray(String[] toBeConvertedValue,
              Class<T> targetType)
```
将字符串数组 toBeConvertedValue 转成指定类型 targetType 的数组.
示例:
```
 String[] ss = { "2", "1" };
 toArray(ss, Long.class);                                     =   new Long[] { 2L, 1L }
 
 ConvertUtil.toArray((String[]) null, Serializable.class)     =   null
 
```
Type Parameters:
T - the generic type
Parameters:
toBeConvertedValue - the values
targetType - 要被转换的目标类型

Returns:
如果 toBeConvertedValue 是null,那么返回null
如果 targetType 是null,抛出 NullPointerException
否则调用 ConvertUtils.convert(String[], Class)
Since:

1.6.0

See Also:
ConvertUtils.convert(String[], Class), ConvertUtilsBean.convert(String[], Class)

toStrings
```
public static String[] toStrings(Object toBeConvertedValue)
```
将 toBeConvertedValue 转成String数组.
说明:
1. 该方法很适合将 非字符串数组的数组 转换成 字符串数组,比如
  URL[] urls = { URLUtil.newURL("http://www.exiaoshuo.com/jinyiyexing0/"), URLUtil.newURL("http://www.exiaoshuo.com/jinyiyexing1/"), URLUtil.newURL("http://www.exiaoshuo.com/jinyiyexing2/"), null }; LOGGER.debug(JsonUtil.format(ConvertUtil.toStrings(urls)));
  返回:
  [ "http://www.exiaoshuo.com/jinyiyexing0/", "http://www.exiaoshuo.com/jinyiyexing1/", "http://www.exiaoshuo.com/jinyiyexing2/", null ]
  
  还有诸如 Integer[] 转成 String[]
  
  ConvertUtil.toStrings(new Integer[] { 1, 2, 5 }) = [ "1", "2", "5" ]
2. 也可以将字符串解析成数组 in the Java language into a List individual Strings for each element, 根据以下规则:
  
  字符串转成数组的规则:
  参见 parseElements
  
  The string is expected to be a comma-separated list of values.
  
  自动去除开头的 '{' 和结束的'}'.
  
  每个元素前后的空格将会去除.
  
  Elements in the list may be delimited by single or double quotes. Within a quoted elements, the normal Java escape sequences are valid.
  
  示例:
  
  ConvertUtil.toStrings("{5,4, 8,2;8 9_5@3`a}"); = ["5","4","8","2","8","9","5","3","a"]
Parameters:
toBeConvertedValue - the to be converted value

Returns:
如果 toBeConvertedValue 是null,返回null
Since:

1.4.0

See Also:
ArrayConverter.convertToType(Class, Object), ArrayConverter.parseElements(Class, String), convert(Object, Class)

toIterator
```
public static <T> Iterator<T> toIterator(Object toBeConvertedValue)
```
将 toBeConvertedValue转成Iterator类型.
示例:
```
 // null
 toIterator(null) = null
 
 //PrimitiveArray
 int[] i2 = { 1, 2 };
 Iterator<Integer> iterator = toIterator(i2);
 
 //逗号分隔的字符串
 Iterator<String> iterator = toIterator("1,2");
 
 //collection
 List<String> list = new ArrayList<>();
 list.add("aaaa");
 list.add("nnnnn");
 
 Iterator<String> iterator = toIterator(list);
 
 //Enumeration
 Enumeration<Object> enumeration = new StringTokenizer("this is a test");
 Iterator<String> iterator = toIterator(enumeration);
 
 
```
支持以下类型:
- 逗号分隔的字符串,先使用toStrings(Object) 转成数组
- 数组(包括包装类型数组以及原始类型数组)
- 如果是Map,将 Map.values() 转成Iterator
- Collection
- Iterator
- Enumeration
- Dictionary
- Node
- NodeList
Type Parameters:
T - the generic type
Parameters:
toBeConvertedValue - the to be converted value

Returns:
如果 toBeConvertedValue 是null,返回null
如果 toBeConvertedValue 是字符串,先转成数组,再转成迭代器
否则转成 IteratorUtils.getIterator(Object)
Since:

Commons Collections4.0

See Also:
Collection.iterator(), EnumerationIterator.EnumerationIterator(Enumeration), IteratorUtils.asIterator(Enumeration), IteratorUtils.getIterator(Object), "org.apache.taglibs.standard.tag.common.core.ForEachSupport#supportedTypeForEachIterator(Object)"

convert

public static <T> T convert(Object toBeConvertedValue,
            Class<T> targetType)

将 toBeConvertedValue 转成指定 targetType 类型的对象.

示例:

 ConvertUtil.convert("1", Integer.class)      =1
 ConvertUtil.convert("", Integer.class)       =0
 ConvertUtil.convert("1", Long.class)         =1

此外,该方法特别适合数组类型的转换,比如 Type[] 转成 Class []:

原来的写法:

 
 Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
 int length = actualTypeArguments.length;
 Class<?>[] klasses = new Class<?>[length];
 for (int i = 0, j = length; i < j; ++i){
     klasses[i] = (Class<?>) actualTypeArguments[i];
 }
 
 return klasses;

现在可以重构成:

 Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
 return convert(actualTypeArguments, Class[].class);

注意:

如果targetType的转换器没有注册,那么传入的value原样返回,
比如ConvertUtil.convert("zh_CN", Locale.class) 由于找不到converter,那么返回"zh_CN".

如果转换不了,会使用默认值

如果传的 toBeConvertedValue是 toBeConvertedValue.getClass().isArray() 或者 Collection

如果 targetType 不是数组

那么会取第一个元素进行转换,
参见AbstractConverter.convert(Class, Object),调用的 AbstractConverter.convertArray(Object) 方法

如果 targetType 是数组

参见 ArrayConverter#convertToType(Class, Object) 会基于targetType 构造一个数组对象,大小长度就是 toBeConvertedValue的大小或者长度, 然后迭代 toBeConvertedValue 依次进行转换

注意:

该方法不适合 list转换成字符串,比如:
 ConvertUtil.toString(toList("张飞", "关羽", "", "赵云"), String.class) = "张飞"
 
,请使用 toString(Collection, ToStringConfig)

该方法也不适合 array 转换成字符串,比如:
 Integer[] int1 = { 2, null, 1, null };
 LOGGER.debug(ConvertUtil.toString(int1),String.class);        = 2
 
请使用 toString(Object[], ToStringConfig)

对于 Array 转成 String:

参见 ArrayConverter#convertToString(Object)
在转换的过程中,如果发现object是数组,将使用 Array#get(Object, int)来获得数据,
如果发现不是数组,将会将object转成集合 ArrayConverter#convertToCollection(Class, Object)再转成迭代器 Collection.iterator()

在将object转成集合 ArrayConverter#convertToCollection(Class, Object)时候,有以下规则:

The string is expected to be a comma-separated list of values.

字符串可以被'{' and '}'分隔符包裹.

去除前后空白.

Elements in the list may be delimited by single or double quotes. Within a quoted elements, the normal Java escape sequences are valid.

默认:

字段说明

int defaultSize 指定构建的默认数组的大小 or if less than zero indicates that a null default value should be used.

char delimiter = ',' 分隔符,转成的string中的元素分隔符

char[] allowedChars = new char[] {'.', '-'} 用于StreamTokenizer分隔字符串

boolean onlyFirstToString = true; 只转第一个值

字段	说明
int defaultSize	指定构建的默认数组的大小 or if less than zero indicates that a `null` default value should be used.
char delimiter = ','	分隔符,转成的string中的元素分隔符
char[] allowedChars = new char[] {'.', '-'}	用于`StreamTokenizer`分隔字符串
boolean onlyFirstToString = true;	只转第一个值

Type Parameters:: T - the generic type
Parameters:: toBeConvertedValue - 需要被转换的对象/值; targetType - 要转成什么类型
Returns:: 如果 targetType 是null,抛出 NullPointerException
如果 toBeConvertedValue 是null,那么直接返回null
否则返回 ConvertUtils.convert(Object, Class)
See Also:: ConvertUtils.convert(Object, Class), AbstractConverter.convert(Class, Object), ArrayConverter.convertToType(Class, Object)

toLocale
```
public static Locale toLocale(Object locale)
```
将对象转成 Locale.
示例:
```
 ConvertUtil.toLocale(null)       = null
 ConvertUtil.toLocale("zh_CN")    = Locale.CHINA
 
```
Parameters:
locale - 可以是 null ,字符串 或者直接的 Locale对象

Returns:
如果 locale 是null,返回 null
如果 locale instanceof Locale,返回 (Locale) locale
如果 locale instanceof String,返回 LocaleUtils.toLocale(String)
其他的类型,将抛出 UnsupportedOperationException
Since:

1.7.2

See Also:
LocaleUtils.toLocale(String)

Class ConvertUtil

关于类型转换:

ConvertUtils 几个方法的区别:

Method Summary

Methods inherited from class java.lang.Object

Method Detail

registerStandardDefaultNull

registerSimpleDateLocaleConverter

toBoolean

示例:

逻辑及规则:

和 Boolean.parseBoolean(String)的区别:

toInteger

示例:

示例:

toInteger

示例:

示例:

toLong

示例:

toBigDecimal

示例:

Double 转成 BigDecimal注意点:

toIntegers

说明:

示例:

示例:

示例:

toLongs

说明:

示例:

示例:

示例:

特别适合以下形式的代码:

toString

示例:

toString

示例:

说明

toString

示例:

如果原始类型数组需要转换:

说明

toString

示例:

关于 default ToStringConfig:

关于 ToStringConfig prefix(since 1.12.9):

toString

示例:

如果原始类型数组需要转换:

关于 default ToStringConfig:

关于 ToStringConfig prefix(since 1.12.9):

toEnumeration

说明:

示例:

toMap

说明:

示例:

重构:

toMap

说明:

重构:

toMap

示例:

说明:

关于 Properties

toMap

说明:

示例:

toMap

说明:

示例:

toMap

说明:

示例:

toMap

说明:

Pair 示例:

AbstractMap.SimpleEntry 示例:

toMapUseEntrys

`ConvertUtils` 几个方法的区别:

和 `Boolean.parseBoolean(String)`的区别:

`Double` 转成 `BigDecimal`注意点:

关于 default `ToStringConfig`:

关于 `ToStringConfig` prefix(since 1.12.9):

关于 default `ToStringConfig`:

关于 `ToStringConfig` prefix(since 1.12.9):

关于 `Properties`

`Pair` 示例:

`AbstractMap.SimpleEntry` 示例:

`Pair` 示例:

`AbstractMap.SimpleEntry` 示例: