BJ_ZTEITS-Developers / parking-cloud-yudao

Commit 1590e1068c364d3c614f48e8d9f2ed64d93699e9

Authored by RuoYi
1 parent 103583a8

删除多余包

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