odcc/CpzIdc.git

yanzhaofeige

2024-09-30 3c4fee1db116c11d4f04727cfe076d7c94daeaf2

commit \| author \| age
43dc29	1	package com.odcc.cpzidc.common.core.text;
Y	2
	3	import java.math.BigDecimal;
	4	import java.math.BigInteger;
	5	import java.math.RoundingMode;
	6	import java.nio.ByteBuffer;
	7	import java.nio.charset.Charset;
	8	import java.text.NumberFormat;
	9	import java.util.Set;
	10	import com.odcc.cpzidc.common.utils.StringUtils;
	11	import org.apache.commons.lang3.ArrayUtils;
	12
	13	/**
	14	* 类型转换器
	15	*
	16	* @author ruoyi
	17	*/
	18	public class Convert
	19	{
	20	/**
	21	* 转换为字符串<br>
	22	* 如果给定的值为null，或者转换失败，返回默认值<br>
	23	* 转换失败不会报错
	24	*
	25	* @param value 被转换的值
	26	* @param defaultValue 转换错误时的默认值
	27	* @return 结果
	28	*/
	29	public static String toStr(Object value, String defaultValue)
	30	{
	31	if (null == value)
	32	{
	33	return defaultValue;
	34	}
	35	if (value instanceof String)
	36	{
	37	return (String) value;
	38	}
	39	return value.toString();
	40	}
	41
	42	/**
	43	* 转换为字符串<br>
	44	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	45	* 转换失败不会报错
	46	*
	47	* @param value 被转换的值
	48	* @return 结果
	49	*/
	50	public static String toStr(Object value)
	51	{
	52	return toStr(value, null);
	53	}
	54
	55	/**
	56	* 转换为字符<br>
	57	* 如果给定的值为null，或者转换失败，返回默认值<br>
	58	* 转换失败不会报错
	59	*
	60	* @param value 被转换的值
	61	* @param defaultValue 转换错误时的默认值
	62	* @return 结果
	63	*/
	64	public static Character toChar(Object value, Character defaultValue)
	65	{
	66	if (null == value)
	67	{
	68	return defaultValue;
	69	}
	70	if (value instanceof Character)
	71	{
	72	return (Character) value;
	73	}
	74
	75	final String valueStr = toStr(value, null);
	76	return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
	77	}
	78
	79	/**
	80	* 转换为字符<br>
	81	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	82	* 转换失败不会报错
	83	*
	84	* @param value 被转换的值
	85	* @return 结果
	86	*/
	87	public static Character toChar(Object value)
	88	{
	89	return toChar(value, null);
	90	}
	91
	92	/**
	93	* 转换为byte<br>
	94	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
	95	* 转换失败不会报错
	96	*
	97	* @param value 被转换的值
	98	* @param defaultValue 转换错误时的默认值
	99	* @return 结果
	100	*/
	101	public static Byte toByte(Object value, Byte defaultValue)
	102	{
	103	if (value == null)
	104	{
	105	return defaultValue;
	106	}
	107	if (value instanceof Byte)
	108	{
	109	return (Byte) value;
	110	}
	111	if (value instanceof Number)
	112	{
	113	return ((Number) value).byteValue();
	114	}
	115	final String valueStr = toStr(value, null);
	116	if (StringUtils.isEmpty(valueStr))
	117	{
	118	return defaultValue;
	119	}
	120	try
	121	{
	122	return Byte.parseByte(valueStr);
	123	}
	124	catch (Exception e)
	125	{
	126	return defaultValue;
	127	}
	128	}
	129
	130	/**
	131	* 转换为byte<br>
	132	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	133	* 转换失败不会报错
	134	*
	135	* @param value 被转换的值
	136	* @return 结果
	137	*/
	138	public static Byte toByte(Object value)
	139	{
	140	return toByte(value, null);
	141	}
	142
	143	/**
	144	* 转换为Short<br>
	145	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
	146	* 转换失败不会报错
	147	*
	148	* @param value 被转换的值
	149	* @param defaultValue 转换错误时的默认值
	150	* @return 结果
	151	*/
	152	public static Short toShort(Object value, Short defaultValue)
	153	{
	154	if (value == null)
	155	{
	156	return defaultValue;
	157	}
	158	if (value instanceof Short)
	159	{
	160	return (Short) value;
	161	}
	162	if (value instanceof Number)
	163	{
	164	return ((Number) value).shortValue();
	165	}
	166	final String valueStr = toStr(value, null);
	167	if (StringUtils.isEmpty(valueStr))
	168	{
	169	return defaultValue;
	170	}
	171	try
	172	{
	173	return Short.parseShort(valueStr.trim());
	174	}
	175	catch (Exception e)
	176	{
	177	return defaultValue;
	178	}
	179	}
	180
	181	/**
	182	* 转换为Short<br>
	183	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	184	* 转换失败不会报错
	185	*
	186	* @param value 被转换的值
	187	* @return 结果
	188	*/
	189	public static Short toShort(Object value)
	190	{
	191	return toShort(value, null);
	192	}
	193
	194	/**
	195	* 转换为Number<br>
	196	* 如果给定的值为空，或者转换失败，返回默认值<br>
	197	* 转换失败不会报错
	198	*
	199	* @param value 被转换的值
	200	* @param defaultValue 转换错误时的默认值
	201	* @return 结果
	202	*/
	203	public static Number toNumber(Object value, Number defaultValue)
	204	{
	205	if (value == null)
	206	{
	207	return defaultValue;
	208	}
	209	if (value instanceof Number)
	210	{
	211	return (Number) value;
	212	}
	213	final String valueStr = toStr(value, null);
	214	if (StringUtils.isEmpty(valueStr))
	215	{
	216	return defaultValue;
	217	}
	218	try
	219	{
	220	return NumberFormat.getInstance().parse(valueStr);
	221	}
	222	catch (Exception e)
	223	{
	224	return defaultValue;
	225	}
	226	}
	227
	228	/**
	229	* 转换为Number<br>
	230	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	231	* 转换失败不会报错
	232	*
	233	* @param value 被转换的值
	234	* @return 结果
	235	*/
	236	public static Number toNumber(Object value)
	237	{
	238	return toNumber(value, null);
	239	}
	240
	241	/**
	242	* 转换为int<br>
	243	* 如果给定的值为空，或者转换失败，返回默认值<br>
	244	* 转换失败不会报错
	245	*
	246	* @param value 被转换的值
	247	* @param defaultValue 转换错误时的默认值
	248	* @return 结果
	249	*/
	250	public static Integer toInt(Object value, Integer defaultValue)
	251	{
	252	if (value == null)
	253	{
	254	return defaultValue;
	255	}
	256	if (value instanceof Integer)
	257	{
	258	return (Integer) value;
	259	}
	260	if (value instanceof Number)
	261	{
	262	return ((Number) value).intValue();
	263	}
	264	final String valueStr = toStr(value, null);
	265	if (StringUtils.isEmpty(valueStr))
	266	{
	267	return defaultValue;
	268	}
	269	try
	270	{
	271	return Integer.parseInt(valueStr.trim());
	272	}
	273	catch (Exception e)
	274	{
	275	return defaultValue;
	276	}
	277	}
	278
	279	/**
	280	* 转换为int<br>
	281	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	282	* 转换失败不会报错
	283	*
	284	* @param value 被转换的值
	285	* @return 结果
	286	*/
	287	public static Integer toInt(Object value)
	288	{
	289	return toInt(value, null);
	290	}
	291
	292	/**
	293	* 转换为Integer数组<br>
	294	*
	295	* @param str 被转换的值
	296	* @return 结果
	297	*/
	298	public static Integer[] toIntArray(String str)
	299	{
	300	return toIntArray(",", str);
	301	}
	302
	303	/**
	304	* 转换为Long数组<br>
	305	*
	306	* @param str 被转换的值
	307	* @return 结果
	308	*/
	309	public static Long[] toLongArray(String str)
	310	{
	311	return toLongArray(",", str);
	312	}
	313
	314	/**
	315	* 转换为Integer数组<br>
	316	*
	317	* @param split 分隔符
	318	* @param split 被转换的值
	319	* @return 结果
	320	*/
	321	public static Integer[] toIntArray(String split, String str)
	322	{
	323	if (StringUtils.isEmpty(str))
	324	{
	325	return new Integer[] {};
	326	}
	327	String[] arr = str.split(split);
	328	final Integer[] ints = new Integer[arr.length];
	329	for (int i = 0; i < arr.length; i++)
	330	{
	331	final Integer v = toInt(arr[i], 0);
	332	ints[i] = v;
	333	}
	334	return ints;
	335	}
	336
	337	/**
	338	* 转换为Long数组<br>
	339	*
	340	* @param split 分隔符
	341	* @param str 被转换的值
	342	* @return 结果
	343	*/
	344	public static Long[] toLongArray(String split, String str)
	345	{
	346	if (StringUtils.isEmpty(str))
	347	{
	348	return new Long[] {};
	349	}
	350	String[] arr = str.split(split);
	351	final Long[] longs = new Long[arr.length];
	352	for (int i = 0; i < arr.length; i++)
	353	{
	354	final Long v = toLong(arr[i], null);
	355	longs[i] = v;
	356	}
	357	return longs;
	358	}
	359
	360	/**
	361	* 转换为String数组<br>
	362	*
	363	* @param str 被转换的值
	364	* @return 结果
	365	*/
	366	public static String[] toStrArray(String str)
	367	{
	368	if (StringUtils.isEmpty(str))
	369	{
	370	return new String[] {};
	371	}
	372	return toStrArray(",", str);
	373	}
	374
	375	/**
	376	* 转换为String数组<br>
	377	*
	378	* @param split 分隔符
	379	* @param split 被转换的值
	380	* @return 结果
	381	*/
	382	public static String[] toStrArray(String split, String str)
	383	{
	384	return str.split(split);
	385	}
	386
	387	/**
	388	* 转换为long<br>
	389	* 如果给定的值为空，或者转换失败，返回默认值<br>
	390	* 转换失败不会报错
	391	*
	392	* @param value 被转换的值
	393	* @param defaultValue 转换错误时的默认值
	394	* @return 结果
	395	*/
	396	public static Long toLong(Object value, Long defaultValue)
	397	{
	398	if (value == null)
	399	{
	400	return defaultValue;
	401	}
	402	if (value instanceof Long)
	403	{
	404	return (Long) value;
	405	}
	406	if (value instanceof Number)
	407	{
	408	return ((Number) value).longValue();
	409	}
	410	final String valueStr = toStr(value, null);
	411	if (StringUtils.isEmpty(valueStr))
	412	{
	413	return defaultValue;
	414	}
	415	try
	416	{
	417	// 支持科学计数法
	418	return new BigDecimal(valueStr.trim()).longValue();
	419	}
	420	catch (Exception e)
	421	{
	422	return defaultValue;
	423	}
	424	}
	425
	426	/**
	427	* 转换为long<br>
	428	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	429	* 转换失败不会报错
	430	*
	431	* @param value 被转换的值
	432	* @return 结果
	433	*/
	434	public static Long toLong(Object value)
	435	{
	436	return toLong(value, null);
	437	}
	438
	439	/**
	440	* 转换为double<br>
	441	* 如果给定的值为空，或者转换失败，返回默认值<br>
	442	* 转换失败不会报错
	443	*
	444	* @param value 被转换的值
	445	* @param defaultValue 转换错误时的默认值
	446	* @return 结果
	447	*/
	448	public static Double toDouble(Object value, Double defaultValue)
	449	{
	450	if (value == null)
	451	{
	452	return defaultValue;
	453	}
	454	if (value instanceof Double)
	455	{
	456	return (Double) value;
	457	}
	458	if (value instanceof Number)
	459	{
	460	return ((Number) value).doubleValue();
	461	}
	462	final String valueStr = toStr(value, null);
	463	if (StringUtils.isEmpty(valueStr))
	464	{
	465	return defaultValue;
	466	}
	467	try
	468	{
	469	// 支持科学计数法
	470	return new BigDecimal(valueStr.trim()).doubleValue();
	471	}
	472	catch (Exception e)
	473	{
	474	return defaultValue;
	475	}
	476	}
	477
	478	/**
	479	* 转换为double<br>
	480	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	481	* 转换失败不会报错
	482	*
	483	* @param value 被转换的值
	484	* @return 结果
	485	*/
	486	public static Double toDouble(Object value)
	487	{
	488	return toDouble(value, null);
	489	}
	490
	491	/**
	492	* 转换为Float<br>
	493	* 如果给定的值为空，或者转换失败，返回默认值<br>
	494	* 转换失败不会报错
	495	*
	496	* @param value 被转换的值
	497	* @param defaultValue 转换错误时的默认值
	498	* @return 结果
	499	*/
	500	public static Float toFloat(Object value, Float defaultValue)
	501	{
	502	if (value == null)
	503	{
	504	return defaultValue;
	505	}
	506	if (value instanceof Float)
	507	{
	508	return (Float) value;
	509	}
	510	if (value instanceof Number)
	511	{
	512	return ((Number) value).floatValue();
	513	}
	514	final String valueStr = toStr(value, null);
	515	if (StringUtils.isEmpty(valueStr))
	516	{
	517	return defaultValue;
	518	}
	519	try
	520	{
	521	return Float.parseFloat(valueStr.trim());
	522	}
	523	catch (Exception e)
	524	{
	525	return defaultValue;
	526	}
	527	}
	528
	529	/**
	530	* 转换为Float<br>
	531	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	532	* 转换失败不会报错
	533	*
	534	* @param value 被转换的值
	535	* @return 结果
	536	*/
	537	public static Float toFloat(Object value)
	538	{
	539	return toFloat(value, null);
	540	}
	541
	542	/**
	543	* 转换为boolean<br>
	544	* String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
	545	* 转换失败不会报错
	546	*
	547	* @param value 被转换的值
	548	* @param defaultValue 转换错误时的默认值
	549	* @return 结果
	550	*/
	551	public static Boolean toBool(Object value, Boolean defaultValue)
	552	{
	553	if (value == null)
	554	{
	555	return defaultValue;
	556	}
	557	if (value instanceof Boolean)
	558	{
	559	return (Boolean) value;
	560	}
	561	String valueStr = toStr(value, null);
	562	if (StringUtils.isEmpty(valueStr))
	563	{
	564	return defaultValue;
	565	}
	566	valueStr = valueStr.trim().toLowerCase();
	567	switch (valueStr)
	568	{
	569	case "true":
	570	case "yes":
	571	case "ok":
	572	case "1":
	573	return true;
	574	case "false":
	575	case "no":
	576	case "0":
	577	return false;
	578	default:
	579	return defaultValue;
	580	}
	581	}
	582
	583	/**
	584	* 转换为boolean<br>
	585	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	586	* 转换失败不会报错
	587	*
	588	* @param value 被转换的值
	589	* @return 结果
	590	*/
	591	public static Boolean toBool(Object value)
	592	{
	593	return toBool(value, null);
	594	}
	595
	596	/**
	597	* 转换为Enum对象<br>
	598	* 如果给定的值为空，或者转换失败，返回默认值<br>
	599	*
	600	* @param clazz Enum的Class
	601	* @param value 值
	602	* @param defaultValue 默认值
	603	* @return Enum
	604	*/
	605	public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
	606	{
	607	if (value == null)
	608	{
	609	return defaultValue;
	610	}
	611	if (clazz.isAssignableFrom(value.getClass()))
	612	{
	613	@SuppressWarnings("unchecked")
	614	E myE = (E) value;
	615	return myE;
	616	}
	617	final String valueStr = toStr(value, null);
	618	if (StringUtils.isEmpty(valueStr))
	619	{
	620	return defaultValue;
	621	}
	622	try
	623	{
	624	return Enum.valueOf(clazz, valueStr);
	625	}
	626	catch (Exception e)
	627	{
	628	return defaultValue;
	629	}
	630	}
	631
	632	/**
	633	* 转换为Enum对象<br>
	634	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	635	*
	636	* @param clazz Enum的Class
	637	* @param value 值
	638	* @return Enum
	639	*/
	640	public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
	641	{
	642	return toEnum(clazz, value, null);
	643	}
	644
	645	/**
	646	* 转换为BigInteger<br>
	647	* 如果给定的值为空，或者转换失败，返回默认值<br>
	648	* 转换失败不会报错
	649	*
	650	* @param value 被转换的值
	651	* @param defaultValue 转换错误时的默认值
	652	* @return 结果
	653	*/
	654	public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
	655	{
	656	if (value == null)
	657	{
	658	return defaultValue;
	659	}
	660	if (value instanceof BigInteger)
	661	{
	662	return (BigInteger) value;
	663	}
	664	if (value instanceof Long)
	665	{
	666	return BigInteger.valueOf((Long) value);
	667	}
	668	final String valueStr = toStr(value, null);
	669	if (StringUtils.isEmpty(valueStr))
	670	{
	671	return defaultValue;
	672	}
	673	try
	674	{
	675	return new BigInteger(valueStr);
	676	}
	677	catch (Exception e)
	678	{
	679	return defaultValue;
	680	}
	681	}
	682
	683	/**
	684	* 转换为BigInteger<br>
	685	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	686	* 转换失败不会报错
	687	*
	688	* @param value 被转换的值
	689	* @return 结果
	690	*/
	691	public static BigInteger toBigInteger(Object value)
	692	{
	693	return toBigInteger(value, null);
	694	}
	695
	696	/**
	697	* 转换为BigDecimal<br>
	698	* 如果给定的值为空，或者转换失败，返回默认值<br>
	699	* 转换失败不会报错
	700	*
	701	* @param value 被转换的值
	702	* @param defaultValue 转换错误时的默认值
	703	* @return 结果
	704	*/
	705	public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
	706	{
	707	if (value == null)
	708	{
	709	return defaultValue;
	710	}
	711	if (value instanceof BigDecimal)
	712	{
	713	return (BigDecimal) value;
	714	}
	715	if (value instanceof Long)
	716	{
	717	return new BigDecimal((Long) value);
	718	}
	719	if (value instanceof Double)
	720	{
	721	return BigDecimal.valueOf((Double) value);
	722	}
	723	if (value instanceof Integer)
	724	{
	725	return new BigDecimal((Integer) value);
	726	}
	727	final String valueStr = toStr(value, null);
	728	if (StringUtils.isEmpty(valueStr))
	729	{
	730	return defaultValue;
	731	}
	732	try
	733	{
	734	return new BigDecimal(valueStr);
	735	}
	736	catch (Exception e)
	737	{
	738	return defaultValue;
	739	}
	740	}
	741
	742	/**
	743	* 转换为BigDecimal<br>
	744	* 如果给定的值为空，或者转换失败，返回默认值<br>
	745	* 转换失败不会报错
	746	*
	747	* @param value 被转换的值
	748	* @return 结果
	749	*/
	750	public static BigDecimal toBigDecimal(Object value)
	751	{
	752	return toBigDecimal(value, null);
	753	}
	754
	755	/**
	756	* 将对象转为字符串<br>
	757	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	758	*
	759	* @param obj 对象
	760	* @return 字符串
	761	*/
	762	public static String utf8Str(Object obj)
	763	{
	764	return str(obj, CharsetKit.CHARSET_UTF_8);
	765	}
	766
	767	/**
	768	* 将对象转为字符串<br>
	769	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	770	*
	771	* @param obj 对象
	772	* @param charsetName 字符集
	773	* @return 字符串
	774	*/
	775	public static String str(Object obj, String charsetName)
	776	{
	777	return str(obj, Charset.forName(charsetName));
	778	}
	779
	780	/**
	781	* 将对象转为字符串<br>
	782	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	783	*
	784	* @param obj 对象
	785	* @param charset 字符集
	786	* @return 字符串
	787	*/
	788	public static String str(Object obj, Charset charset)
	789	{
	790	if (null == obj)
	791	{
	792	return null;
	793	}
	794
	795	if (obj instanceof String)
	796	{
	797	return (String) obj;
	798	}
	799	else if (obj instanceof byte[])
	800	{
	801	return str((byte[]) obj, charset);
	802	}
	803	else if (obj instanceof Byte[])
	804	{
	805	byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
	806	return str(bytes, charset);
	807	}
	808	else if (obj instanceof ByteBuffer)
	809	{
	810	return str((ByteBuffer) obj, charset);
	811	}
	812	return obj.toString();
	813	}
	814
	815	/**
	816	* 将byte数组转为字符串
	817	*
	818	* @param bytes byte数组
	819	* @param charset 字符集
	820	* @return 字符串
	821	*/
	822	public static String str(byte[] bytes, String charset)
	823	{
	824	return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
	825	}
	826
	827	/**
	828	* 解码字节码
	829	*
	830	* @param data 字符串
	831	* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
	832	* @return 解码后的字符串
	833	*/
	834	public static String str(byte[] data, Charset charset)
	835	{
	836	if (data == null)
	837	{
	838	return null;
	839	}
	840
	841	if (null == charset)
	842	{
	843	return new String(data);
	844	}
	845	return new String(data, charset);
	846	}
	847
	848	/**
	849	* 将编码的byteBuffer数据转换为字符串
	850	*
	851	* @param data 数据
	852	* @param charset 字符集，如果为空使用当前系统字符集
	853	* @return 字符串
	854	*/
	855	public static String str(ByteBuffer data, String charset)
	856	{
	857	if (data == null)
	858	{
	859	return null;
	860	}
	861
	862	return str(data, Charset.forName(charset));
	863	}
	864
	865	/**
	866	* 将编码的byteBuffer数据转换为字符串
	867	*
	868	* @param data 数据
	869	* @param charset 字符集，如果为空使用当前系统字符集
	870	* @return 字符串
	871	*/
	872	public static String str(ByteBuffer data, Charset charset)
	873	{
	874	if (null == charset)
	875	{
	876	charset = Charset.defaultCharset();
	877	}
	878	return charset.decode(data).toString();
	879	}
	880
	881	// ----------------------------------------------------------------------- 全角半角转换
	882	/**
	883	* 半角转全角
	884	*
	885	* @param input String.
	886	* @return 全角字符串.
	887	*/
	888	public static String toSBC(String input)
	889	{
	890	return toSBC(input, null);
	891	}
	892
	893	/**
	894	* 半角转全角
	895	*
	896	* @param input String
	897	* @param notConvertSet 不替换的字符集合
	898	* @return 全角字符串.
	899	*/
	900	public static String toSBC(String input, Set<Character> notConvertSet)
	901	{
	902	char[] c = input.toCharArray();
	903	for (int i = 0; i < c.length; i++)
	904	{
	905	if (null != notConvertSet && notConvertSet.contains(c[i]))
	906	{
	907	// 跳过不替换的字符
	908	continue;
	909	}
	910
	911	if (c[i] == ' ')
	912	{
	913	c[i] = '\u3000';
	914	}
	915	else if (c[i] < '\177')
	916	{
	917	c[i] = (char) (c[i] + 65248);
	918
	919	}
	920	}
	921	return new String(c);
	922	}
	923
	924	/**
	925	* 全角转半角
	926	*
	927	* @param input String.
	928	* @return 半角字符串
	929	*/
	930	public static String toDBC(String input)
	931	{
	932	return toDBC(input, null);
	933	}
	934
	935	/**
	936	* 替换全角为半角
	937	*
	938	* @param text 文本
	939	* @param notConvertSet 不替换的字符集合
	940	* @return 替换后的字符
	941	*/
	942	public static String toDBC(String text, Set<Character> notConvertSet)
	943	{
	944	char[] c = text.toCharArray();
	945	for (int i = 0; i < c.length; i++)
	946	{
	947	if (null != notConvertSet && notConvertSet.contains(c[i]))
	948	{
	949	// 跳过不替换的字符
	950	continue;
	951	}
	952
	953	if (c[i] == '\u3000')
	954	{
	955	c[i] = ' ';
	956	}
	957	else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
	958	{
	959	c[i] = (char) (c[i] - 65248);
	960	}
	961	}
	962	String returnString = new String(c);
	963
	964	return returnString;
	965	}
	966
	967	/**
	968	* 数字金额大写转换先写个完整的然后将如零拾替换成零
	969	*
	970	* @param n 数字
	971	* @return 中文大写数字
	972	*/
	973	public static String digitUppercase(double n)
	974	{
	975	String[] fraction = { "角", "分" };
	976	String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
	977	String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
	978
	979	String head = n < 0 ? "负" : "";
	980	n = Math.abs(n);
	981
	982	String s = "";
	983	for (int i = 0; i < fraction.length; i++)
	984	{
	985	// 优化double计算精度丢失问题
	986	BigDecimal nNum = new BigDecimal(n);
	987	BigDecimal decimal = new BigDecimal(10);
	988	BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);
	989	double d = scale.doubleValue();
	990	s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
	991	}
	992	if (s.length() < 1)
	993	{
	994	s = "整";
	995	}
	996	int integerPart = (int) Math.floor(n);
	997
	998	for (int i = 0; i < unit[0].length && integerPart > 0; i++)
	999	{
	1000	String p = "";
	1001	for (int j = 0; j < unit[1].length && n > 0; j++)
	1002	{
	1003	p = digit[integerPart % 10] + unit[1][j] + p;
	1004	integerPart = integerPart / 10;
	1005	}
	1006	s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
	1007	}
	1008	return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
	1009	}
	1010	}