Jcdm041-Mes.git

懒羊羊

2024-01-16 a6711108edecbb4893bf29fe77e00e33aa1a9e1f

提交 \| 用户 \| 时间
fd2207	1	package com.jcdm.common.core.text;
懒	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.jcdm.common.utils.StringUtils;
	11	import org.apache.commons.lang3.ArrayUtils;
	12
	13	/**
	14	* 类型转换器
	15	*
	16	* @author jc
	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	return toStrArray(",", str);
	369	}
	370
	371	/**
	372	* 转换为String数组<br>
	373	*
	374	* @param split 分隔符
	375	* @param split 被转换的值
	376	* @return 结果
	377	*/
	378	public static String[] toStrArray(String split, String str)
	379	{
	380	return str.split(split);
	381	}
	382
	383	/**
	384	* 转换为long<br>
	385	* 如果给定的值为空，或者转换失败，返回默认值<br>
	386	* 转换失败不会报错
	387	*
	388	* @param value 被转换的值
	389	* @param defaultValue 转换错误时的默认值
	390	* @return 结果
	391	*/
	392	public static Long toLong(Object value, Long defaultValue)
	393	{
	394	if (value == null)
	395	{
	396	return defaultValue;
	397	}
	398	if (value instanceof Long)
	399	{
	400	return (Long) value;
	401	}
	402	if (value instanceof Number)
	403	{
	404	return ((Number) value).longValue();
	405	}
	406	final String valueStr = toStr(value, null);
	407	if (StringUtils.isEmpty(valueStr))
	408	{
	409	return defaultValue;
	410	}
	411	try
	412	{
	413	// 支持科学计数法
	414	return new BigDecimal(valueStr.trim()).longValue();
	415	}
	416	catch (Exception e)
	417	{
	418	return defaultValue;
	419	}
	420	}
	421
	422	/**
	423	* 转换为long<br>
	424	* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
	425	* 转换失败不会报错
	426	*
	427	* @param value 被转换的值
	428	* @return 结果
	429	*/
	430	public static Long toLong(Object value)
	431	{
	432	return toLong(value, null);
	433	}
	434
	435	/**
	436	* 转换为double<br>
	437	* 如果给定的值为空，或者转换失败，返回默认值<br>
	438	* 转换失败不会报错
	439	*
	440	* @param value 被转换的值
	441	* @param defaultValue 转换错误时的默认值
	442	* @return 结果
	443	*/
	444	public static Double toDouble(Object value, Double defaultValue)
	445	{
	446	if (value == null)
	447	{
	448	return defaultValue;
	449	}
	450	if (value instanceof Double)
	451	{
	452	return (Double) value;
	453	}
	454	if (value instanceof Number)
	455	{
	456	return ((Number) value).doubleValue();
	457	}
	458	final String valueStr = toStr(value, null);
	459	if (StringUtils.isEmpty(valueStr))
	460	{
	461	return defaultValue;
	462	}
	463	try
	464	{
	465	// 支持科学计数法
	466	return new BigDecimal(valueStr.trim()).doubleValue();
	467	}
	468	catch (Exception e)
	469	{
	470	return defaultValue;
	471	}
	472	}
	473
	474	/**
	475	* 转换为double<br>
	476	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	477	* 转换失败不会报错
	478	*
	479	* @param value 被转换的值
	480	* @return 结果
	481	*/
	482	public static Double toDouble(Object value)
	483	{
	484	return toDouble(value, null);
	485	}
	486
	487	/**
	488	* 转换为Float<br>
	489	* 如果给定的值为空，或者转换失败，返回默认值<br>
	490	* 转换失败不会报错
	491	*
	492	* @param value 被转换的值
	493	* @param defaultValue 转换错误时的默认值
	494	* @return 结果
	495	*/
	496	public static Float toFloat(Object value, Float defaultValue)
	497	{
	498	if (value == null)
	499	{
	500	return defaultValue;
	501	}
	502	if (value instanceof Float)
	503	{
	504	return (Float) value;
	505	}
	506	if (value instanceof Number)
	507	{
	508	return ((Number) value).floatValue();
	509	}
	510	final String valueStr = toStr(value, null);
	511	if (StringUtils.isEmpty(valueStr))
	512	{
	513	return defaultValue;
	514	}
	515	try
	516	{
	517	return Float.parseFloat(valueStr.trim());
	518	}
	519	catch (Exception e)
	520	{
	521	return defaultValue;
	522	}
	523	}
	524
	525	/**
	526	* 转换为Float<br>
	527	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	528	* 转换失败不会报错
	529	*
	530	* @param value 被转换的值
	531	* @return 结果
	532	*/
	533	public static Float toFloat(Object value)
	534	{
	535	return toFloat(value, null);
	536	}
	537
	538	/**
	539	* 转换为boolean<br>
	540	* String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
	541	* 转换失败不会报错
	542	*
	543	* @param value 被转换的值
	544	* @param defaultValue 转换错误时的默认值
	545	* @return 结果
	546	*/
	547	public static Boolean toBool(Object value, Boolean defaultValue)
	548	{
	549	if (value == null)
	550	{
	551	return defaultValue;
	552	}
	553	if (value instanceof Boolean)
	554	{
	555	return (Boolean) value;
	556	}
	557	String valueStr = toStr(value, null);
	558	if (StringUtils.isEmpty(valueStr))
	559	{
	560	return defaultValue;
	561	}
	562	valueStr = valueStr.trim().toLowerCase();
	563	switch (valueStr)
	564	{
	565	case "true":
	566	case "yes":
	567	case "ok":
	568	case "1":
	569	return true;
	570	case "false":
	571	case "no":
	572	case "0":
	573	return false;
	574	default:
	575	return defaultValue;
	576	}
	577	}
	578
	579	/**
	580	* 转换为boolean<br>
	581	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	582	* 转换失败不会报错
	583	*
	584	* @param value 被转换的值
	585	* @return 结果
	586	*/
	587	public static Boolean toBool(Object value)
	588	{
	589	return toBool(value, null);
	590	}
	591
	592	/**
	593	* 转换为Enum对象<br>
	594	* 如果给定的值为空，或者转换失败，返回默认值<br>
	595	*
	596	* @param clazz Enum的Class
	597	* @param value 值
	598	* @param defaultValue 默认值
	599	* @return Enum
	600	*/
	601	public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
	602	{
	603	if (value == null)
	604	{
	605	return defaultValue;
	606	}
	607	if (clazz.isAssignableFrom(value.getClass()))
	608	{
	609	@SuppressWarnings("unchecked")
	610	E myE = (E) value;
	611	return myE;
	612	}
	613	final String valueStr = toStr(value, null);
	614	if (StringUtils.isEmpty(valueStr))
	615	{
	616	return defaultValue;
	617	}
	618	try
	619	{
	620	return Enum.valueOf(clazz, valueStr);
	621	}
	622	catch (Exception e)
	623	{
	624	return defaultValue;
	625	}
	626	}
	627
	628	/**
	629	* 转换为Enum对象<br>
	630	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	631	*
	632	* @param clazz Enum的Class
	633	* @param value 值
	634	* @return Enum
	635	*/
	636	public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
	637	{
	638	return toEnum(clazz, value, null);
	639	}
	640
	641	/**
	642	* 转换为BigInteger<br>
	643	* 如果给定的值为空，或者转换失败，返回默认值<br>
	644	* 转换失败不会报错
	645	*
	646	* @param value 被转换的值
	647	* @param defaultValue 转换错误时的默认值
	648	* @return 结果
	649	*/
	650	public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
	651	{
	652	if (value == null)
	653	{
	654	return defaultValue;
	655	}
	656	if (value instanceof BigInteger)
	657	{
	658	return (BigInteger) value;
	659	}
	660	if (value instanceof Long)
	661	{
	662	return BigInteger.valueOf((Long) value);
	663	}
	664	final String valueStr = toStr(value, null);
	665	if (StringUtils.isEmpty(valueStr))
	666	{
	667	return defaultValue;
	668	}
	669	try
	670	{
	671	return new BigInteger(valueStr);
	672	}
	673	catch (Exception e)
	674	{
	675	return defaultValue;
	676	}
	677	}
	678
	679	/**
	680	* 转换为BigInteger<br>
	681	* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
	682	* 转换失败不会报错
	683	*
	684	* @param value 被转换的值
	685	* @return 结果
	686	*/
	687	public static BigInteger toBigInteger(Object value)
	688	{
	689	return toBigInteger(value, null);
	690	}
	691
	692	/**
	693	* 转换为BigDecimal<br>
	694	* 如果给定的值为空，或者转换失败，返回默认值<br>
	695	* 转换失败不会报错
	696	*
	697	* @param value 被转换的值
	698	* @param defaultValue 转换错误时的默认值
	699	* @return 结果
	700	*/
	701	public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
	702	{
	703	if (value == null)
	704	{
	705	return defaultValue;
	706	}
	707	if (value instanceof BigDecimal)
	708	{
	709	return (BigDecimal) value;
	710	}
	711	if (value instanceof Long)
	712	{
	713	return new BigDecimal((Long) value);
	714	}
	715	if (value instanceof Double)
	716	{
	717	return BigDecimal.valueOf((Double) value);
	718	}
	719	if (value instanceof Integer)
	720	{
	721	return new BigDecimal((Integer) value);
	722	}
	723	final String valueStr = toStr(value, null);
	724	if (StringUtils.isEmpty(valueStr))
	725	{
	726	return defaultValue;
	727	}
	728	try
	729	{
	730	return new BigDecimal(valueStr);
	731	}
	732	catch (Exception e)
	733	{
	734	return defaultValue;
	735	}
	736	}
	737
	738	/**
	739	* 转换为BigDecimal<br>
	740	* 如果给定的值为空，或者转换失败，返回默认值<br>
	741	* 转换失败不会报错
	742	*
	743	* @param value 被转换的值
	744	* @return 结果
	745	*/
	746	public static BigDecimal toBigDecimal(Object value)
	747	{
	748	return toBigDecimal(value, null);
	749	}
	750
	751	/**
	752	* 将对象转为字符串<br>
	753	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	754	*
	755	* @param obj 对象
	756	* @return 字符串
	757	*/
	758	public static String utf8Str(Object obj)
	759	{
	760	return str(obj, CharsetKit.CHARSET_UTF_8);
	761	}
	762
	763	/**
	764	* 将对象转为字符串<br>
	765	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	766	*
	767	* @param obj 对象
	768	* @param charsetName 字符集
	769	* @return 字符串
	770	*/
	771	public static String str(Object obj, String charsetName)
	772	{
	773	return str(obj, Charset.forName(charsetName));
	774	}
	775
	776	/**
	777	* 将对象转为字符串<br>
	778	* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
	779	*
	780	* @param obj 对象
	781	* @param charset 字符集
	782	* @return 字符串
	783	*/
	784	public static String str(Object obj, Charset charset)
	785	{
	786	if (null == obj)
	787	{
	788	return null;
	789	}
	790
	791	if (obj instanceof String)
	792	{
	793	return (String) obj;
	794	}
	795	else if (obj instanceof byte[])
	796	{
	797	return str((byte[]) obj, charset);
	798	}
	799	else if (obj instanceof Byte[])
	800	{
	801	byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
	802	return str(bytes, charset);
	803	}
	804	else if (obj instanceof ByteBuffer)
	805	{
	806	return str((ByteBuffer) obj, charset);
	807	}
	808	return obj.toString();
	809	}
	810
	811	/**
	812	* 将byte数组转为字符串
	813	*
	814	* @param bytes byte数组
	815	* @param charset 字符集
	816	* @return 字符串
	817	*/
	818	public static String str(byte[] bytes, String charset)
	819	{
	820	return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
	821	}
	822
	823	/**
	824	* 解码字节码
	825	*
	826	* @param data 字符串
	827	* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
	828	* @return 解码后的字符串
	829	*/
	830	public static String str(byte[] data, Charset charset)
	831	{
	832	if (data == null)
	833	{
	834	return null;
	835	}
	836
	837	if (null == charset)
	838	{
	839	return new String(data);
	840	}
	841	return new String(data, charset);
	842	}
	843
	844	/**
	845	* 将编码的byteBuffer数据转换为字符串
	846	*
	847	* @param data 数据
	848	* @param charset 字符集，如果为空使用当前系统字符集
	849	* @return 字符串
	850	*/
	851	public static String str(ByteBuffer data, String charset)
	852	{
	853	if (data == null)
	854	{
	855	return null;
	856	}
	857
	858	return str(data, Charset.forName(charset));
	859	}
	860
	861	/**
	862	* 将编码的byteBuffer数据转换为字符串
	863	*
	864	* @param data 数据
	865	* @param charset 字符集，如果为空使用当前系统字符集
	866	* @return 字符串
	867	*/
	868	public static String str(ByteBuffer data, Charset charset)
	869	{
	870	if (null == charset)
	871	{
	872	charset = Charset.defaultCharset();
	873	}
	874	return charset.decode(data).toString();
	875	}
	876
	877	// ----------------------------------------------------------------------- 全角半角转换
	878	/**
	879	* 半角转全角
	880	*
	881	* @param input String.
	882	* @return 全角字符串.
	883	*/
	884	public static String toSBC(String input)
	885	{
	886	return toSBC(input, null);
	887	}
	888
	889	/**
	890	* 半角转全角
	891	*
	892	* @param input String
	893	* @param notConvertSet 不替换的字符集合
	894	* @return 全角字符串.
	895	*/
	896	public static String toSBC(String input, Set<Character> notConvertSet)
	897	{
	898	char[] c = input.toCharArray();
	899	for (int i = 0; i < c.length; i++)
	900	{
	901	if (null != notConvertSet && notConvertSet.contains(c[i]))
	902	{
	903	// 跳过不替换的字符
	904	continue;
	905	}
	906
	907	if (c[i] == ' ')
	908	{
	909	c[i] = '\u3000';
	910	}
	911	else if (c[i] < '\177')
	912	{
	913	c[i] = (char) (c[i] + 65248);
	914
	915	}
	916	}
	917	return new String(c);
	918	}
	919
	920	/**
	921	* 全角转半角
	922	*
	923	* @param input String.
	924	* @return 半角字符串
	925	*/
	926	public static String toDBC(String input)
	927	{
	928	return toDBC(input, null);
	929	}
	930
	931	/**
	932	* 替换全角为半角
	933	*
	934	* @param text 文本
	935	* @param notConvertSet 不替换的字符集合
	936	* @return 替换后的字符
	937	*/
	938	public static String toDBC(String text, Set<Character> notConvertSet)
	939	{
	940	char[] c = text.toCharArray();
	941	for (int i = 0; i < c.length; i++)
	942	{
	943	if (null != notConvertSet && notConvertSet.contains(c[i]))
	944	{
	945	// 跳过不替换的字符
	946	continue;
	947	}
	948
	949	if (c[i] == '\u3000')
	950	{
	951	c[i] = ' ';
	952	}
	953	else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
	954	{
	955	c[i] = (char) (c[i] - 65248);
	956	}
	957	}
	958	String returnString = new String(c);
	959
	960	return returnString;
	961	}
	962
	963	/**
	964	* 数字金额大写转换先写个完整的然后将如零拾替换成零
	965	*
	966	* @param n 数字
	967	* @return 中文大写数字
	968	*/
	969	public static String digitUppercase(double n)
	970	{
	971	String[] fraction = { "角", "分" };
	972	String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
	973	String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
	974
	975	String head = n < 0 ? "负" : "";
	976	n = Math.abs(n);
	977
	978	String s = "";
	979	for (int i = 0; i < fraction.length; i++)
	980	{
	981	// 优化double计算精度丢失问题
	982	BigDecimal nNum = new BigDecimal(n);
	983	BigDecimal decimal = new BigDecimal(10);
	984	BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);
	985	double d = scale.doubleValue();
	986	s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
	987	}
	988	if (s.length() < 1)
	989	{
	990	s = "整";
	991	}
	992	int integerPart = (int) Math.floor(n);
	993
	994	for (int i = 0; i < unit[0].length && integerPart > 0; i++)
	995	{
	996	String p = "";
	997	for (int j = 0; j < unit[1].length && n > 0; j++)
	998	{
	999	p = digit[integerPart % 10] + unit[1][j] + p;
	1000	integerPart = integerPart / 10;
	1001	}
	1002	s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
	1003	}
	1004	return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
	1005	}
	1006	}