chenjiahe
2023-07-17 d4fa5269e214e8bbe1f7dd79a922cefe9fc9916b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
package com.hx.util;
 
import java.io.UnsupportedEncodingException;
import java.text.MessageFormat;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
/**
 * 字符串工具类
 * 
 * @author ThinkGem
 * @version 2013-05-22
 */
public class StringUtils {
 
    private static final char SEPARATOR = '_';
    private static final String CHARSET_NAME = "UTF-8";
 
    /**
     * 格式化字符串,替换原字符串中的{0}, {1},按顺序替换
     * 
     * @param oriStr
     * @param args
     * @return
     */
    public static String format(String oriStr, Object... args) {
        return MessageFormat.format(oriStr, args);
    }
 
    /**
     * 转换为字节数�?
     * 
     * @param str
     * @return
     */
    public static byte[] getBytes(String str) {
        if (str != null) {
            try {
                return str.getBytes(CHARSET_NAME);
            } catch (UnsupportedEncodingException e) {
                return null;
            }
        } else {
            return null;
        }
    }
 
    /**
     * 只取后两�?
     * 
     * @param str
     * @return
     */
    public static String getLastTwoChars(String str) {
        if (null != str && str.trim().length() > 0) {
            str = str.trim();
            int len = str.length();
            if (len == 2) {
                return str;
            } else if (len > 2) {
                return str.substring(len - 2);
            }
        }
        return "";
    }
 
    /**
     * 只取后三�?
     * 
     * @param str
     * @return
     */
    public static String getLastThreeChars(String str) {
        if (null != str && str.trim().length() > 0) {
            str = str.trim();
            int len = str.length();
            if (len == 3) {
                return str;
            } else if (len > 3) {
                return str.substring(len - 3);
            }
        }
        return "";
    }
 
    /**
     * 替换为手机识别的HTML,去掉样式及属�?�,保留回车�?
     * 
     * @param html
     * @return
     */
    public static String replaceMobileHtml(String html) {
        if (html == null) {
            return "";
        }
        return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>");
    }
 
    /**
     * 驼峰命名法工�?
     * 
     * @return toCamelCase("hello_world") == "helloWorld"
     *         toCapitalizeCamelCase("hello_world") == "HelloWorld"
     *         toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }
 
        s = s.toLowerCase();
 
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
 
            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }
 
        return sb.toString();
    }
 
    /**
     * 驼峰命名法工�?
     * 
     * @return toCamelCase("hello_world") == "helloWorld"
     *         toCapitalizeCamelCase("hello_world") == "HelloWorld"
     *         toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toCapitalizeCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = toCamelCase(s);
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }
 
    /**
     * 驼峰命名法工�?
     * 
     * @return toCamelCase("hello_world") == "helloWorld"
     *         toCapitalizeCamelCase("hello_world") == "HelloWorld"
     *         toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toUnderScoreCase(String s) {
        if (s == null) {
            return null;
        }
 
        StringBuilder sb = new StringBuilder();
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
 
            boolean nextUpperCase = true;
 
            if (i < (s.length() - 1)) {
                nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
            }
 
            if ((i > 0) && Character.isUpperCase(c)) {
                if (!upperCase || !nextUpperCase) {
                    sb.append(SEPARATOR);
                }
                upperCase = true;
            } else {
                upperCase = false;
            }
 
            sb.append(Character.toLowerCase(c));
        }
 
        return sb.toString();
    }
 
    /**
     * 根据规则regExpr,判断字符内容是否匹配
     * <p>
     * 利用正则表达式规则判断,待验证的字符内容是否符合要求�? <br>
     * 比如'[0-9]*'即判断是否为数字的规�?, '^[a-z0-9_-]{3,15}$'即判断是否为用户名的规则,<br>
     * '((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})'即判断是否为密码的规�?,<br>
     * '^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$'即email规则,<br>
     * '([^\s]+(\.(?i)(jpg|png|gif|bmp))$)'即判断某图片文件格式,<br>
     * '^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$'即IP规则.
     *
     * 
     * @param regExpr
     *            正则表达�?
     * @param content
     *            待验证的字符内容
     * @return boolean
     */
    public static boolean isMatch(String regExpr, String content) {
        if (StringUtils.isEmpty(regExpr, content))
            return false;
 
        Pattern pattern = Pattern.compile(regExpr);
        Matcher matcher = pattern.matcher(content);
 
        return matcher.matches();
    }
 
