ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

修复Convert#toMap默认转成HashMap的问题

Browse Source
This commit is contained in:
Looly 2022-07-29 22:13:46 +08:00
parent d4d8522cd4
commit 52dec0c301
2 changed files with 93 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -43,6 +43,7 @@
* 【core 】 修复UrlBuilder无法配置末尾追加“/”问题（issue#2459@Github） * 【core 】 修复UrlBuilder无法配置末尾追加“/”问题（issue#2459@Github）
* 【core 】 修复SystemPropsUtil.getBoolean方法应该只有值为true时才返回true，其他情况都应该返回false（pr#717@Gitee） * 【core 】 修复SystemPropsUtil.getBoolean方法应该只有值为true时才返回true，其他情况都应该返回false（pr#717@Gitee）
* 【core 】 修复isBase64判断不准确的问题（pr#727@Gitee） * 【core 】 修复isBase64判断不准确的问题（pr#727@Gitee）
* 【core 】 修复Convert#toMap默认转成HashMap的问题（pr#729@Gitee）
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------

181
hutool-core/src/main/java/cn/hutool/core/convert/Convert.java
View File

@ -33,7 +33,6 @@ import java.util.concurrent.TimeUnit;
* 类型转换器 * 类型转换器
* *
* @author xiaoleilu * @author xiaoleilu
*
*/ */
public class Convert { public class Convert {
@ -42,7 +41,7 @@ public class Convert {
* 如果给定的值为null，或者转换失败，返回默认值<br> * 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -78,7 +77,7 @@ public class Convert {
* 如果给定的值为null，或者转换失败，返回默认值<br> * 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -114,7 +113,7 @@ public class Convert {
* 如果给定的值为{@code null}，或者转换失败，返回默认值<br> * 如果给定的值为{@code null}，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -161,7 +160,7 @@ public class Convert {
* 如果给定的值为{@code null}，或者转换失败，返回默认值<br> * 如果给定的值为{@code null}，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -197,7 +196,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -233,7 +232,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -268,7 +267,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -303,7 +302,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -338,7 +337,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -373,7 +372,7 @@ public class Convert {
* String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br> * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -408,7 +407,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -433,7 +432,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
*/ */
@ -458,7 +457,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
* @since 4.1.6 * @since 4.1.6
@ -472,7 +471,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
* @since 5.0.7 * @since 5.0.7
@ -498,7 +497,7 @@ public class Convert {
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错 * 转换失败不会报错
* *
* @param value 被转换的值 * @param value 被转换的值
* @param defaultValue 转换错误时的默认值 * @param defaultValue 转换错误时的默认值
* @return 结果 * @return 结果
* @since 5.0.7 * @since 5.0.7
@ -524,9 +523,9 @@ public class Convert {
* 转换为Enum对象<br> * 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值<br> * 如果给定的值为空，或者转换失败，返回默认值<br>
* *
* @param <E> 枚举类型 * @param <E> 枚举类型
* @param clazz Enum的Class * @param clazz Enum的Class
* @param value 值 * @param value 值
* @param defaultValue 默认值 * @param defaultValue 默认值
* @return Enum * @return Enum
*/ */
@ -539,7 +538,7 @@ public class Convert {
* 转换为Enum对象<br> * 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值{@code null}<br> * 如果给定的值为空，或者转换失败，返回默认值{@code null}<br>
* *
* @param <E> 枚举类型 * @param <E> 枚举类型
* @param clazz Enum的Class * @param clazz Enum的Class
* @param value 值 * @param value 值
* @return Enum * @return Enum
@ -552,8 +551,8 @@ public class Convert {
* 转换为集合类 * 转换为集合类
* *
* @param collectionType 集合类型 * @param collectionType 集合类型
* @param elementType 集合中元素类型 * @param elementType 集合中元素类型
* @param value 被转换的值 * @param value 被转换的值
* @return {@link Collection} * @return {@link Collection}
* @since 3.0.8 * @since 3.0.8
*/ */
@ -575,9 +574,9 @@ public class Convert {
/** /**
* 转换为ArrayList * 转换为ArrayList
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param elementType 集合中元素类型 * @param elementType 集合中元素类型
* @param value 被转换的值 * @param value 被转换的值
* @return {@link ArrayList} * @return {@link ArrayList}
* @since 4.1.20 * @since 4.1.20
*/ */
@ -589,9 +588,9 @@ public class Convert {
/** /**
* 转换为HashSet * 转换为HashSet
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param elementType 集合中元素类型 * @param elementType 集合中元素类型
* @param value 被转换的值 * @param value 被转换的值
* @return {@link HashSet} * @return {@link HashSet}
* @since 5.7.3 * @since 5.7.3
*/ */
@ -603,18 +602,18 @@ public class Convert {
/** /**
* 转换为Map，若value原本就是Map，则转为原始类型，若不是则默认转为HashMap * 转换为Map，若value原本就是Map，则转为原始类型，若不是则默认转为HashMap
* *
* @param <K> 键类型 * @param <K> 键类型
* @param <V> 值类型 * @param <V> 值类型
* @param keyType 键类型 * @param keyType 键类型
* @param valueType 值类型 * @param valueType 值类型
* @param value 被转换的值 * @param value 被转换的值
* @return {@link Map} * @return {@link Map}
* @since 4.6.8 * @since 4.6.8
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static <K, V> Map<K, V> toMap(Class<K> keyType, Class<V> valueType, Object value) { public static <K, V> Map<K, V> toMap(Class<K> keyType, Class<V> valueType, Object value) {
if (value instanceof Map) { if (value instanceof Map) {
return toMap((Class<? extends Map>) value.getClass(), keyType, valueType, value); return toMap((Class<? extends Map<?, ?>>) value.getClass(), keyType, valueType, value);
} else { } else {
return toMap(HashMap.class, keyType, valueType, value); return toMap(HashMap.class, keyType, valueType, value);
} }
@ -623,15 +622,15 @@ public class Convert {
/** /**
* 转换为Map * 转换为Map
* *
* @param mapType 转后的具体Map类型 * @param mapType 转后的具体Map类型
* @param <K> 键类型 * @param <K> 键类型
* @param <V> 值类型 * @param <V> 值类型
* @param keyType 键类型 * @param keyType 键类型
* @param valueType 值类型 * @param valueType 值类型
* @param value 被转换的值 * @param value 被转换的值
* @return {@link Map} * @return {@link Map}
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings({"unchecked", "rawtypes"})
public static <K, V> Map<K, V> toMap(Class<? extends Map> mapType, Class<K> keyType, Class<V> valueType, Object value) { public static <K, V> Map<K, V> toMap(Class<? extends Map> mapType, Class<K> keyType, Class<V> valueType, Object value) {
return (Map<K, V>) new MapConverter(mapType, keyType, valueType).convert(value, null); return (Map<K, V>) new MapConverter(mapType, keyType, valueType).convert(value, null);
} }
@ -639,78 +638,78 @@ public class Convert {
/** /**
* 转换值为指定类型，类型采用字符串表示 * 转换值为指定类型，类型采用字符串表示
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param className 类的字符串表示 * @param className 类的字符串表示
* @param value 值 * @param value 值
* @return 转换后的值 * @return 转换后的值
* @since 4.0.7
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
* @since 4.0.7
*/ */
public static <T> T convertByClassName(String className, Object value) throws ConvertException{ public static <T> T convertByClassName(String className, Object value) throws ConvertException {
return convert(ClassUtil.loadClass(className), value); return convert(ClassUtil.loadClass(className), value);
} }
/** /**
* 转换值为指定类型 * 转换值为指定类型
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 类型 * @param type 类型
* @param value 值 * @param value 值
* @return 转换后的值 * @return 转换后的值
* @since 4.0.0
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
* @since 4.0.0
*/ */
public static <T> T convert(Class<T> type, Object value) throws ConvertException{ public static <T> T convert(Class<T> type, Object value) throws ConvertException {
return convert((Type)type, value); return convert((Type) type, value);
} }
/** /**
* 转换值为指定类型 * 转换值为指定类型
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param reference 类型参考，用于持有转换后的泛型类型 * @param reference 类型参考，用于持有转换后的泛型类型
* @param value 值 * @param value 值
* @return 转换后的值 * @return 转换后的值
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
*/ */
public static <T> T convert(TypeReference<T> reference, Object value) throws ConvertException{ public static <T> T convert(TypeReference<T> reference, Object value) throws ConvertException {
return convert(reference.getType(), value, null); return convert(reference.getType(), value, null);
} }
/** /**
* 转换值为指定类型 * 转换值为指定类型
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 类型 * @param type 类型
* @param value 值 * @param value 值
* @return 转换后的值 * @return 转换后的值
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
*/ */
public static <T> T convert(Type type, Object value) throws ConvertException{ public static <T> T convert(Type type, Object value) throws ConvertException {
return convert(type, value, null); return convert(type, value, null);
} }
/** /**
* 转换值为指定类型 * 转换值为指定类型
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 类型 * @param type 类型
* @param value 值 * @param value 值
* @param defaultValue 默认值 * @param defaultValue 默认值
* @return 转换后的值 * @return 转换后的值
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
* @since 4.0.0 * @since 4.0.0
*/ */
public static <T> T convert(Class<T> type, Object value, T defaultValue) throws ConvertException { public static <T> T convert(Class<T> type, Object value, T defaultValue) throws ConvertException {
return convert((Type)type, value, defaultValue); return convert((Type) type, value, defaultValue);
} }
/** /**
* 转换值为指定类型 * 转换值为指定类型
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 类型 * @param type 类型
* @param value 值 * @param value 值
* @param defaultValue 默认值 * @param defaultValue 默认值
* @return 转换后的值 * @return 转换后的值
* @throws ConvertException 转换器不存在 * @throws ConvertException 转换器不存在
@ -723,8 +722,8 @@ public class Convert {
* 转换值为指定类型，不抛异常转换<br> * 转换值为指定类型，不抛异常转换<br>
* 当转换失败时返回{@code null} * 当转换失败时返回{@code null}
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 目标类型 * @param type 目标类型
* @param value 值 * @param value 值
* @return 转换后的值，转换失败返回null * @return 转换后的值，转换失败返回null
* @since 4.5.10 * @since 4.5.10
@ -737,9 +736,9 @@ public class Convert {
* 转换值为指定类型，不抛异常转换<br> * 转换值为指定类型，不抛异常转换<br>
* 当转换失败时返回默认值 * 当转换失败时返回默认值
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 目标类型 * @param type 目标类型
* @param value 值 * @param value 值
* @param defaultValue 默认值 * @param defaultValue 默认值
* @return 转换后的值 * @return 转换后的值
* @since 4.5.10 * @since 4.5.10
@ -752,11 +751,11 @@ public class Convert {
* 转换值为指定类型，可选是否不抛异常转换<br> * 转换值为指定类型，可选是否不抛异常转换<br>
* 当转换失败时返回默认值 * 当转换失败时返回默认值
* *
* @param <T> 目标类型 * @param <T> 目标类型
* @param type 目标类型 * @param type 目标类型
* @param value 值 * @param value 值
* @param defaultValue 默认值 * @param defaultValue 默认值
* @param quietly 是否静默转换，true不抛异常 * @param quietly 是否静默转换，true不抛异常
* @return 转换后的值 * @return 转换后的值
* @since 5.3.2 * @since 5.3.2
*/ */
@ -765,7 +764,7 @@ public class Convert {
try { try {
return registry.convert(type, value, defaultValue); return registry.convert(type, value, defaultValue);
} catch (Exception e) { } catch (Exception e) {
if(quietly){ if (quietly) {
return defaultValue; return defaultValue;
} }
throw e; throw e;
@ -773,6 +772,7 @@ public class Convert {
} }
// ----------------------------------------------------------------------- 全角半角转换 // ----------------------------------------------------------------------- 全角半角转换
/** /**
* 半角转全角，{@code null}返回{@code null} * 半角转全角，{@code null}返回{@code null}
* *
@ -786,12 +786,12 @@ public class Convert {
/** /**
* 半角转全角，{@code null}返回{@code null} * 半角转全角，{@code null}返回{@code null}
* *
* @param input String * @param input String
* @param notConvertSet 不替换的字符集合 * @param notConvertSet 不替换的字符集合
* @return 全角字符串，{@code null}返回{@code null} * @return 全角字符串，{@code null}返回{@code null}
*/ */
public static String toSBC(String input, Set<Character> notConvertSet) { public static String toSBC(String input, Set<Character> notConvertSet) {
if(StrUtil.isEmpty(input)){ if (StrUtil.isEmpty(input)) {
return input; return input;
} }
final char[] c = input.toCharArray(); final char[] c = input.toCharArray();
@ -823,12 +823,12 @@ public class Convert {
/** /**
* 替换全角为半角 * 替换全角为半角
* *
* @param text 文本 * @param text 文本
* @param notConvertSet 不替换的字符集合 * @param notConvertSet 不替换的字符集合
* @return 替换后的字符 * @return 替换后的字符
*/ */
public static String toDBC(String text, Set<Character> notConvertSet) { public static String toDBC(String text, Set<Character> notConvertSet) {
if(StrUtil.isBlank(text)) { if (StrUtil.isBlank(text)) {
return text; return text;
} }
final char[] c = text.toCharArray(); final char[] c = text.toCharArray();
@ -850,10 +850,11 @@ public class Convert {
} }
// --------------------------------------------------------------------- hex // --------------------------------------------------------------------- hex
/** /**
* 字符串转换成十六进制字符串，结果为小写 * 字符串转换成十六进制字符串，结果为小写
* *
* @param str 待转换的ASCII字符串 * @param str 待转换的ASCII字符串
* @param charset 编码 * @param charset 编码
* @return 16进制字符串 * @return 16进制字符串
* @see HexUtil#encodeHexStr(String, Charset) * @see HexUtil#encodeHexStr(String, Charset)
@ -887,7 +888,7 @@ public class Convert {
/** /**
* 十六进制转换字符串 * 十六进制转换字符串
* *
* @param hexStr Byte字符串(Byte之间无分隔符 如:[616C6B]) * @param hexStr Byte字符串(Byte之间无分隔符 如:[616C6B])
* @param charset 编码 {@link Charset} * @param charset 编码 {@link Charset}
* @return 对应的字符串 * @return 对应的字符串
* @see HexUtil#decodeHexStr(String, Charset) * @see HexUtil#decodeHexStr(String, Charset)
@ -923,9 +924,9 @@ public class Convert {
* 给定字符串转换字符编码<br> * 给定字符串转换字符编码<br>
* 如果参数为空，则返回原字符串，不报错。 * 如果参数为空，则返回原字符串，不报错。
* *
* @param str 被转码的字符串 * @param str 被转码的字符串
* @param sourceCharset 原字符集 * @param sourceCharset 原字符集
* @param destCharset 目标字符集 * @param destCharset 目标字符集
* @return 转换后的字符串 * @return 转换后的字符串
* @see CharsetUtil#convert(String, String, String) * @see CharsetUtil#convert(String, String, String)
*/ */
@ -941,8 +942,8 @@ public class Convert {
* 转换时间单位 * 转换时间单位
* *
* @param sourceDuration 时长 * @param sourceDuration 时长
* @param sourceUnit 源单位 * @param sourceUnit 源单位
* @param destUnit 目标单位 * @param destUnit 目标单位
* @return 目标单位的时长 * @return 目标单位的时长
*/ */
public static long convertTime(long sourceDuration, TimeUnit sourceUnit, TimeUnit destUnit) { public static long convertTime(long sourceDuration, TimeUnit sourceUnit, TimeUnit destUnit) {
@ -952,13 +953,14 @@ public class Convert {
} }
// --------------------------------------------------------------- 原始包装类型转换 // --------------------------------------------------------------- 原始包装类型转换
/** /**
* 原始类转为包装类，非原始类返回原类 * 原始类转为包装类，非原始类返回原类
* *
* @see BasicType#wrap(Class)
* @param clazz 原始类 * @param clazz 原始类
* @return 包装类 * @return 包装类
* @see BasicType#wrap(Class) * @see BasicType#wrap(Class)
* @see BasicType#wrap(Class)
*/ */
public static Class<?> wrap(Class<?> clazz) { public static Class<?> wrap(Class<?> clazz) {
return BasicType.wrap(clazz); return BasicType.wrap(clazz);
@ -967,16 +969,17 @@ public class Convert {
/** /**
* 包装类转为原始类，非包装类返回原类 * 包装类转为原始类，非包装类返回原类
* *
* @see BasicType#unWrap(Class)
* @param clazz 包装类 * @param clazz 包装类
* @return 原始类 * @return 原始类
* @see BasicType#unWrap(Class) * @see BasicType#unWrap(Class)
* @see BasicType#unWrap(Class)
*/ */
public static Class<?> unWrap(Class<?> clazz) { public static Class<?> unWrap(Class<?> clazz) {
return BasicType.unWrap(clazz); return BasicType.unWrap(clazz);
} }
// -------------------------------------------------------------------------- 数字和英文转换 // -------------------------------------------------------------------------- 数字和英文转换
/** /**
* 将阿拉伯数字转为英文表达方式 * 将阿拉伯数字转为英文表达方式
* *
@ -1006,7 +1009,7 @@ public class Convert {
/** /**
* 将阿拉伯数字转为中文表达方式 * 将阿拉伯数字转为中文表达方式
* *
* @param number 数字 * @param number 数字
* @param isUseTraditional 是否使用繁体字（金额形式） * @param isUseTraditional 是否使用繁体字（金额形式）
* @return 中文 * @return 中文
* @since 3.2.3 * @since 3.2.3
@ -1026,7 +1029,7 @@ public class Convert {
* @return 数字 * @return 数字
* @since 5.6.0 * @since 5.6.0
*/ */
public static int chineseToNumber(String number){ public static int chineseToNumber(String number) {
return NumberChineseFormatter.chineseToNumber(number); return NumberChineseFormatter.chineseToNumber(number);
} }
@ -1038,28 +1041,28 @@ public class Convert {
* @since 3.2.3 * @since 3.2.3
*/ */
public static String digitToChinese(Number n) { public static String digitToChinese(Number n) {
if(null == n) { if (null == n) {
return "零"; return "零";
} }
return NumberChineseFormatter.format(n.doubleValue(), true, true); return NumberChineseFormatter.format(n.doubleValue(), true, true);
} }
/** /**
* 中文大写数字金额转换为数字，返回结果以元为单位的BigDecimal类型数字 * 中文大写数字金额转换为数字，返回结果以元为单位的BigDecimal类型数字<br>
*
* 如： * 如：
* “陆万柒仟伍佰伍拾陆元叁角贰分”返回“67556.32” * “陆万柒仟伍佰伍拾陆元叁角贰分”返回“67556.32”
* “叁角贰分”返回“0.32” * “叁角贰分”返回“0.32”
* *
* @param chineseMoneyAmount 中文大写数字金额 * @param chineseMoneyAmount 中文大写数字金额
* @return 返回结果以元为单位的BigDecimal类型数字 * @return 返回结果以元为单位的BigDecimal类型数字
* @since 5.8.5 * @since 5.8.5
*/ */
public static BigDecimal chineseMoneyToNumber(String chineseMoneyAmount){ public static BigDecimal chineseMoneyToNumber(String chineseMoneyAmount) {
return NumberChineseFormatter.chineseMoneyToNumber(chineseMoneyAmount); return NumberChineseFormatter.chineseMoneyToNumber(chineseMoneyAmount);
} }
// -------------------------------------------------------------------------- 数字转换 // -------------------------------------------------------------------------- 数字转换
/** /**
* int转byte * int转byte
* *