春风项目四线(合箱线、总装线)
查看 | 历史 | 提交 | 提交对比
懒羊羊
2024-01-16 f1d9df303a33ef98066e4bf044b1114e1f3f629d
提交 | 用户 | 时间
fd2207 1 package com.jcdm.common.utils;
懒 2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.HashSet;
6 import java.util.List;
7 import java.util.Map;
8 import java.util.Set;
9 import org.springframework.util.AntPathMatcher;
10 import com.jcdm.common.constant.Constants;
11 import com.jcdm.common.core.text.StrFormatter;
12
13 /**
14  * 字符串工具类
15  * 
16  * @author jc
17  */
18 public class StringUtils extends org.apache.commons.lang3.StringUtils
19 {
20     /** 空字符串 */
21     private static final String NULLSTR = "";
22
23     /** 下划线 */
24     private static final char SEPARATOR = '_';
25
26     /**
27      * 获取参数不为空值
28      * 
29      * @param value defaultValue 要判断的value
30      * @return value 返回值
31      */
32     public static <T> T nvl(T value, T defaultValue)
33     {
34         return value != null ? value : defaultValue;
35     }
36
37     /**
38      * * 判断一个Collection是否为空， 包含List，Set，Queue
39      * 
40      * @param coll 要判断的Collection
41      * @return true：为空 false：非空
42      */
43     public static boolean isEmpty(Collection<?> coll)
44     {
45         return isNull(coll) || coll.isEmpty();
46     }
47
48     /**
49      * * 判断一个Collection是否非空，包含List，Set，Queue
50      * 
51      * @param coll 要判断的Collection
52      * @return true：非空 false：空
53      */
54     public static boolean isNotEmpty(Collection<?> coll)
55     {
56         return !isEmpty(coll);
57     }
58
59     /**
60      * * 判断一个对象数组是否为空
61      * 
62      * @param objects 要判断的对象数组
63      ** @return true：为空 false：非空
64      */
65     public static boolean isEmpty(Object[] objects)
66     {
67         return isNull(objects) || (objects.length == 0);
68     }
69
70     /**
71      * * 判断一个对象数组是否非空
72      * 
73      * @param objects 要判断的对象数组
74      * @return true：非空 false：空
75      */
76     public static boolean isNotEmpty(Object[] objects)
77     {
78         return !isEmpty(objects);
79     }
80
81     /**
82      * * 判断一个Map是否为空
83      * 
84      * @param map 要判断的Map
85      * @return true：为空 false：非空
86      */
87     public static boolean isEmpty(Map<?, ?> map)
88     {
89         return isNull(map) || map.isEmpty();
90     }
91
92     /**
93      * * 判断一个Map是否为空
94      * 
95      * @param map 要判断的Map
96      * @return true：非空 false：空
97      */
98     public static boolean isNotEmpty(Map<?, ?> map)
99     {
100         return !isEmpty(map);
101     }
102
103     /**
104      * * 判断一个字符串是否为空串
105      * 
106      * @param str String
107      * @return true：为空 false：非空
108      */
109     public static boolean isEmpty(String str)
110     {
111         return isNull(str) || NULLSTR.equals(str.trim());
112     }
113
114     /**
115      * * 判断一个字符串是否为非空串
116      * 
117      * @param str String
118      * @return true：非空串 false：空串
119      */
120     public static boolean isNotEmpty(String str)
121     {
122         return !isEmpty(str);
123     }
124
125     /**
126      * * 判断一个对象是否为空
127      * 
128      * @param object Object
129      * @return true：为空 false：非空
130      */
131     public static boolean isNull(Object object)
132     {
133         return object == null;
134     }
135
136     /**
137      * * 判断一个对象是否非空
138      * 
139      * @param object Object
140      * @return true：非空 false：空
141      */
142     public static boolean isNotNull(Object object)
143     {
144         return !isNull(object);
145     }
146
147     /**
148      * * 判断一个对象是否是数组类型（Java基本型别的数组）
149      * 
150      * @param object 对象
151      * @return true：是数组 false：不是数组
152      */
153     public static boolean isArray(Object object)
154     {
155         return isNotNull(object) && object.getClass().isArray();
156     }
157
158     /**
159      * 去空格
160      */
161     public static String trim(String str)
162     {
163         return (str == null ? "" : str.trim());
164     }
165
166     /**
167      * 截取字符串
168      * 
169      * @param str 字符串
170      * @param start 开始
171      * @return 结果
172      */
173     public static String substring(final String str, int start)
174     {
175         if (str == null)
176         {
177             return NULLSTR;
178         }
179
180         if (start < 0)
181         {
182             start = str.length() + start;
183         }
184
185         if (start < 0)
186         {
187             start = 0;
188         }
189         if (start > str.length())
190         {
191             return NULLSTR;
192         }
193
194         return str.substring(start);
195     }
196
197     /**
198      * 截取字符串
199      * 
200      * @param str 字符串
201      * @param start 开始
202      * @param end 结束
203      * @return 结果
204      */
205     public static String substring(final String str, int start, int end)
206     {
207         if (str == null)
208         {
209             return NULLSTR;
210         }
211
212         if (end < 0)
213         {
214             end = str.length() + end;
215         }
216         if (start < 0)
217         {
218             start = str.length() + start;
219         }
220
221         if (end > str.length())
222         {
223             end = str.length();
224         }
225
226         if (start > end)
227         {
228             return NULLSTR;
229         }
230
231         if (start < 0)
232         {
233             start = 0;
234         }
235         if (end < 0)
236         {
237             end = 0;
238         }
239
240         return str.substring(start, end);
241     }
242
243     /**
244      * 判断是否为空，并且不是空白字符
245      * 
246      * @param str 要判断的value
247      * @return 结果
248      */
249     public static boolean hasText(String str)
250     {
251         return (str != null && !str.isEmpty() && containsText(str));
252     }
253
254     private static boolean containsText(CharSequence str)
255     {
256         int strLen = str.length();
257         for (int i = 0; i < strLen; i++)
258         {
259             if (!Character.isWhitespace(str.charAt(i)))
260             {
261                 return true;
262             }
263         }
264         return false;
265     }
266
267     /**
268      * 格式化文本, {} 表示占位符<br>
269      * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
270      * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
271      * 例：<br>
272      * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
273      * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
274      * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
275      * 
276      * @param template 文本模板，被替换的部分用 {} 表示
277      * @param params 参数值
278      * @return 格式化后的文本
279      */
280     public static String format(String template, Object... params)
281     {
282         if (isEmpty(params) || isEmpty(template))
283         {
284             return template;
285         }
286         return StrFormatter.format(template, params);
287     }
288
289     /**
290      * 是否为http(s)://开头
291      * 
292      * @param link 链接
293      * @return 结果
294      */
295     public static boolean ishttp(String link)
296     {
297         return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
298     }
299
300     /**
301      * 字符串转set
302      * 
303      * @param str 字符串
304      * @param sep 分隔符
305      * @return set集合
306      */
307     public static final Set<String> str2Set(String str, String sep)
308     {
309         return new HashSet<String>(str2List(str, sep, true, false));
310     }
311
312     /**
313      * 字符串转list
314      * 
315      * @param str 字符串
316      * @param sep 分隔符
317      * @param filterBlank 过滤纯空白
318      * @param trim 去掉首尾空白
319      * @return list集合
320      */
321     public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
322     {
323         List<String> list = new ArrayList<String>();
324         if (StringUtils.isEmpty(str))
325         {
326             return list;
327         }
328
329         // 过滤空白字符串
330         if (filterBlank && StringUtils.isBlank(str))
331         {
332             return list;
333         }
334         String[] split = str.split(sep);
335         for (String string : split)
336         {
337             if (filterBlank && StringUtils.isBlank(string))
338             {
339                 continue;
340             }
341             if (trim)
342             {
343                 string = string.trim();
344             }
345             list.add(string);
346         }
347
348         return list;
349     }
350
351     /**
352      * 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
353      *
354      * @param collection 给定的集合
355      * @param array 给定的数组
356      * @return boolean 结果
357      */
358     public static boolean containsAny(Collection<String> collection, String... array)
359     {
360         if (isEmpty(collection) || isEmpty(array))
361         {
362             return false;
363         }
364         else
365         {
366             for (String str : array)
367             {
368                 if (collection.contains(str))
369                 {
370                     return true;
371                 }
372             }
373             return false;
374         }
375     }
376
377     /**
378      * 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
379      *
380      * @param cs 指定字符串
381      * @param searchCharSequences 需要检查的字符串数组
382      * @return 是否包含任意一个字符串
383      */
384     public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences)
385     {
386         if (isEmpty(cs) || isEmpty(searchCharSequences))
387         {
388             return false;
389         }
390         for (CharSequence testStr : searchCharSequences)
391         {
392             if (containsIgnoreCase(cs, testStr))
393             {
394                 return true;
395             }
396         }
397         return false;
398     }
399
400     /**
401      * 驼峰转下划线命名
402      */
403     public static String toUnderScoreCase(String str)
404     {
405         if (str == null)
406         {
407             return null;
408         }
409         StringBuilder sb = new StringBuilder();
410         // 前置字符是否大写
411         boolean preCharIsUpperCase = true;
412         // 当前字符是否大写
413         boolean curreCharIsUpperCase = true;
414         // 下一字符是否大写
415         boolean nexteCharIsUpperCase = true;
416         for (int i = 0; i < str.length(); i++)
417         {
418             char c = str.charAt(i);
419             if (i > 0)
420             {
421                 preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
422             }
423             else
424             {
425                 preCharIsUpperCase = false;
426             }
427
428             curreCharIsUpperCase = Character.isUpperCase(c);
429
430             if (i < (str.length() - 1))
431             {
432                 nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
433             }
434
435             if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
436             {
437                 sb.append(SEPARATOR);
438             }
439             else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
440             {
441                 sb.append(SEPARATOR);
442             }
443             sb.append(Character.toLowerCase(c));
444         }
445
446         return sb.toString();
447     }
448
449     /**
450      * 是否包含字符串
451      * 
452      * @param str 验证字符串
453      * @param strs 字符串组
454      * @return 包含返回true
455      */
456     public static boolean inStringIgnoreCase(String str, String... strs)
457     {
458         if (str != null && strs != null)
459         {
460             for (String s : strs)
461             {
462                 if (str.equalsIgnoreCase(trim(s)))
463                 {
464                     return true;
465                 }
466             }
467         }
468         return false;
469     }
470
471     /**
472      * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
473      * 
474      * @param name 转换前的下划线大写方式命名的字符串
475      * @return 转换后的驼峰式命名的字符串
476      */
477     public static String convertToCamelCase(String name)
478     {
479         StringBuilder result = new StringBuilder();
480         // 快速检查
481         if (name == null || name.isEmpty())
482         {
483             // 没必要转换
484             return "";
485         }
486         else if (!name.contains("_"))
487         {
488             // 不含下划线，仅将首字母大写
489             return name.substring(0, 1).toUpperCase() + name.substring(1);
490         }
491         // 用下划线将原始字符串分割
492         String[] camels = name.split("_");
493         for (String camel : camels)
494         {
495             // 跳过原始字符串中开头、结尾的下换线或双重下划线
496             if (camel.isEmpty())
497             {
498                 continue;
499             }
500             // 首字母大写
501             result.append(camel.substring(0, 1).toUpperCase());
502             result.append(camel.substring(1).toLowerCase());
503         }
504         return result.toString();
505     }
506
507     /**
508      * 驼峰式命名法
509      * 例如：user_name->userName
510      */
511     public static String toCamelCase(String s)
512     {
513         if (s == null)
514         {
515             return null;
516         }
517         if (s.indexOf(SEPARATOR) == -1)
518         {
519             return s;
520         }
521         s = s.toLowerCase();
522         StringBuilder sb = new StringBuilder(s.length());
523         boolean upperCase = false;
524         for (int i = 0; i < s.length(); i++)
525         {
526             char c = s.charAt(i);
527
528             if (c == SEPARATOR)
529             {
530                 upperCase = true;
531             }
532             else if (upperCase)
533             {
534                 sb.append(Character.toUpperCase(c));
535                 upperCase = false;
536             }
537             else
538             {
539                 sb.append(c);
540             }
541         }
542         return sb.toString();
543     }
544
545     /**
546      * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
547      * 
548      * @param str 指定字符串
549      * @param strs 需要检查的字符串数组
550      * @return 是否匹配
551      */
552     public static boolean matches(String str, List<String> strs)
553     {
554         if (isEmpty(str) || isEmpty(strs))
555         {
556             return false;
557         }
558         for (String pattern : strs)
559         {
560             if (isMatch(pattern, str))
561             {
562                 return true;
563             }
564         }
565         return false;
566     }
567
568     /**
569      * 判断url是否与规则配置: 
570      * ? 表示单个字符; 
571      * * 表示一层路径内的任意字符串，不可跨层级; 
572      * ** 表示任意层路径;
573      * 
574      * @param pattern 匹配规则
575      * @param url 需要匹配的url
576      * @return
577      */
578     public static boolean isMatch(String pattern, String url)
579     {
580         AntPathMatcher matcher = new AntPathMatcher();
581         return matcher.match(pattern, url);
582     }
583
584     @SuppressWarnings("unchecked")
585     public static <T> T cast(Object obj)
586     {
587         return (T) obj;
588     }
589
590     /**
591      * 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
592      * 
593      * @param num 数字对象
594      * @param size 字符串指定长度
595      * @return 返回数字的字符串格式，该字符串为指定长度。
596      */
597     public static final String padl(final Number num, final int size)
598     {
599         return padl(num.toString(), size, '0');
600     }
601
602     /**
603      * 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
604      * 
605      * @param s 原始字符串
606      * @param size 字符串指定长度
607      * @param c 用于补齐的字符
608      * @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
609      */
610     public static final String padl(final String s, final int size, final char c)
611     {
612         final StringBuilder sb = new StringBuilder(size);
613         if (s != null)
614         {
615             final int len = s.length();
616             if (s.length() <= size)
617             {
618                 for (int i = size - len; i > 0; i--)
619                 {
620                     sb.append(c);
621                 }
622                 sb.append(s);
623             }
624             else
625             {
626                 return s.substring(len - size, len);
627             }
628         }
629         else
630         {
631             for (int i = size; i > 0; i--)
632             {
633                 sb.append(c);
634             }
635         }
636         return sb.toString();
637     }
638 }