    /**
     * 正则判断纯数�?
     * 
     * @param str
     * @return
     */
    public static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }
 
    public static boolean isEmpty(String str) {
        return null == str || str.trim().length() == 0 || "undefined".equals(str);
    }
 
    /**判断空*/
    public static boolean isNull(String str) {
        return null == str || str.trim().length() == 0 || "undefined".equals(str);
    }
 
    /**判断非空*/
    public static boolean noNull(String str) {
        return null != str && str.trim().length() != 0 && !"undefined".equals(str);
    }
 
    /**
     * 判断字符内容中是否存在一个为空的字符�?
     * <p>
     * 如果在所有的字符串内容中,只要存在某�?个字符串为空,则返回为true, 如果�?有的字符串内容中,不存在�?个空字符串,则返回为false.
     * 
     * @param strings
     * @return boolean
     */
    public static boolean isEmpty(String... strings) {
        if (strings == null)
            return true;
 
        for (String str : strings) {
            if (StringUtils.isEmpty(str))
                return true;
        }
 
        return false;
    }
 
    public static boolean isAllEmpty(String... strings) {
        if (strings == null)
            return true;
 
        for (String str : strings) {
            if (!StringUtils.isEmpty(str))
                return false;
        }
 
        return true;
    }
 
    /**
     * @param strings
     *            该数组是否有�?
     * @return
     */
    public static boolean hasContent(String[] strings) {
        if (strings != null && strings.length > 0)
            return true;
 
        return false;
    }
 
    /**
     * @param params
     *            该map是否有�??
     * @return
     */
    public static boolean hasContent(Map<?, ?> params) {
        if (params != null && params.size() > 0)
            return true;
 
        return false;
    }
 
    public static boolean isNumeric2(String str) {
        if (null == str || isEmpty(str)) {
            return false;
        }
        char[] chars = str.toCharArray();
        for (char c : chars) {
            if (!Character.isDigit(c))
                return false;
        }
        return true;
    }
 
    public static int parseInt(String string) {
        if (null != string && isNumeric2(string)) {
            return Integer.parseInt(string);
        }
        return 0;
    }
 
    /**
     * 对字符串(手机,名称)作隐藏处理
     * @param oriStr 原始字符串
     * @param type 类型0:只保留第一个及最后一个字符,其它用*替代;1前4后3保留,中间用*替代
     * @return
     */
    public static String hideKeyWord(String oriStr, int type)
    {
        if(!isEmpty(oriStr))
        {
            String temp = null;
 
            if(type == 0)
            {
                if(oriStr.length() == 1)
                {
                    temp = oriStr;
                }else if(oriStr.length() == 2) {
                    temp = oriStr.substring(0, 1) + "*";
                }else if(oriStr.length() > 2) {
                    temp = oriStr.substring(0, 1);
                    for (int i = 1; i < oriStr.length() - 1; i++) {
                        temp += "*";
                    }
                    temp += oriStr.substring(oriStr.length() - 1, oriStr.length());
                }
            }else{
                if(oriStr.length() < 8)
                {
                    temp = oriStr;
                }else{
                    temp = oriStr.substring(0,3);
                    for (int i = 3; i < oriStr.length() - 4; i++) {
                        temp += "*";
                    }
                    temp += oriStr.substring(oriStr.length() - 4, oriStr.length());
                }
            }
 
            return temp;
        }
 
        return oriStr;
    }
 
}