分享一个String对象类，也许你的项目中会用获得
添加时间:2013-7-9 点击量:
每次做项目都邑碰到字符串的处理惩罚，每次都邑去写一个StringUtil，完成一些功能。
但其实每次要的功能都差不久不多：
1.断定类（包含NULL和空串、是否是空白字符串等）
2.默认值
3.去空白（trim）
4.斗劲
5.字符类型断定（是否只包含数字、字母）
6.大小写转换（首字母大小写等）
7.字符串分别
8.字符串连接
9.字符串查找
10.取子串
11.删除字符
12.字符串斗劲
下面是一个字符串的对象类，涵盖了上方列的功能，算是斗劲完全的。
1 /
2 有关字符串处理惩罚的对象类。
3
4 <p>
5 这个类中的每个办法都可以“安然”地处理惩罚<code>null</code>，而不会抛出<code>NullPointerException</code>。
6 </p>
7
8 /
9 public class StringUtil {
10 / ============================================================================ /
11 / 常量和singleton。 /
12 / ============================================================================ /
13
14 / 空字符串。 /
15 public static final String EMPTY_STRING = ;
16
17 / ============================================================================ /
18 / 判空函数。 /
19 / /
20 / 以下办法用来剖断一个字符串是否为： /
21 / 1. null /
22 / 2. empty - /
23 / 3. blank - 全部是空白 - 空白由Character.isWhitespace所定义。 /
24 / ============================================================================ /
25
26 /
27 搜检字符串是否为<code>null</code>或空字符串<code></code>。
28 <pre>
29 StringUtil.isEmpty（null） = true
30 StringUtil.isEmpty（） = true
31 StringUtil.isEmpty（ ） = false
32 StringUtil.isEmpty（bob） = false
33 StringUtil.isEmpty（ bob ） = false
34 </pre>
35
36 ＠param str 要搜检的字符串
37
38 ＠return 若是为空， 则返回<code>true</code>
39 /
40 public static boolean isEmpty（String str） {
41 return （（str == null） || （str.length（） == 0））;
42 }
43
44 /
45 搜检字符串是否不是<code>null</code>和空字符串<code></code>。
46 <pre>
47 StringUtil.isEmpty（null） = false
48 StringUtil.isEmpty（） = false
49 StringUtil.isEmpty（ ） = true
50 StringUtil.isEmpty（bob） = true
51 StringUtil.isEmpty（ bob ） = true
52 </pre>
53
54 ＠param str 要搜检的字符串
55
56 ＠return 若是不为空， 则返回<code>true</code>
57 /
58 public static boolean isNotEmpty（String str） {
59 return （（str != null） && （str.length（） > 0））;
60 }
61
62 /
63 搜检字符串是否是空白：<code>null</code>、空字符串<code></code>或只有空白字符。
64 <pre>
65 StringUtil.isBlank（null） = true
66 StringUtil.isBlank（） = true
67 StringUtil.isBlank（ ） = true
68 StringUtil.isBlank（bob） = false
69 StringUtil.isBlank（ bob ） = false
70 </pre>
71
72 ＠param str 要搜检的字符串
73
74 ＠return 若是为空白， 则返回<code>true</code>
75 /
76 public static boolean isBlank（String str） {
77 int length;
78
79 if （（str == null） || （（length = str.length（）） == 0）） {
80 return true;
81 }
82
83 for （int i = 0; i < length; i++） {
84 if （!Character.isWhitespace（str.charAt（i））） {
85 return false;
86 }
87 }
88
89 return true;
90 }
91
92 /
93 搜检字符串是否不是空白：<code>null</code>、空字符串<code></code>或只有空白字符。
94 <pre>
95 StringUtil.isBlank（null） = false
96 StringUtil.isBlank（） = false
97 StringUtil.isBlank（ ） = false
98 StringUtil.isBlank（bob） = true
99 StringUtil.isBlank（ bob ） = true
100 </pre>
101
102 ＠param str 要搜检的字符串
103
104 ＠return 若是为空白， 则返回<code>true</code>
105 /
106 public static boolean isNotBlank（String str） {
107 int length;
108
109 if （（str == null） || （（length = str.length（）） == 0）） {
110 return false;
111 }
112
113 for （int i = 0; i < length; i++） {
114 if （!Character.isWhitespace（str.charAt（i））） {
115 return true;
116 }
117 }
118
119 return false;
120 }
121
122 / ============================================================================ /
123 / 默认值函数。 /
124 / /
125 / 当字符串为null、empty或blank时，将字符串转换成指定的默认字符串。 /
126 / ============================================================================ /
127
128 /
129 若是字符串是<code>null</code>，则返回空字符串<code></code>，不然返回字符串本身。
130 <pre>
131 StringUtil.defaultIfNull（null） =
132 StringUtil.defaultIfNull（） =
133 StringUtil.defaultIfNull（ ） =
134 StringUtil.defaultIfNull（bat） = bat
135 </pre>
136
137 ＠param str 要转换的字符串
138
139 ＠return 字符串本身或空字符串<code></code>
140 /
141 public static String defaultIfNull（String str） {
142 return （str == null） ？ EMPTY_STRING : str;
143 }
144
145 /
146 若是字符串是<code>null</code>，则返回指定默认字符串，不然返回字符串本身。
147 <pre>
148 StringUtil.defaultIfNull（null， default） = default
149 StringUtil.defaultIfNull（， default） =
150 StringUtil.defaultIfNull（ ， default） =
151 StringUtil.defaultIfNull（bat， default） = bat
152 </pre>
153
154 ＠param str 要转换的字符串
155 ＠param defaultStr 默认字符串
156
157 ＠return 字符串本身或指定的默认字符串
158 /
159 public static String defaultIfNull（String str， String defaultStr） {
160 return （str == null） ？ defaultStr : str;
161 }
162
163 /
164 若是字符串是<code>null</code>或空字符串<code></code>，则返回空字符串<code></code>，不然返回字符串本身。
165
166 <p>
167 此办法实际上和<code>defaultIfNull（String）</code>等效。
168 <pre>
169 StringUtil.defaultIfEmpty（null） =
170 StringUtil.defaultIfEmpty（） =
171 StringUtil.defaultIfEmpty（ ） =
172 StringUtil.defaultIfEmpty（bat） = bat
173 </pre>
174 </p>
175
176 ＠param str 要转换的字符串
177
178 ＠return 字符串本身或空字符串<code></code>
179 /
180 public static String defaultIfEmpty（String str） {
181 return （str == null） ？ EMPTY_STRING : str;
182 }
183
184 /
185 若是字符串是<code>null</code>或空字符串<code></code>，则返回指定默认字符串，不然返回字符串本身。
186 <pre>
187 StringUtil.defaultIfEmpty（null， default） = default
188 StringUtil.defaultIfEmpty（， default） = default
189 StringUtil.defaultIfEmpty（ ， default） =
190 StringUtil.defaultIfEmpty（bat， default） = bat
191 </pre>
192
193 ＠param str 要转换的字符串
194 ＠param defaultStr 默认字符串
195
196 ＠return 字符串本身或指定的默认字符串
197 /
198 public static String defaultIfEmpty（String str， String defaultStr） {
199 return （（str == null） || （str.length（） == 0）） ？ defaultStr : str;
200 }
201
202 /
203 若是字符串是空白：<code>null</code>、空字符串<code></code>或只有空白字符，则返回空字符串<code></code>，不然返回字符串本身。
204 <pre>
205 StringUtil.defaultIfBlank（null） =
206 StringUtil.defaultIfBlank（） =
207 StringUtil.defaultIfBlank（ ） =
208 StringUtil.defaultIfBlank（bat） = bat
209 </pre>
210
211 ＠param str 要转换的字符串
212
213 ＠return 字符串本身或空字符串<code></code>
214 /
215 public static String defaultIfBlank（String str） {
216 return isBlank（str） ？ EMPTY_STRING : str;
217 }
218
219 /
220 若是字符串是<code>null</code>或空字符串<code></code>，则返回指定默认字符串，不然返回字符串本身。
221 <pre>
222 StringUtil.defaultIfBlank（null， default） = default
223 StringUtil.defaultIfBlank（， default） = default
224 StringUtil.defaultIfBlank（ ， default） = default
225 StringUtil.defaultIfBlank（bat， default） = bat
226 </pre>
227
228 ＠param str 要转换的字符串
229 ＠param defaultStr 默认字符串
230
231 ＠return 字符串本身或指定的默认字符串
232 /
233 public static String defaultIfBlank（String str， String defaultStr） {
234 return isBlank（str） ？ defaultStr : str;
235 }
236
237 / ============================================================================ /
238 / 去空白（或指定字符）的函数。 /
239 / /
240 / 以下办法用来除去一个字串中的空白或指定字符。 /
241 / ============================================================================ /
242
243 /
244 除去字符串头尾部的空白，若是字符串是<code>null</code>，依然返回<code>null</code>。
245
246 <p>
247 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
248 因而可以除去英文字符集之外的其它空白，如中文空格。
249 <pre>
250 StringUtil.trim（null） = null
251 StringUtil.trim（） =
252 StringUtil.trim（ ） =
253 StringUtil.trim（abc） = abc
254 StringUtil.trim（ abc ） = abc
255 </pre>
256 </p>
257
258 ＠param str 要处理惩罚的字符串
259
260 ＠return 除去空白的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
261 /
262 public static String trim（String str） {
263 return trim（str， null， 0）;
264 }
265
266 /
267 除去字符串头尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
268 <pre>
269 StringUtil.trim（null， ） = null
270 StringUtil.trim（， ） =
271 StringUtil.trim（abc， null） = abc
272 StringUtil.trim（ abc， null） = abc
273 StringUtil.trim（abc ， null） = abc
274 StringUtil.trim（ abc ， null） = abc
275 StringUtil.trim（ abcyx， xyz） = abc
276 </pre>
277
278 ＠param str 要处理惩罚的字符串
279 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
280
281 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
282 /
283 public static String trim（String str， String stripChars） {
284 return trim（str， stripChars， 0）;
285 }
286
287 /
288 除去字符串头部的空白，若是字符串是<code>null</code>，则返回<code>null</code>。
289
290 <p>
291 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
292 因而可以除去英文字符集之外的其它空白，如中文空格。
293 <pre>
294 StringUtil.trimStart（null） = null
295 StringUtil.trimStart（） =
296 StringUtil.trimStart（abc） = abc
297 StringUtil.trimStart（ abc） = abc
298 StringUtil.trimStart（abc ） = abc
299 StringUtil.trimStart（ abc ） = abc
300 </pre>
301 </p>
302
303 ＠param str 要处理惩罚的字符串
304
305 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
306 /
307 public static String trimStart（String str） {
308 return trim（str， null， -1）;
309 }
310
311 /
312 除去字符串头部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
313 <pre>
314 StringUtil.trimStart（null， ） = null
315 StringUtil.trimStart（， ） =
316 StringUtil.trimStart（abc， ） = abc
317 StringUtil.trimStart（abc， null） = abc
318 StringUtil.trimStart（ abc， null） = abc
319 StringUtil.trimStart（abc ， null） = abc
320 StringUtil.trimStart（ abc ， null） = abc
321 StringUtil.trimStart（yxabc ， xyz） = abc
322 </pre>
323
324 ＠param str 要处理惩罚的字符串
325 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
326
327 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
328 /
329 public static String trimStart（String str， String stripChars） {
330 return trim（str， stripChars， -1）;
331 }
332
333 /
334 除去字符串尾部的空白，若是字符串是<code>null</code>，则返回<code>null</code>。
335
336 <p>
337 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
338 因而可以除去英文字符集之外的其它空白，如中文空格。
339 <pre>
340 StringUtil.trimEnd（null） = null
341 StringUtil.trimEnd（） =
342 StringUtil.trimEnd（abc） = abc
343 StringUtil.trimEnd（ abc） = abc
344 StringUtil.trimEnd（abc ） = abc
345 StringUtil.trimEnd（ abc ） = abc
346 </pre>
347 </p>
348
349 ＠param str 要处理惩罚的字符串
350
351 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
352 /
353 public static String trimEnd（String str） {
354 return trim（str， null， 1）;
355 }
356
357 /
358 除去字符串尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
359 <pre>
360 StringUtil.trimEnd（null， ） = null
361 StringUtil.trimEnd（， ） =
362 StringUtil.trimEnd（abc， ） = abc
363 StringUtil.trimEnd（abc， null） = abc
364 StringUtil.trimEnd（ abc， null） = abc
365 StringUtil.trimEnd（abc ， null） = abc
366 StringUtil.trimEnd（ abc ， null） = abc
367 StringUtil.trimEnd（ abcyx， xyz） = abc
368 </pre>
369
370 ＠param str 要处理惩罚的字符串
371 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
372
373 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
374 /
375 public static String trimEnd（String str， String stripChars） {
376 return trim（str， stripChars， 1）;
377 }
378
379 /
380 除去字符串头尾部的空白，若是成果字符串是空字符串<code></code>，则返回<code>null</code>。
381
382 <p>
383 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
384 因而可以除去英文字符集之外的其它空白，如中文空格。
385 <pre>
386 StringUtil.trimToNull（null） = null
387 StringUtil.trimToNull（） = null
388 StringUtil.trimToNull（ ） = null
389 StringUtil.trimToNull（abc） = abc
390 StringUtil.trimToNull（ abc ） = abc
391 </pre>
392 </p>
393
394 ＠param str 要处理惩罚的字符串
395
396 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
397 /
398 public static String trimToNull（String str） {
399 return trimToNull（str， null）;
400 }
401
402 /
403 除去字符串头尾部的空白，若是成果字符串是空字符串<code></code>，则返回<code>null</code>。
404
405 <p>
406 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
407 因而可以除去英文字符集之外的其它空白，如中文空格。
408 <pre>
409 StringUtil.trim（null， ） = null
410 StringUtil.trim（， ） = null
411 StringUtil.trim（abc， null） = abc
412 StringUtil.trim（ abc， null） = abc
413 StringUtil.trim（abc ， null） = abc
414 StringUtil.trim（ abc ， null） = abc
415 StringUtil.trim（ abcyx， xyz） = abc
416 </pre>
417 </p>
418
419 ＠param str 要处理惩罚的字符串
420 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
421
422 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
423 /
424 public static String trimToNull（String str， String stripChars） {
425 String result = trim（str， stripChars）;
426
427 if （（result == null） || （result.length（） == 0）） {
428 return null;
429 }
430
431 return result;
432 }
433
434 /
435 除去字符串头尾部的空白，若是字符串是<code>null</code>，则返回空字符串<code></code>。
436
437 <p>
438 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
439 因而可以除去英文字符集之外的其它空白，如中文空格。
440 <pre>
441 StringUtil.trimToEmpty（null） =
442 StringUtil.trimToEmpty（） =
443 StringUtil.trimToEmpty（ ） =
444 StringUtil.trimToEmpty（abc） = abc
445 StringUtil.trimToEmpty（ abc ） = abc
446 </pre>
447 </p>
448
449 ＠param str 要处理惩罚的字符串
450
451 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
452 /
453 public static String trimToEmpty（String str） {
454 return trimToEmpty（str， null）;
455 }
456
457 /
458 除去字符串头尾部的空白，若是字符串是<code>null</code>，则返回空字符串<code></code>。
459
460 <p>
461 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
462 因而可以除去英文字符集之外的其它空白，如中文空格。
463 <pre>
464 StringUtil.trim（null， ） =
465 StringUtil.trim（， ） =
466 StringUtil.trim（abc， null） = abc
467 StringUtil.trim（ abc， null） = abc
468 StringUtil.trim（abc ， null） = abc
469 StringUtil.trim（ abc ， null） = abc
470 StringUtil.trim（ abcyx， xyz） = abc
471 </pre>
472 </p>
473
474 ＠param str 要处理惩罚的字符串
475
476 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
477 /
478 public static String trimToEmpty（String str， String stripChars） {
479 String result = trim（str， stripChars）;
480
481 if （result == null） {
482 return EMPTY_STRING;
483 }
484
485 return result;
486 }
487
488 /
489 除去字符串头尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
490 <pre>
491 StringUtil.trim（null， ） = null
492 StringUtil.trim（， ） =
493 StringUtil.trim（abc， null） = abc
494 StringUtil.trim（ abc， null） = abc
495 StringUtil.trim（abc ， null） = abc
496 StringUtil.trim（ abc ， null） = abc
497 StringUtil.trim（ abcyx， xyz） = abc
498 </pre>
499
500 ＠param str 要处理惩罚的字符串
501 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
502 ＠param mode <code>-1</code>默示trimStart，<code>0</code>默示trim全部，<code>1</code>默示trimEnd
503
504 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
505 /
506 private static String trim（String str， String stripChars， int mode） {
507 if （str == null） {
508 return null;
509 }
510
511 int length = str.length（）;
512 int start = 0;
513 int end = length;
514
515 // 扫描字符串头部
516 if （mode <= 0） {
517 if （stripChars == null） {
518 while （（start < end） && （Character.isWhitespace（str.charAt（start）））） {
519 start++;
520 }
521 } else if （stripChars.length（） == 0） {
522 return str;
523 } else {
524 while （（start < end） && （stripChars.indexOf（str.charAt（start）） != -1）） {
525 start++;
526 }
527 }
528 }
529
530 // 扫描字符串尾部
531 if （mode >= 0） {
532 if （stripChars == null） {
533 while （（start < end） && （Character.isWhitespace（str.charAt（end - 1）））） {
534 end--;
535 }
536 } else if （stripChars.length（） == 0） {
537 return str;
538 } else {
539 while （（start < end） && （stripChars.indexOf（str.charAt（end - 1）） != -1）） {
540 end--;
541 }
542 }
543 }
544
545 if （（start > 0） || （end < length）） {
546 return str.substring（start， end）;
547 }
548
549 return str;
550 }
551
552 / ============================================================================ /
553 / 斗劲函数。 /
554 / /
555 / 以下办法用来斗劲两个字符串是否雷同。 /
556 / ============================================================================ /
557
558 /
559 斗劲两个字符串（大小写敏感）。
560 <pre>
561 StringUtil.equals（null， null） = true
562 StringUtil.equals（null， abc） = false
563 StringUtil.equals（abc， null） = false
564 StringUtil.equals（abc， abc） = true
565 StringUtil.equals（abc， ABC） = false
566 </pre>
567
568 ＠param str1 要斗劲的字符串1
569 ＠param str2 要斗劲的字符串2
570
571 ＠return 若是两个字符串雷同，或者都是<code>null</code>，则返回<code>true</code>
572 /
573 public static boolean equals（String str1， String str2） {
574 if （str1 == null） {
575 return str2 == null;
576 }
577
578 return str1.equals（str2）;
579 }
580
581 /
582 斗劲两个字符串（大小写不敏感）。
583 <pre>
584 StringUtil.equalsIgnoreCase（null， null） = true
585 StringUtil.equalsIgnoreCase（null， abc） = false
586 StringUtil.equalsIgnoreCase（abc， null） = false
587 StringUtil.equalsIgnoreCase（abc， abc） = true
588 StringUtil.equalsIgnoreCase（abc， ABC） = true
589 </pre>
590
591 ＠param str1 要斗劲的字符串1
592 ＠param str2 要斗劲的字符串2
593
594 ＠return 若是两个字符串雷同，或者都是<code>null</code>，则返回<code>true</code>
595 /
596 public static boolean equalsIgnoreCase（String str1， String str2） {
597 if （str1 == null） {
598 return str2 == null;
599 }
600
601 return str1.equalsIgnoreCase（str2）;
602 }
603
604 / ============================================================================ /
605 / 字符串类型剖断函数。 /
606 / /
607 / 剖断字符串的类型是否为：字母、数字、空白等 /
608 / ============================================================================ /
609
610 /
611 断定字符串是否只包含unicode字母。
612
613 <p>
614 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
615 </p>
616 <pre>
617 StringUtil.isAlpha（null） = false
618 StringUtil.isAlpha（） = true
619 StringUtil.isAlpha（ ） = false
620 StringUtil.isAlpha（abc） = true
621 StringUtil.isAlpha（ab2c） = false
622 StringUtil.isAlpha（ab-c） = false
623 </pre>
624
625 ＠param str 要搜检的字符串
626
627 ＠return 若是字符串非<code>null</code>并且全由unicode字母构成，则返回<code>true</code>
628 /
629 public static boolean isAlpha（String str） {
630 if （str == null） {
631 return false;
632 }
633
634 int length = str.length（）;
635
636 for （int i = 0; i < length; i++） {
637 if （!Character.isLetter（str.charAt（i））） {
638 return false;
639 }
640 }
641
642 return true;
643 }
644
645 /
646 断定字符串是否只包含unicode字母和空格<code> </code>。
647
648 <p>
649 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
650 </p>
651 <pre>
652 StringUtil.isAlphaSpace（null） = false
653 StringUtil.isAlphaSpace（） = true
654 StringUtil.isAlphaSpace（ ） = true
655 StringUtil.isAlphaSpace（abc） = true
656 StringUtil.isAlphaSpace（ab c） = true
657 StringUtil.isAlphaSpace（ab2c） = false
658 StringUtil.isAlphaSpace（ab-c） = false
659 </pre>
660
661 ＠param str 要搜检的字符串
662
663 ＠return 若是字符串非<code>null</code>并且全由unicode字母和空格构成，则返回<code>true</code>
664 /
665 public static boolean isAlphaSpace（String str） {
666 if （str == null） {
667 return false;
668 }
669
670 int length = str.length（）;
671
672 for （int i = 0; i < length; i++） {
673 if （!Character.isLetter（str.charAt（i）） && （str.charAt（i） != ）） {
674 return false;
675 }
676 }
677
678 return true;
679 }
680
681 /
682 断定字符串是否只包含unicode字母和数字。
683
684 <p>
685 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
686 </p>
687 <pre>
688 StringUtil.isAlphanumeric（null） = false
689 StringUtil.isAlphanumeric（） = true
690 StringUtil.isAlphanumeric（ ） = false
691 StringUtil.isAlphanumeric（abc） = true
692 StringUtil.isAlphanumeric（ab c） = false
693 StringUtil.isAlphanumeric（ab2c） = true
694 StringUtil.isAlphanumeric（ab-c） = false
695 </pre>
696
697 ＠param str 要搜检的字符串
698
699 ＠return 若是字符串非<code>null</code>并且全由unicode字母数字构成，则返回<code>true</code>
700 /
701 public static boolean isAlphanumeric（String str） {
702 if （str == null） {
703 return false;
704 }
705
706 int length = str.length（）;
707
708 for （int i = 0; i < length; i++） {
709 if （!Character.isLetterOrDigit（str.charAt（i））） {
710 return false;
711 }
712 }
713
714 return true;
715 }
716
717 /
718 断定字符串是否只包含unicode字母数字和空格<code> </code>。
719
720 <p>
721 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
722 </p>
723 <pre>
724 StringUtil.isAlphanumericSpace（null） = false
725 StringUtil.isAlphanumericSpace（） = true
726 StringUtil.isAlphanumericSpace（ ） = true
727 StringUtil.isAlphanumericSpace（abc） = true
728 StringUtil.isAlphanumericSpace（ab c） = true
729 StringUtil.isAlphanumericSpace（ab2c） = true
730 StringUtil.isAlphanumericSpace（ab-c） = false
731 </pre>
732
733 ＠param str 要搜检的字符串
734
735 ＠return 若是字符串非<code>null</code>并且全由unicode字母数字和空格构成，则返回<code>true</code>
736 /
737 public static boolean isAlphanumericSpace（String str） {
738 if （str == null） {
739 return false;
740 }
741
742 int length = str.length（）;
743
744 for （int i = 0; i < length; i++） {
745 if （!Character.isLetterOrDigit（str.charAt（i）） && （str.charAt（i） != ）） {
746 return false;
747 }
748 }
749
750 return true;
751 }
752
753 /
754 断定字符串是否只包含unicode数字。
755
756 <p>
757 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
758 </p>
759 <pre>
760 StringUtil.isNumeric（null） = false
761 StringUtil.isNumeric（） = true
762 StringUtil.isNumeric（ ） = false
763 StringUtil.isNumeric（123） = true
764 StringUtil.isNumeric（12 3） = false
765 StringUtil.isNumeric（ab2c） = false
766 StringUtil.isNumeric（12-3） = false
767 StringUtil.isNumeric（12.3） = false
768 </pre>
769
770 ＠param str 要搜检的字符串
771
772 ＠return 若是字符串非<code>null</code>并且全由unicode数字构成，则返回<code>true</code>
773 /
774 public static boolean isNumeric（String str） {
775 if （str == null） {
776 return false;
777 }
778
779 int length = str.length（）;
780
781 for （int i = 0; i < length; i++） {
782 if （!Character.isDigit（str.charAt（i））） {
783 return false;
784 }
785 }
786
787 return true;
788 }
789
790 /
791 断定字符串是否只包含unicode数字，包含小数。
792
793 <p>
794 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
795 </p>
796 <pre>
797 StringUtil.isNumeric（null） = false
798 StringUtil.isNumeric（） = false
799 StringUtil.isNumeric（ ） = false
800 StringUtil.isNumeric（123） = true
801 StringUtil.isNumeric（12 3） = false
802 StringUtil.isNumeric（ab2c） = false
803 StringUtil.isNumeric（12-3） = false
804 StringUtil.isNumeric（12.3） = true
805 </pre>
806
807 ＠param str 要搜检的字符串
808
809 ＠return 若是字符串非<code>null</code>并且全由unicode数字构成，则返回<code>true</code>
810 /
811 public static boolean isNumber（String str） {
812 if （isBlank（str）） {
813 return false;
814 }
815 int index = str.indexOf（.）;
816 if （index < 0） {
817 return isNumeric（str）;
818 } else {
819 String num1 = str.substring（0， index）;
820 String num2 = str.substring（index + 1）;
821 return isNumeric（num1） && isNumeric（num2）;
822 }
823 }
824
825
826 /
827 断定字符串是否只包含unicode数字和空格<code> </code>。
828
829 <p>
830 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
831 </p>
832 <pre>
833 StringUtil.isNumericSpace（null） = false
834 StringUtil.isNumericSpace（） = true
835 StringUtil.isNumericSpace（ ） = true
836 StringUtil.isNumericSpace（123） = true
837 StringUtil.isNumericSpace（12 3） = true
838 StringUtil.isNumericSpace（ab2c） = false
839 StringUtil.isNumericSpace（12-3） = false
840 StringUtil.isNumericSpace（12.3） = false
841 </pre>
842
843 ＠param str 要搜检的字符串
844
845 ＠return 若是字符串非<code>null</code>并且全由unicode数字和空格构成，则返回<code>true</code>
846 /
847 public static boolean isNumericSpace（String str） {
848 if （str == null） {
849 return false;
850 }
851
852 int length = str.length（）;
853
854 for （int i = 0; i < length; i++） {
855 if （!Character.isDigit（str.charAt（i）） && （str.charAt（i） != ）） {
856 return false;
857 }
858 }
859
860 return true;
861 }
862
863 /
864 断定字符串是否只包含unicode空白。
865
866 <p>
867 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
868 </p>
869 <pre>
870 StringUtil.isWhitespace（null） = false
871 StringUtil.isWhitespace（） = true
872 StringUtil.isWhitespace（ ） = true
873 StringUtil.isWhitespace（abc） = false
874 StringUtil.isWhitespace（ab2c） = false
875 StringUtil.isWhitespace（ab-c） = false
876 </pre>
877
878 ＠param str 要搜检的字符串
879
880 ＠return 若是字符串非<code>null</code>并且全由unicode空白构成，则返回<code>true</code>
881 /
882 public static boolean isWhitespace（String str） {
883 if （str == null） {
884 return false;
885 }
886
887 int length = str.length（）;
888
889 for （int i = 0; i < length; i++） {
890 if （!Character.isWhitespace（str.charAt（i））） {
891 return false;
892 }
893 }
894
895 return true;
896 }
897
898 / ============================================================================ /
899 / 大小写转换。 /
900 / ============================================================================ /
901
902 /
903 将字符串转换成大写。
904
905 <p>
906 若是字符串是<code>null</code>则返回<code>null</code>。
907 <pre>
908 StringUtil.toUpperCase（null） = null
909 StringUtil.toUpperCase（） =
910 StringUtil.toUpperCase（aBc） = ABC
911 </pre>
912 </p>
913
914 ＠param str 要转换的字符串
915
916 ＠return 大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
917 /
918 public static String toUpperCase（String str） {
919 if （str == null） {
920 return null;
921 }
922
923 return str.toUpperCase（）;
924 }
925
926 /
927 将字符串转换成小写。
928
929 <p>
930 若是字符串是<code>null</code>则返回<code>null</code>。
931 <pre>
932 StringUtil.toLowerCase（null） = null
933 StringUtil.toLowerCase（） =
934 StringUtil.toLowerCase（aBc） = abc
935 </pre>
936 </p>
937
938 ＠param str 要转换的字符串
939
940 ＠return 大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
941 /
942 public static String toLowerCase（String str） {
943 if （str == null） {
944 return null;
945 }
946
947 return str.toLowerCase（）;
948 }
949
950 /
951 将字符串的首字符转成大写（<code>Character.toTitleCase</code>），其它字符不变。
952
953 <p>
954 若是字符串是<code>null</code>则返回<code>null</code>。
955 <pre>
956 StringUtil.capitalize（null） = null
957 StringUtil.capitalize（） =
958 StringUtil.capitalize（cat） = Cat
959 StringUtil.capitalize（cAt） = CAt
960 </pre>
961 </p>
962
963 ＠param str 要转换的字符串
964
965 ＠return 首字符为大写的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
966 /
967 public static String capitalize（String str） {
968 int strLen;
969
970 if （（str == null） || （（strLen = str.length（）） == 0）） {
971 return str;
972 }
973
974 return new StringBuffer（strLen）.append（Character.toTitleCase（str.charAt（0）））.append（
975 str.substring（1））.toString（）;
976 }
977
978 /
979 将字符串的首字符转成小写，其它字符不变。
980
981 <p>
982 若是字符串是<code>null</code>则返回<code>null</code>。
983 <pre>
984 StringUtil.uncapitalize（null） = null
985 StringUtil.uncapitalize（） =
986 StringUtil.uncapitalize（Cat） = cat
987 StringUtil.uncapitalize（CAT） = cAT
988 </pre>
989 </p>
990
991 ＠param str 要转换的字符串
992
993 ＠return 首字符为小写的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
994 /
995 public static String uncapitalize（String str） {
996 int strLen;
997
998 if （（str == null） || （（strLen = str.length（）） == 0）） {
999 return str;
1000 }
1001
1002 return new StringBuffer（strLen）.append（Character.toLowerCase（str.charAt（0）））.append（
1003 str.substring（1））.toString（）;
1004 }
1005
1006 /
1007 反转字符串的大小写。
1008
1009 <p>
1010 若是字符串是<code>null</code>则返回<code>null</code>。
1011 <pre>
1012 StringUtil.swapCase（null） = null
1013 StringUtil.swapCase（） =
1014 StringUtil.swapCase（The dog has a BONE） = tHE DOG HAS A bone
1015 </pre>
1016 </p>
1017
1018 ＠param str 要转换的字符串
1019
1020 ＠return 大小写被反转的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1021 /
1022 public static String swapCase（String str） {
1023 int strLen;
1024
1025 if （（str == null） || （（strLen = str.length（）） == 0）） {
1026 return str;
1027 }
1028
1029 StringBuffer buffer = new StringBuffer（strLen）;
1030
1031 char ch = 0;
1032
1033 for （int i = 0; i < strLen; i++） {
1034 ch = str.charAt（i）;
1035
1036 if （Character.isUpperCase（ch）） {
1037 ch = Character.toLowerCase（ch）;
1038 } else if （Character.isTitleCase（ch）） {
1039 ch = Character.toLowerCase（ch）;
1040 } else if （Character.isLowerCase（ch）） {
1041 ch = Character.toUpperCase（ch）;
1042 }
1043
1044 buffer.append（ch）;
1045 }
1046
1047 return buffer.toString（）;
1048 }
1049
1050 /
1051 将字符串转换成camel case。
1052
1053 <p>
1054 若是字符串是<code>null</code>则返回<code>null</code>。
1055 <pre>
1056 StringUtil.toCamelCase（null） = null
1057 StringUtil.toCamelCase（） =
1058 StringUtil.toCamelCase（aBc） = aBc
1059 StringUtil.toCamelCase（aBc def） = aBcDef
1060 StringUtil.toCamelCase（aBc def_ghi） = aBcDefGhi
1061 StringUtil.toCamelCase（aBc def_ghi 123） = aBcDefGhi123
1062 </pre>
1063 </p>
1064
1065 <p>
1066 此办保存除了下划线和空白以外的所有分隔符。
1067 </p>
1068
1069 ＠param str 要转换的字符串
1070
1071 ＠return camel case字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1072 /
1073 public static String toCamelCase（String str） {
1074 return CAMEL_CASE_TOKENIZER.parse（str）;
1075 }
1076
1077 /
1078 将字符串转换成pascal case。
1079
1080 <p>
1081 若是字符串是<code>null</code>则返回<code>null</code>。
1082 <pre>
1083 StringUtil.toPascalCase（null） = null
1084 StringUtil.toPascalCase（） =
1085 StringUtil.toPascalCase（aBc） = ABc
1086 StringUtil.toPascalCase（aBc def） = ABcDef
1087 StringUtil.toPascalCase（aBc def_ghi） = ABcDefGhi
1088 StringUtil.toPascalCase（aBc def_ghi 123） = aBcDefGhi123
1089 </pre>
1090 </p>
1091
1092 <p>
1093 此办保存除了下划线和空白以外的所有分隔符。
1094 </p>
1095
1096 ＠param str 要转换的字符串
1097
1098 ＠return pascal case字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1099 /
1100 public static String toPascalCase（String str） {
1101 return PASCAL_CASE_TOKENIZER.parse（str）;
1102 }
1103
1104 /
1105 将字符串转换成下划线分隔的大写字符串。
1106
1107 <p>
1108 若是字符串是<code>null</code>则返回<code>null</code>。
1109 <pre>
1110 StringUtil.toUpperCaseWithUnderscores（null） = null
1111 StringUtil.toUpperCaseWithUnderscores（） =
1112 StringUtil.toUpperCaseWithUnderscores（aBc） = A_BC
1113 StringUtil.toUpperCaseWithUnderscores（aBc def） = A_BC_DEF
1114 StringUtil.toUpperCaseWithUnderscores（aBc def_ghi） = A_BC_DEF_GHI
1115 StringUtil.toUpperCaseWithUnderscores（aBc def_ghi 123） = A_BC_DEF_GHI_123
1116 StringUtil.toUpperCaseWithUnderscores（__a__Bc__） = __A__BC__
1117 </pre>
1118 </p>
1119
1120 <p>
1121 此办保存除了空白以外的所有分隔符。
1122 </p>
1123
1124 ＠param str 要转换的字符串
1125
1126 ＠return 下划线分隔的大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1127 /
1128 public static String toUpperCaseWithUnderscores（String str） {
1129 return UPPER_CASE_WITH_UNDERSCORES_TOKENIZER.parse（str）;
1130 }
1131
1132 /
1133 将字符串转换成下划线分隔的小写字符串。
1134
1135 <p>
1136 若是字符串是<code>null</code>则返回<code>null</code>。
1137 <pre>
1138 StringUtil.toLowerCaseWithUnderscores（null） = null
1139 StringUtil.toLowerCaseWithUnderscores（） =
1140 StringUtil.toLowerCaseWithUnderscores（aBc） = a_bc
1141 StringUtil.toLowerCaseWithUnderscores（aBc def） = a_bc_def
1142 StringUtil.toLowerCaseWithUnderscores（aBc def_ghi） = a_bc_def_ghi
1143 StringUtil.toLowerCaseWithUnderscores（aBc def_ghi 123） = a_bc_def_ghi_123
1144 StringUtil.toLowerCaseWithUnderscores（__a__Bc__） = __a__bc__
1145 </pre>
1146 </p>
1147
1148 <p>
1149 此办保存除了空白以外的所有分隔符。
1150 </p>
1151
1152 ＠param str 要转换的字符串
1153
1154 ＠return 下划线分隔的小写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1155 /
1156 public static String toLowerCaseWithUnderscores（String str） {
1157 return LOWER_CASE_WITH_UNDERSCORES_TOKENIZER.parse（str）;
1158 }
1159
1160 / 解析单词的解析器。 /
1161 private static final WordTokenizer CAMEL_CASE_TOKENIZER = new WordTokenizer（） {
1162 protected void startSentence（
1163 StringBuffer buffer，
1164 char ch） {
1165 buffer
1166 .append（Character
1167 .toLowerCase（ch））;
1168 }
1169
1170 protected void startWord（
1171 StringBuffer buffer，
1172 char ch） {
1173 if （!isDelimiter（buffer
1174 .charAt（buffer
1175 .length（） - 1））） {
1176 buffer
1177 .append（Character
1178 .toUpperCase（ch））;
1179 } else {
1180 buffer
1181 .append（Character
1182 .toLowerCase（ch））;
1183 }
1184 }
1185
1186 protected void inWord（
1187 StringBuffer buffer，
1188 char ch） {
1189 buffer
1190 .append（Character
1191 .toLowerCase（ch））;
1192 }
1193
1194 protected void startDigitSentence（
1195 StringBuffer buffer，
1196 char ch） {
1197 buffer
1198 .append（ch）;
1199 }
1200
1201 protected void startDigitWord（
1202 StringBuffer buffer，
1203 char ch） {
1204 buffer
1205 .append（ch）;
1206 }
1207
1208 protected void inDigitWord（
1209 StringBuffer buffer，
1210 char ch） {
1211 buffer
1212 .append（ch）;
1213 }
1214
1215 protected void inDelimiter（
1216 StringBuffer buffer，
1217 char ch） {
1218 if （ch != UNDERSCORE） {
1219 buffer
1220 .append（ch）;
1221 }
1222 }
1223 };
1224
1225 private static final WordTokenizer PASCAL_CASE_TOKENIZER = new WordTokenizer（） {
1226 protected void startSentence（
1227 StringBuffer buffer，
1228 char ch） {
1229 buffer
1230 .append（Character
1231 .toUpperCase（ch））;
1232 }
1233
1234 protected void startWord（
1235 StringBuffer buffer，
1236 char ch） {
1237 buffer
1238 .append（Character
1239 .toUpperCase（ch））;
1240 }
1241
1242 protected void inWord（
1243 StringBuffer buffer，
1244 char ch） {
1245 buffer
1246 .append（Character
1247 .toLowerCase（ch））;
1248 }
1249
1250 protected void startDigitSentence（
1251 StringBuffer buffer，
1252 char ch） {
1253 buffer
1254 .append（ch）;
1255 }
1256
1257 protected void startDigitWord（
1258 StringBuffer buffer，
1259 char ch） {
1260 buffer
1261 .append（ch）;
1262 }
1263
1264 protected void inDigitWord（
1265 StringBuffer buffer，
1266 char ch） {
1267 buffer
1268 .append（ch）;
1269 }
1270
1271 protected void inDelimiter（
1272 StringBuffer buffer，
1273 char ch） {
1274 if （ch != UNDERSCORE） {
1275 buffer
1276 .append（ch）;
1277 }
1278 }
1279 };
1280
1281 private static final WordTokenizer UPPER_CASE_WITH_UNDERSCORES_TOKENIZER = new WordTokenizer（） {
1282 protected void startSentence（
1283 StringBuffer buffer，
1284 char ch） {
1285 buffer
1286 .append（Character
1287 .toUpperCase（ch））;
1288 }
1289
1290 protected void startWord（
1291 StringBuffer buffer，
1292 char ch） {
1293 if （!isDelimiter（buffer
1294 .charAt（buffer
1295 .length（） - 1））） {
1296 buffer
1297 .append（UNDERSCORE）;
1298 }
1299
1300 buffer
1301 .append（Character
1302 .toUpperCase（ch））;
1303 }
1304
1305 protected void inWord（
1306 StringBuffer buffer，
1307 char ch） {
1308 buffer
1309 .append（Character
1310 .toUpperCase（ch））;
1311 }
1312
1313 protected void startDigitSentence（
1314 StringBuffer buffer，
1315 char ch） {
1316 buffer
1317 .append（ch）;
1318 }
1319
1320 protected void startDigitWord（
1321 StringBuffer buffer，
1322 char ch） {
1323 if （!isDelimiter（buffer
1324 .charAt（buffer
1325 .length（） - 1））） {
1326 buffer
1327 .append（UNDERSCORE）;
1328 }
1329
1330 buffer
1331 .append（ch）;
1332 }
1333
1334 protected void inDigitWord（
1335 StringBuffer buffer，
1336 char ch） {
1337 buffer
1338 .append（ch）;
1339 }
1340
1341 protected void inDelimiter（
1342 StringBuffer buffer，
1343 char ch） {
1344 buffer
1345 .append（ch）;
1346 }
1347 };
1348
1349 private static final WordTokenizer LOWER_CASE_WITH_UNDERSCORES_TOKENIZER = new WordTokenizer（） {
1350 protected void startSentence（
1351 StringBuffer buffer，
1352 char ch） {
1353 buffer
1354 .append（Character
1355 .toLowerCase（ch））;
1356 }
1357
1358 protected void startWord（
1359 StringBuffer buffer，
1360 char ch） {
1361 if （!isDelimiter（buffer
1362 .charAt（buffer
1363 .length（） - 1））） {
1364 buffer
1365 .append（UNDERSCORE）;
1366 }
1367
1368 buffer
1369 .append（Character
1370 .toLowerCase（ch））;
1371 }
1372
1373 protected void inWord（
1374 StringBuffer buffer，
1375 char ch） {
1376 buffer
1377 .append（Character
1378 .toLowerCase（ch））;
1379 }
1380
1381 protected void startDigitSentence（
1382 StringBuffer buffer，
1383 char ch） {
1384 buffer
1385 .append（ch）;
1386 }
1387
1388 protected void startDigitWord（
1389 StringBuffer buffer，
1390 char ch） {
1391 if （!isDelimiter（buffer
1392 .charAt（buffer
1393 .length（） - 1））） {
1394 buffer
1395 .append（UNDERSCORE）;
1396 }
1397
1398 buffer
1399 .append（ch）;
1400 }
1401
1402 protected void inDigitWord（
1403 StringBuffer buffer，
1404 char ch） {
1405 buffer
1406 .append（ch）;
1407 }
1408
1409 protected void inDelimiter（
1410 StringBuffer buffer，
1411 char ch） {
1412 buffer
1413 .append（ch）;
1414 }
1415 };
1416
1417 /
1418 解析出下列语法所构成的<code>SENTENCE</code>。
1419 <pre>
1420 SENTENCE = WORD （DELIMITER WORD）
1421
1422 WORD = UPPER_CASE_WORD | LOWER_CASE_WORD | TITLE_CASE_WORD | DIGIT_WORD
1423
1424 UPPER_CASE_WORD = UPPER_CASE_LETTER+
1425 LOWER_CASE_WORD = LOWER_CASE_LETTER+
1426 TITLE_CASE_WORD = UPPER_CASE_LETTER LOWER_CASE_LETTER+
1427 DIGIT_WORD = DIGIT+
1428
1429 UPPER_CASE_LETTER = Character.isUpperCase（）
1430 LOWER_CASE_LETTER = Character.isLowerCase（）
1431 DIGIT = Character.isDigit（）
1432 NON_LETTER_DIGIT = !Character.isUpperCase（） && !Character.isLowerCase（） && !Character.isDigit（）
1433
1434 DELIMITER = WHITESPACE | NON_LETTER_DIGIT
1435 </pre>
1436 /
1437 private abstract static class WordTokenizer {
1438 protected static final char UNDERSCORE = _;
1439
1440 /
1441 Parse sentence。
1442 /
1443 public String parse（String str） {
1444 if （StringUtil.isEmpty（str）） {
1445 return str;
1446 }
1447
1448 int length = str.length（）;
1449 StringBuffer buffer = new StringBuffer（length）;
1450
1451 for （int index = 0; index < length; index++） {
1452 char ch = str.charAt（index）;
1453
1454 // 忽视空白。
1455 if （Character.isWhitespace（ch）） {
1456 continue;
1457 }
1458
1459 // 大写字母开端：UpperCaseWord或是TitleCaseWord。
1460 if （Character.isUpperCase（ch）） {
1461 int wordIndex = index + 1;
1462
1463 while （wordIndex < length） {
1464 char wordChar = str.charAt（wordIndex）;
1465
1466 if （Character.isUpperCase（wordChar）） {
1467 wordIndex++;
1468 } else if （Character.isLowerCase（wordChar）） {
1469 wordIndex--;
1470 break;
1471 } else {
1472 break;
1473 }
1474 }
1475
1476 // 1. wordIndex == length，申明最后一个字母为大写，以upperCaseWord处理惩罚之。
1477 // 2. wordIndex == index，申明index处为一个titleCaseWord。
1478 // 3. wordIndex > index，申明index到wordIndex - 1处全部是大写，以upperCaseWord处理惩罚。
1479 if （（wordIndex == length） || （wordIndex > index）） {
1480 index = parseUpperCaseWord（buffer， str， index， wordIndex）;
1481 } else {
1482 index = parseTitleCaseWord（buffer， str， index）;
1483 }
1484
1485 continue;
1486 }
1487
1488 // 小写字母开端：LowerCaseWord。
1489 if （Character.isLowerCase（ch）） {
1490 index = parseLowerCaseWord（buffer， str， index）;
1491 continue;
1492 }
1493
1494 // 数字开端：DigitWord。
1495 if （Character.isDigit（ch）） {
1496 index = parseDigitWord（buffer， str， index）;
1497 continue;
1498 }
1499
1500 // 非字母数字开端：Delimiter。
1501 inDelimiter（buffer， ch）;
1502 }
1503
1504 return buffer.toString（）;
1505 }
1506
1507 private int parseUpperCaseWord（StringBuffer buffer， String str， int index， int length） {
1508 char ch = str.charAt（index++）;
1509
1510 // 首字母，必定存在且为大写。
1511 if （buffer.length（） == 0） {
1512 startSentence（buffer， ch）;
1513 } else {
1514 startWord（buffer， ch）;
1515 }
1516
1517 // 后续字母，必为小写。
1518 for （; index < length; index++） {
1519 ch = str.charAt（index）;
1520 inWord（buffer， ch）;
1521 }
1522
1523 return index - 1;
1524 }
1525
1526 private int parseLowerCaseWord（StringBuffer buffer， String str， int index） {
1527 char ch = str.charAt（index++）;
1528
1529 // 首字母，必定存在且为小写。
1530 if （buffer.length（） == 0） {
1531 startSentence（buffer， ch）;
1532 } else {
1533 startWord（buffer， ch）;
1534 }
1535
1536 // 后续字母，必为小写。
1537 int length = str.length（）;
1538
1539 for （; index < length; index++） {
1540 ch = str.charAt（index）;
1541
1542 if （Character.isLowerCase（ch）） {
1543 inWord（buffer， ch）;
1544 } else {
1545 break;
1546 }
1547 }
1548
1549 return index - 1;
1550 }
1551
1552 private int parseTitleCaseWord（StringBuffer buffer， String str， int index） {
1553 char ch = str.charAt（index++）;
1554
1555 // 首字母，必定存在且为大写。
1556 if （buffer.length（） == 0） {
1557 startSentence（buffer， ch）;
1558 } else {
1559 startWord（buffer， ch）;
1560 }
1561
1562 // 后续字母，必为小写。
1563 int length = str.length（）;
1564
1565 for （; index < length; index++） {
1566 ch = str.charAt（index）;
1567
1568 if （Character.isLowerCase（ch）） {
1569 inWord（buffer， ch）;
1570 } else {
1571 break;
1572 }
1573 }
1574
1575 return index - 1;
1576 }
1577
1578 private int parseDigitWord（StringBuffer buffer， String str， int index） {
1579 char ch = str.charAt（index++）;
1580
1581 // 首字符，必定存在且为数字。
1582 if （buffer.length（） == 0） {
1583 startDigitSentence（buffer， ch）;
1584 } else {
1585 startDigitWord（buffer， ch）;
1586 }
1587
1588 // 后续字符，必为数字。
1589 int length = str.length（）;
1590
1591 for （; index < length; index++） {
1592 ch = str.charAt（index）;
1593
1594 if （Character.isDigit（ch）） {
1595 inDigitWord（buffer， ch）;
1596 } else {
1597 break;
1598 }
1599 }
1600
1601 return index - 1;
1602 }
1603
1604 protected boolean isDelimiter（char ch） {
1605 return !Character.isUpperCase（ch） && !Character.isLowerCase（ch）
1606 && !Character.isDigit（ch）;
1607 }
1608
1609 protected abstract void startSentence（StringBuffer buffer， char ch）;
1610
1611 protected abstract void startWord（StringBuffer buffer， char ch）;
1612
1613 protected abstract void inWord（StringBuffer buffer， char ch）;
1614
1615 protected abstract void startDigitSentence（StringBuffer buffer， char ch）;
1616
1617 protected abstract void startDigitWord（StringBuffer buffer， char ch）;
1618
1619 protected abstract void inDigitWord（StringBuffer buffer， char ch）;
1620
1621 protected abstract void inDelimiter（StringBuffer buffer， char ch）;
1622 }
1623
1624 / ============================================================================ /
1625 / 字符串分别函数。 /
1626 / /
1627 / 将字符串按指定分隔符分别。 /
1628 / ============================================================================ /
1629
1630 /
1631 将字符串按空白字符分别。
1632
1633 <p>
1634 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1635 <pre>
1636 StringUtil.split（null） = null
1637 StringUtil.split（） = []
1638 StringUtil.split（abc def） = [abc， def]
1639 StringUtil.split（abc def） = [abc， def]
1640 StringUtil.split（ abc ） = [abc]
1641 </pre>
1642 </p>
1643
1644 ＠param str 要分别的字符串
1645
1646 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1647 /
1648 public static String[] split（String str） {
1649 return split（str， null， -1）;
1650 }
1651
1652 /
1653 将字符串按指定字符分别。
1654
1655 <p>
1656 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1657 <pre>
1658 StringUtil.split（null， ） = null
1659 StringUtil.split（， ） = []
1660 StringUtil.split（a.b.c， .） = [a， b， c]
1661 StringUtil.split（a..b.c， .） = [a， b， c]
1662 StringUtil.split（a:b:c， .） = [a:b:c]
1663 StringUtil.split（a b c， ） = [a， b， c]
1664 </pre>
1665 </p>
1666
1667 ＠param str 要分别的字符串
1668 ＠param separatorChar 分隔符
1669
1670 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1671 /
1672 public static String[] split（String str， char separatorChar） {
1673 if （str == null） {
1674 return null;
1675 }
1676
1677 int length = str.length（）;
1678
1679 if （length == 0） {
1680 return ArrayUtil.EMPTY_STRING_ARRAY;
1681 }
1682
1683 List list = new ArrayList（）;
1684 int i = 0;
1685 int start = 0;
1686 boolean match = false;
1687
1688 while （i < length） {
1689 if （str.charAt（i） == separatorChar） {
1690 if （match） {
1691 list.add（str.substring（start， i））;
1692 match = false;
1693 }
1694
1695 start = ++i;
1696 continue;
1697 }
1698
1699 match = true;
1700 i++;
1701 }
1702
1703 if （match） {
1704 list.add（str.substring（start， i））;
1705 }
1706
1707 return （String[]） list.toArray（new String[list.size（）]）;
1708 }
1709
1710 /
1711 将字符串按指定字符分别。
1712
1713 <p>
1714 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1715 <pre>
1716 StringUtil.split（null， ） = null
1717 StringUtil.split（， ） = []
1718 StringUtil.split（abc def， null） = [abc， def]
1719 StringUtil.split（abc def， ） = [abc， def]
1720 StringUtil.split（abc def， ） = [abc， def]
1721 StringUtil.split（ ab: cd::ef ， :） = [ab， cd， ef]
1722 StringUtil.split（abc.def， ） = [abc.def]
1723 </pre>
1724 </p>
1725
1726 ＠param str 要分别的字符串
1727 ＠param separatorChars 分隔符
1728
1729 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1730 /
1731 public static String[] split（String str， String separatorChars） {
1732 return split（str， separatorChars， -1）;
1733 }
1734
1735 /
1736 将字符串按指定字符分别。
1737
1738 <p>
1739 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1740 <pre>
1741 StringUtil.split（null， ， ） = null
1742 StringUtil.split（， ， ） = []
1743 StringUtil.split（ab cd ef， null， 0） = [ab， cd， ef]
1744 StringUtil.split（ ab cd ef ， null， 0） = [ab， cd， ef]
1745 StringUtil.split（ab:cd::ef， :， 0） = [ab， cd， ef]
1746 StringUtil.split（ab:cd:ef， :， 2） = [ab， cdef]
1747 StringUtil.split（abc.def， ， 2） = [abc.def]
1748 </pre>
1749 </p>
1750
1751 ＠param str 要分别的字符串
1752 ＠param separatorChars 分隔符
1753 ＠param max 返回的数组的最大个数，若是小于便是0，则默示无穷制
1754
1755 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1756 /
1757 public static String[] split（String str， String separatorChars， int max） {
1758 if （str == null） {
1759 return null;
1760 }
1761
1762 int length = str.length（）;
1763
1764 if （length == 0） {
1765 return ArrayUtil.EMPTY_STRING_ARRAY;
1766 }
1767
1768 List list = new ArrayList（）;
1769 int sizePlus1 = 1;
1770 int i = 0;
1771 int start = 0;
1772 boolean match = false;
1773
1774 if （separatorChars == null） {
1775 // null默示应用空白作为分隔符
1776 while （i < length） {
1777 if （Character.isWhitespace（str.charAt（i））） {
1778 if （match） {
1779 if （sizePlus1++ == max） {
1780 i = length;
1781 }
1782
1783 list.add（str.substring（start， i））;
1784 match = false;
1785 }
1786
1787 start = ++i;
1788 continue;
1789 }
1790
1791 match = true;
1792 i++;
1793 }
1794 } else if （separatorChars.length（） == 1） {
1795 // 优化分隔符长度为1的景象
1796 char sep = separatorChars.charAt（0）;
1797
1798 while （i < length） {
1799 if （str.charAt（i） == sep） {
1800 if （match） {
1801 if （sizePlus1++ == max） {
1802 i = length;
1803 }
1804
1805 list.add（str.substring（start， i））;
1806 match = false;
1807 }
1808
1809 start = ++i;
1810 continue;
1811 }
1812
1813 match = true;
1814 i++;
1815 }
1816 } else {
1817 // 一般景象
1818 while （i < length） {
1819 if （separatorChars.indexOf（str.charAt（i）） >= 0） {
1820 if （match） {
1821 if （sizePlus1++ == max） {
1822 i = length;
1823 }
1824
1825 list.add（str.substring（start， i））;
1826 match = false;
1827 }
1828
1829 start = ++i;
1830 continue;
1831 }
1832
1833 match = true;
1834 i++;
1835 }
1836 }
1837
1838 if （match） {
1839 list.add（str.substring（start， i））;
1840 }
1841
1842 return （String[]） list.toArray（new String[list.size（）]）;
1843 }
1844
1845 / ============================================================================ /
1846 / 字符串连接函数。 /
1847 / /
1848 / 将多个对象按指定分隔符连接成字符串。 /
1849 / ============================================================================ /
1850
1851 /
1852 将数组中的元素连接成一个字符串。
1853 <pre>
1854 StringUtil.join（null） = null
1855 StringUtil.join（[]） =
1856 StringUtil.join（[null]） =
1857 StringUtil.join（[a， b， c]） = abc
1858 StringUtil.join（[null， ， a]） = a
1859 </pre>
1860
1861 ＠param array 要连接的数组
1862
1863 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1864 /
1865 public static String join（Object[] array） {
1866 return join（array， null）;
1867 }
1868
1869 /
1870 将数组中的元素连接成一个字符串。
1871 <pre>
1872 StringUtil.join（null， ） = null
1873 StringUtil.join（[]， ） =
1874 StringUtil.join（[null]， ） =
1875 StringUtil.join（[a， b， c]， ;） = a;b;c
1876 StringUtil.join（[a， b， c]， null） = abc
1877 StringUtil.join（[null， ， a]， ;） = ;;a
1878 </pre>
1879
1880 ＠param array 要连接的数组
1881 ＠param separator 分隔符
1882
1883 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1884 /
1885 public static String join（Object[] array， char separator） {
1886 if （array == null） {
1887 return null;
1888 }
1889
1890 int arraySize = array.length;
1891 int bufSize = （arraySize == 0） ？ 0 : （（（（array[0] == null） ？ 16 : array[0].toString（）
1892 .length（）） + 1） arraySize）;
1893 StringBuffer buf = new StringBuffer（bufSize）;
1894
1895 for （int i = 0; i < arraySize; i++） {
1896 if （i > 0） {
1897 buf.append（separator）;
1898 }
1899
1900 if （array[i] != null） {
1901 buf.append（array[i]）;
1902 }
1903 }
1904
1905 return buf.toString（）;
1906 }
1907
1908 /
1909 将数组中的元素连接成一个字符串。
1910 <pre>
1911 StringUtil.join（null， ） = null
1912 StringUtil.join（[]， ） =
1913 StringUtil.join（[null]， ） =
1914 StringUtil.join（[a， b， c]， --） = a--b--c
1915 StringUtil.join（[a， b， c]， null） = abc
1916 StringUtil.join（[a， b， c]， ） = abc
1917 StringUtil.join（[null， ， a]， ，） = ，，a
1918 </pre>
1919
1920 ＠param array 要连接的数组
1921 ＠param separator 分隔符
1922
1923 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1924 /
1925 public static String join（Object[] array， String separator） {
1926 if （array == null） {
1927 return null;
1928 }
1929
1930 if （separator == null） {
1931 separator = EMPTY_STRING;
1932 }
1933
1934 int arraySize = array.length;
1935
1936 // ArraySize == 0: Len = 0
1937 // ArraySize > 0: Len = NofStrings （len（firstString） + len（separator））
1938 // （估计大约所有的字符串都一样长）
1939 int bufSize = （arraySize == 0） ？ 0 : （arraySize （（（array[0] == null） ？ 16 : array[0]
1940 .toString（）.length（）） + （（separator != null） ？ separator.length（） : 0）））;
1941
1942 StringBuffer buf = new StringBuffer（bufSize）;
1943
1944 for （int i = 0; i < arraySize; i++） {
1945 if （（separator != null） && （i > 0）） {
1946 buf.append（separator）;
1947 }
1948
1949 if （array[i] != null） {
1950 buf.append（array[i]）;
1951 }
1952 }
1953
1954 return buf.toString（）;
1955 }
1956
1957 /
1958 将<code>Iterator</code>中的元素连接成一个字符串。
1959 <pre>
1960 StringUtil.join（null， ） = null
1961 StringUtil.join（[]， ） =
1962 StringUtil.join（[null]， ） =
1963 StringUtil.join（[a， b， c]， --） = a--b--c
1964 StringUtil.join（[a， b， c]， null） = abc
1965 StringUtil.join（[a， b， c]， ） = abc
1966 StringUtil.join（[null， ， a]， ，） = ，，a
1967 </pre>
1968
1969 ＠param iterator 要连接的<code>Iterator</code>
1970 ＠param separator 分隔符
1971
1972 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1973 /
1974 public static String join（Iterator iterator， char separator） {
1975 if （iterator == null） {
1976 return null;
1977 }
1978
1979 StringBuffer buf = new StringBuffer（256）; // Java默认值是16， 可能偏小
1980
1981 while （iterator.hasNext（）） {
1982 Object obj = iterator.next（）;
1983
1984 if （obj != null） {
1985 buf.append（obj）;
1986 }
1987
1988 if （iterator.hasNext（）） {
1989 buf.append（separator）;
1990 }
1991 }
1992
1993 return buf.toString（）;
1994 }
1995
1996 /
1997 将<code>Iterator</code>中的元素连接成一个字符串。
1998 <pre>
1999 StringUtil.join（null， ） = null
2000 StringUtil.join（[]， ） =
2001 StringUtil.join（[null]， ） =
2002 StringUtil.join（[a， b， c]， --） = a--b--c
2003 StringUtil.join（[a， b， c]， null） = abc
2004 StringUtil.join（[a， b， c]， ） = abc
2005 StringUtil.join（[null， ， a]， ，） = ，，a
2006 </pre>
2007
2008 ＠param iterator 要连接的<code>Iterator</code>
2009 ＠param separator 分隔符
2010
2011 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
2012 /
2013 public static String join（Iterator iterator， String separator） {
2014 if （iterator == null） {
2015 return null;
2016 }
2017
2018 StringBuffer buf = new StringBuffer（256）; // Java默认值是16， 可能偏小
2019
2020 while （iterator.hasNext（）） {
2021 Object obj = iterator.next（）;
2022
2023 if （obj != null） {
2024 buf.append（obj）;
2025 }
2026
2027 if （（separator != null） && iterator.hasNext（）） {
2028 buf.append（separator）;
2029 }
2030 }
2031
2032 return buf.toString（）;
2033 }
2034
2035 / ============================================================================ /
2036 / 字符串查找函数 —— 字符或字符串。 /
2037 / /
2038 / 在字符串中查找指定字符或字符串。 /
2039 / ============================================================================ /
2040
2041 /
2042 在字符串中查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2043 <pre>
2044 StringUtil.indexOf（null， ） = -1
2045 StringUtil.indexOf（， ） = -1
2046 StringUtil.indexOf（aabaabaa， a） = 0
2047 StringUtil.indexOf（aabaabaa， b） = 2
2048 </pre>
2049
2050 ＠param str 要扫描的字符串
2051 ＠param searchChar 要查找的字符
2052
2053 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2054 /
2055 public static int indexOf（String str， char searchChar） {
2056 if （（str == null） || （str.length（） == 0）） {
2057 return -1;
2058 }
2059
2060 return str.indexOf（searchChar）;
2061 }
2062
2063 /
2064 在字符串中查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2065 <pre>
2066 StringUtil.indexOf（null， ， ） = -1
2067 StringUtil.indexOf（， ， ） = -1
2068 StringUtil.indexOf（aabaabaa， b， 0） = 2
2069 StringUtil.indexOf（aabaabaa， b， 3） = 5
2070 StringUtil.indexOf（aabaabaa， b， 9） = -1
2071 StringUtil.indexOf（aabaabaa， b， -1） = 2
2072 </pre>
2073
2074 ＠param str 要扫描的字符串
2075 ＠param searchChar 要查找的字符
2076 ＠param startPos 开端搜刮的索引值，若是小于0，则看作0
2077
2078 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2079 /
2080 public static int indexOf（String str， char searchChar， int startPos） {
2081 if （（str == null） || （str.length（） == 0）） {
2082 return -1;
2083 }
2084
2085 return str.indexOf（searchChar， startPos）;
2086 }
2087
2088 /
2089 在字符串中查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2090 <pre>
2091 StringUtil.indexOf（null， ） = -1
2092 StringUtil.indexOf（， null） = -1
2093 StringUtil.indexOf（， ） = 0
2094 StringUtil.indexOf（aabaabaa， a） = 0
2095 StringUtil.indexOf（aabaabaa， b） = 2
2096 StringUtil.indexOf（aabaabaa， ab） = 1
2097 StringUtil.indexOf（aabaabaa， ） = 0
2098 </pre>
2099
2100 ＠param str 要扫描的字符串
2101 ＠param searchStr 要查找的字符串
2102
2103 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2104 /
2105 public static int indexOf（String str， String searchStr） {
2106 if （（str == null） || （searchStr == null）） {
2107 return -1;
2108 }
2109
2110 return str.indexOf（searchStr）;
2111 }
2112
2113 /
2114 在字符串中查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2115 <pre>
2116 StringUtil.indexOf（null， ， ） = -1
2117 StringUtil.indexOf（， null， ） = -1
2118 StringUtil.indexOf（， ， 0） = 0
2119 StringUtil.indexOf（aabaabaa， a， 0） = 0
2120 StringUtil.indexOf（aabaabaa， b， 0） = 2
2121 StringUtil.indexOf（aabaabaa， ab， 0） = 1
2122 StringUtil.indexOf（aabaabaa， b， 3） = 5
2123 StringUtil.indexOf（aabaabaa， b， 9） = -1
2124 StringUtil.indexOf（aabaabaa， b， -1） = 2
2125 StringUtil.indexOf（aabaabaa， ， 2） = 2
2126 StringUtil.indexOf（abc， ， 9） = 3
2127 </pre>
2128
2129 ＠param str 要扫描的字符串
2130 ＠param searchStr 要查找的字符串
2131 ＠param startPos 开端搜刮的索引值，若是小于0，则看作0
2132
2133 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2134 /
2135 public static int indexOf（String str， String searchStr， int startPos） {
2136 if （（str == null） || （searchStr == null）） {
2137 return -1;
2138 }
2139
2140 // JDK1.3及以下版本的bug：不克不及正确处理惩罚下面的景象
2141 if （（searchStr.length（） == 0） && （startPos >= str.length（））） {
2142 return str.length（）;
2143 }
2144
2145 return str.indexOf（searchStr， startPos）;
2146 }
2147
2148 /
2149 在字符串中查找指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2150 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2151 <pre>
2152 StringUtil.indexOfAny（null， ） = -1
2153 StringUtil.indexOfAny（， ） = -1
2154 StringUtil.indexOfAny（， null） = -1
2155 StringUtil.indexOfAny（， []） = -1
2156 StringUtil.indexOfAny（zzabyycdxx，[z，a]） = 0
2157 StringUtil.indexOfAny（zzabyycdxx，[b，y]） = 3
2158 StringUtil.indexOfAny（aba， [z]） = -1
2159 </pre>
2160
2161 ＠param str 要扫描的字符串
2162 ＠param searchChars 要搜刮的字符凑集
2163
2164 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2165 /
2166 public static int indexOfAny（String str， char[] searchChars） {
2167 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2168 || （searchChars.length == 0）） {
2169 return -1;
2170 }
2171
2172 for （int i = 0; i < str.length（）; i++） {
2173 char ch = str.charAt（i）;
2174
2175 for （int j = 0; j < searchChars.length; j++） {
2176 if （searchChars[j] == ch） {
2177 return i;
2178 }
2179 }
2180 }
2181
2182 return -1;
2183 }
2184
2185 /
2186 在字符串中查找指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2187 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2188 <pre>
2189 StringUtil.indexOfAny（null， ） = -1
2190 StringUtil.indexOfAny（， ） = -1
2191 StringUtil.indexOfAny（， null） = -1
2192 StringUtil.indexOfAny（， ） = -1
2193 StringUtil.indexOfAny（zzabyycdxx， za） = 0
2194 StringUtil.indexOfAny（zzabyycdxx， by） = 3
2195 StringUtil.indexOfAny（aba，z） = -1
2196 </pre>
2197
2198 ＠param str 要扫描的字符串
2199 ＠param searchChars 要搜刮的字符凑集
2200
2201 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2202 /
2203 public static int indexOfAny（String str， String searchChars） {
2204 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2205 || （searchChars.length（） == 0）） {
2206 return -1;
2207 }
2208
2209 for （int i = 0; i < str.length（）; i++） {
2210 char ch = str.charAt（i）;
2211
2212 for （int j = 0; j < searchChars.length（）; j++） {
2213 if （searchChars.charAt（j） == ch） {
2214 return i;
2215 }
2216 }
2217 }
2218
2219 return -1;
2220 }
2221
2222 /
2223 在字符串中查找指定字符串凑集中的字符串，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2224 若是字符串凑集为<code>null</code>或空，也返回<code>-1</code>。
2225 若是字符串凑集包含<code></code>，并且字符串不为<code>null</code>，则返回<code>str.length（）</code>
2226 <pre>
2227 StringUtil.indexOfAny（null， ） = -1
2228 StringUtil.indexOfAny（， null） = -1
2229 StringUtil.indexOfAny（， []） = -1
2230 StringUtil.indexOfAny（zzabyycdxx， [ab，cd]） = 2
2231 StringUtil.indexOfAny（zzabyycdxx， [cd，ab]） = 2
2232 StringUtil.indexOfAny（zzabyycdxx， [mn，op]） = -1
2233 StringUtil.indexOfAny（zzabyycdxx， [zab，aby]） = 1
2234 StringUtil.indexOfAny（zzabyycdxx， []） = 0
2235 StringUtil.indexOfAny（， []） = 0
2236 StringUtil.indexOfAny（， [a]） = -1
2237 </pre>
2238
2239 ＠param str 要扫描的字符串
2240 ＠param searchStrs 要搜刮的字符串凑集
2241
2242 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2243 /
2244 public static int indexOfAny（String str， String[] searchStrs） {
2245 if （（str == null） || （searchStrs == null）） {
2246 return -1;
2247 }
2248
2249 int sz = searchStrs.length;
2250
2251 // Strings cant have a MAX_VALUEth index.
2252 int ret = Integer.MAX_VALUE;
2253
2254 int tmp = 0;
2255
2256 for （int i = 0; i < sz; i++） {
2257 String search = searchStrs[i];
2258
2259 if （search == null） {
2260 continue;
2261 }
2262
2263 tmp = str.indexOf（search）;
2264
2265 if （tmp == -1） {
2266 continue;
2267 }
2268
2269 if （tmp < ret） {
2270 ret = tmp;
2271 }
2272 }
2273
2274 return （ret == Integer.MAX_VALUE） ？ （-1） : ret;
2275 }
2276
2277 /
2278 在字符串中查找不在指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2279 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2280 <pre>
2281 StringUtil.indexOfAnyBut（null， ） = -1
2282 StringUtil.indexOfAnyBut（， ） = -1
2283 StringUtil.indexOfAnyBut（， null） = -1
2284 StringUtil.indexOfAnyBut（， []） = -1
2285 StringUtil.indexOfAnyBut（zzabyycdxx，za） = 3
2286 StringUtil.indexOfAnyBut（zzabyycdxx， by） = 0
2287 StringUtil.indexOfAnyBut（aba， ab） = -1
2288 </pre>
2289
2290 ＠param str 要扫描的字符串
2291 ＠param searchChars 要搜刮的字符凑集
2292
2293 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2294 /
2295 public static int indexOfAnyBut（String str， char[] searchChars） {
2296 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2297 || （searchChars.length == 0）） {
2298 return -1;
2299 }
2300
2301 outer: for （int i = 0; i < str.length（）; i++） {
2302 char ch = str.charAt（i）;
2303
2304 for （int j = 0; j < searchChars.length; j++） {
2305 if （searchChars[j] == ch） {
2306 continue outer;
2307 }
2308 }
2309
2310 return i;
2311 }
2312
2313 return -1;
2314 }
2315
2316 /
2317 在字符串中查找不在指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2318 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2319 <pre>
2320 StringUtil.indexOfAnyBut（null， ） = -1
2321 StringUtil.indexOfAnyBut（， ） = -1
2322 StringUtil.indexOfAnyBut（， null） = -1
2323 StringUtil.indexOfAnyBut（， ） = -1
2324 StringUtil.indexOfAnyBut（zzabyycdxx， za） = 3
2325 StringUtil.indexOfAnyBut（zzabyycdxx， by） = 0
2326 StringUtil.indexOfAnyBut（aba，ab） = -1
2327 </pre>
2328
2329 ＠param str 要扫描的字符串
2330 ＠param searchChars 要搜刮的字符凑集
2331
2332 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2333 /
2334 public static int indexOfAnyBut（String str， String searchChars） {
2335 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2336 || （searchChars.length（） == 0）） {
2337 return -1;
2338 }
2339
2340 for （int i = 0; i < str.length（）; i++） {
2341 if （searchChars.indexOf（str.charAt（i）） < 0） {
2342 return i;
2343 }
2344 }
2345
2346 return -1;
2347 }
2348
2349 /
2350 从字符串尾部开端查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2351 <pre>
2352 StringUtil.lastIndexOf（null， ） = -1
2353 StringUtil.lastIndexOf（， ） = -1
2354 StringUtil.lastIndexOf（aabaabaa， a） = 7
2355 StringUtil.lastIndexOf（aabaabaa， b） = 5
2356 </pre>
2357
2358 ＠param str 要扫描的字符串
2359 ＠param searchChar 要查找的字符
2360
2361 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2362 /
2363 public static int lastIndexOf（String str， char searchChar） {
2364 if （（str == null） || （str.length（） == 0）） {
2365 return -1;
2366 }
2367
2368 return str.lastIndexOf（searchChar）;
2369 }
2370
2371 /
2372 从字符串尾部开端查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2373 <pre>
2374 StringUtil.lastIndexOf（null， ， ） = -1
2375 StringUtil.lastIndexOf（， ， ） = -1
2376 StringUtil.lastIndexOf（aabaabaa， b， 8） = 5
2377 StringUtil.lastIndexOf（aabaabaa， b， 4） = 2
2378 StringUtil.lastIndexOf（aabaabaa， b， 0） = -1
2379 StringUtil.lastIndexOf（aabaabaa， b， 9） = 5
2380 StringUtil.lastIndexOf（aabaabaa， b， -1） = -1
2381 StringUtil.lastIndexOf（aabaabaa， a， 0） = 0
2382 </pre>
2383
2384 ＠param str 要扫描的字符串
2385 ＠param searchChar 要查找的字符
2386 ＠param startPos 从指定索引开端向前搜刮
2387
2388 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2389 /
2390 public static int lastIndexOf（String str， char searchChar， int startPos） {
2391 if （（str == null） || （str.length（） == 0）） {
2392 return -1;
2393 }
2394
2395 return str.lastIndexOf（searchChar， startPos）;
2396 }
2397
2398 /
2399 从字符串尾部开端查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2400 <pre>
2401 StringUtil.lastIndexOf（null， ） = -1
2402 StringUtil.lastIndexOf（， ） = -1
2403 StringUtil.lastIndexOf（aabaabaa， a） = 7
2404 StringUtil.lastIndexOf（aabaabaa， b） = 5
2405 </pre>
2406
2407 ＠param str 要扫描的字符串
2408 ＠param searchStr 要查找的字符串
2409
2410 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2411 /
2412 public static int lastIndexOf（String str， String searchStr） {
2413 if （（str == null） || （searchStr == null）） {
2414 return -1;
2415 }
2416
2417 return str.lastIndexOf（searchStr）;
2418 }
2419
2420 /
2421 从字符串尾部开端查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2422 <pre>
2423 StringUtil.lastIndexOf（null， ， ） = -1
2424 StringUtil.lastIndexOf（， null， ） = -1
2425 StringUtil.lastIndexOf（aabaabaa， a， 8） = 7
2426 StringUtil.lastIndexOf（aabaabaa， b， 8） = 5
2427 StringUtil.lastIndexOf（aabaabaa， ab， 8） = 4
2428 StringUtil.lastIndexOf（aabaabaa， b， 9） = 5
2429 StringUtil.lastIndexOf（aabaabaa， b， -1） = -1
2430 StringUtil.lastIndexOf（aabaabaa， a， 0） = 0
2431 StringUtil.lastIndexOf（aabaabaa， b， 0） = -1
2432 </pre>
2433
2434 ＠param str 要扫描的字符串
2435 ＠param searchStr 要查找的字符串
2436 ＠param startPos 从指定索引开端向前搜刮
2437
2438 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2439 /
2440 public static int lastIndexOf（String str， String searchStr， int startPos） {
2441 if （（str == null） || （searchStr == null）） {
2442 return -1;
2443 }
2444
2445 return str.lastIndexOf（searchStr， startPos）;
2446 }
2447
2448 /
2449 从字符串尾部开端查找指定字符串凑集中的字符串，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2450 若是字符串凑集为<code>null</code>或空，也返回<code>-1</code>。
2451 若是字符串凑集包含<code></code>，并且字符串不为<code>null</code>，则返回<code>str.length（）</code>
2452 <pre>
2453 StringUtil.lastIndexOfAny（null， ） = -1
2454 StringUtil.lastIndexOfAny（， null） = -1
2455 StringUtil.lastIndexOfAny（， []） = -1
2456 StringUtil.lastIndexOfAny（， [null]） = -1
2457 StringUtil.lastIndexOfAny（zzabyycdxx， [ab，cd]） = 6
2458 StringUtil.lastIndexOfAny（zzabyycdxx， [cd，ab]） = 6
2459 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，op]） = -1
2460 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，op]） = -1
2461 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，]） = 10
2462 </pre>
2463
2464 ＠param str 要扫描的字符串
2465 ＠param searchStrs 要搜刮的字符串凑集
2466
2467 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2468 /
2469 public static int lastIndexOfAny（String str， String[] searchStrs） {
2470 if （（str == null） || （searchStrs == null）） {
2471 return -1;
2472 }
2473
2474 int searchStrsLength = searchStrs.length;
2475 int index = -1;
2476 int tmp = 0;
2477
2478 for （int i = 0; i < searchStrsLength; i++） {
2479 String search = searchStrs[i];
2480
2481 if （search == null） {
2482 continue;
2483 }
2484
2485 tmp = str.lastIndexOf（search）;
2486
2487 if （tmp > index） {
2488 index = tmp;
2489 }
2490 }
2491
2492 return index;
2493 }
2494
2495 /
2496 搜检字符串中是否包含指定的字符。若是字符串为<code>null</code>，将返回<code>false</code>。
2497 <pre>
2498 StringUtil.contains（null， ） = false
2499 StringUtil.contains（， ） = false
2500 StringUtil.contains（abc， a） = true
2501 StringUtil.contains（abc， z） = false
2502 </pre>
2503
2504 ＠param str 要扫描的字符串
2505 ＠param searchChar 要查找的字符
2506
2507 ＠return 若是找到，则返回<code>true</code>
2508 /
2509 public static boolean contains（String str， char searchChar） {
2510 if （（str == null） || （str.length（） == 0）） {
2511 return false;
2512 }
2513
2514 return str.indexOf（searchChar） >= 0;
2515 }
2516
2517 /
2518 搜检字符串中是否包含指定的字符串。若是字符串为<code>null</code>，将返回<code>false</code>。
2519 <pre>
2520 StringUtil.contains（null， ） = false
2521 StringUtil.contains（， null） = false
2522 StringUtil.contains（， ） = true
2523 StringUtil.contains（abc， ） = true
2524 StringUtil.contains（abc， a） = true
2525 StringUtil.contains（abc， z） = false
2526 </pre>
2527
2528 ＠param str 要扫描的字符串
2529 ＠param searchStr 要查找的字符串
2530
2531 ＠return 若是找到，则返回<code>true</code>
2532 /
2533 public static boolean contains（String str， String searchStr） {
2534 if （（str == null） || （searchStr == null）） {
2535 return false;
2536 }
2537
2538 return str.indexOf（searchStr） >= 0;
2539 }
2540
2541 /
2542 搜检字符串是是否只包含指定字符凑集中的字符。
2543
2544 <p>
2545 若是字符串为<code>null</code>，则返回<code>false</code>。
2546 若是字符凑集为<code>null</code>则返回<code>false</code>。 然则空字符串永远返回<code>true</code>.
2547 </p>
2548 <pre>
2549 StringUtil.containsOnly（null， ） = false
2550 StringUtil.containsOnly（， null） = false
2551 StringUtil.containsOnly（， ） = true
2552 StringUtil.containsOnly（ab， ） = false
2553 StringUtil.containsOnly（abab， abc） = true
2554 StringUtil.containsOnly（ab1， abc） = false
2555 StringUtil.containsOnly（abz， abc） = false
2556 </pre>
2557
2558 ＠param str 要扫描的字符串
2559 ＠param valid 要查找的字符串
2560
2561 ＠return 若是找到，则返回<code>true</code>
2562 /
2563 public static boolean containsOnly（String str， char[] valid） {
2564 if （（valid == null） || （str == null）） {
2565 return false;
2566 }
2567
2568 if （str.length（） == 0） {
2569 return true;
2570 }
2571
2572 if （valid.length == 0） {
2573 return false;
2574 }
2575
2576 return indexOfAnyBut（str， valid） == -1;
2577 }
2578
2579 /
2580 搜检字符串是是否只包含指定字符凑集中的字符。
2581
2582 <p>
2583 若是字符串为<code>null</code>，则返回<code>false</code>。
2584 若是字符凑集为<code>null</code>则返回<code>false</code>。 然则空字符串永远返回<code>true</code>.
2585 </p>
2586 <pre>
2587 StringUtil.containsOnly（null， ） = false
2588 StringUtil.containsOnly（， null） = false
2589 StringUtil.containsOnly（， ） = true
2590 StringUtil.containsOnly（ab， ） = false
2591 StringUtil.containsOnly（abab， abc） = true
2592 StringUtil.containsOnly（ab1， abc） = false
2593 StringUtil.containsOnly（abz， abc） = false
2594 </pre>
2595
2596 ＠param str 要扫描的字符串
2597 ＠param valid 要查找的字符串
2598
2599 ＠return 若是找到，则返回<code>true</code>
2600 /
2601 public static boolean containsOnly（String str， String valid） {
2602 if （（str == null） || （valid == null）） {
2603 return false;
2604 }
2605
2606 return containsOnly（str， valid.toCharArray（））;
2607 }
2608
2609 /
2610 搜检字符串是是否不包含指定字符凑集中的字符。
2611
2612 <p>
2613 若是字符串为<code>null</code>，则返回<code>false</code>。 若是字符凑集为<code>null</code>则返回<code>true</code>。
2614 然则空字符串永远返回<code>true</code>.
2615 </p>
2616 <pre>
2617 StringUtil.containsNone（null， ） = true
2618 StringUtil.containsNone（， null） = true
2619 StringUtil.containsNone（， ） = true
2620 StringUtil.containsNone（ab， ） = true
2621 StringUtil.containsNone（abab， xyz） = true
2622 StringUtil.containsNone（ab1， xyz） = true
2623 StringUtil.containsNone（abz， xyz） = false
2624 </pre>
2625
2626 ＠param str 要扫描的字符串
2627 ＠param invalid 要查找的字符串
2628
2629 ＠return 若是找到，则返回<code>true</code>
2630 /
2631 public static boolean containsNone（String str， char[] invalid） {
2632 if （（str == null） || （invalid == null）） {
2633 return true;
2634 }
2635
2636 int strSize = str.length（）;
2637 int validSize = invalid.length;
2638
2639 for （int i = 0; i < strSize; i++） {
2640 char ch = str.charAt（i）;
2641
2642 for （int j = 0; j < validSize; j++） {
2643 if （invalid[j] == ch） {
2644 return false;
2645 }
2646 }
2647 }
2648
2649 return true;
2650 }
2651
2652 /
2653 搜检字符串是是否不包含指定字符凑集中的字符。
2654
2655 <p>
2656 若是字符串为<code>null</code>，则返回<code>false</code>。 若是字符凑集为<code>null</code>则返回<code>true</code>。
2657 然则空字符串永远返回<code>true</code>.
2658 </p>
2659 <pre>
2660 StringUtil.containsNone（null， ） = true
2661 StringUtil.containsNone（， null） = true
2662 StringUtil.containsNone（， ） = true
2663 StringUtil.containsNone（ab， ） = true
2664 StringUtil.containsNone（abab， xyz） = true
2665 StringUtil.containsNone（ab1， xyz） = true
2666 StringUtil.containsNone（abz， xyz） = false
2667 </pre>
2668
2669 ＠param str 要扫描的字符串
2670 ＠param invalidChars 要查找的字符串
2671
2672 ＠return 若是找到，则返回<code>true</code>
2673 /
2674 public static boolean containsNone（String str， String invalidChars） {
2675 if （（str == null） || （invalidChars == null）） {
2676 return true;
2677 }
2678
2679 return containsNone（str， invalidChars.toCharArray（））;
2680 }
2681
2682 /
2683 取得指定子串在字符串中呈现的次数。
2684
2685 <p>
2686 若是字符串为<code>null</code>或空，则返回<code>0</code>。
2687 <pre>
2688 StringUtil.countMatches（null， ） = 0
2689 StringUtil.countMatches（， ） = 0
2690 StringUtil.countMatches（abba， null） = 0
2691 StringUtil.countMatches（abba， ） = 0
2692 StringUtil.countMatches（abba， a） = 2
2693 StringUtil.countMatches（abba， ab） = 1
2694 StringUtil.countMatches（abba， xxx） = 0
2695 </pre>
2696 </p>
2697
2698 ＠param str 要扫描的字符串
2699 ＠param subStr 子字符串
2700
2701 ＠return 子串在字符串中呈现的次数，若是字符串为<code>null</code>或空，则返回<code>0</code>
2702 /
2703 public static int countMatches（String str， String subStr） {
2704 if （（str == null） || （str.length（） == 0） || （subStr == null） || （subStr.length（） == 0）） {
2705 return 0;
2706 }
2707
2708 int count = 0;
2709 int index = 0;
2710
2711 while （（index = str.indexOf（subStr， index）） != -1） {
2712 count++;
2713 index += subStr.length（）;
2714 }
2715
2716 return count;
2717 }
2718
2719 / ============================================================================ /
2720 / 取子串函数。 /
2721 / ============================================================================ /
2722
2723 /
2724 取指定字符串的子串。
2725
2726 <p>
2727 负的索引代表从尾部开端策画。若是字符串为<code>null</code>，则返回<code>null</code>。
2728 <pre>
2729 StringUtil.substring（null， ） = null
2730 StringUtil.substring（， ） =
2731 StringUtil.substring（abc， 0） = abc
2732 StringUtil.substring（abc， 2） = c
2733 StringUtil.substring（abc， 4） =
2734 StringUtil.substring（abc， -2） = bc
2735 StringUtil.substring（abc， -4） = abc
2736 </pre>
2737 </p>
2738
2739 ＠param str 字符串
2740 ＠param start 肇端索引，若是为负数，默示从尾部查找
2741
2742 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2743 /
2744 public static String substring（String str， int start） {
2745 if （str == null） {
2746 return null;
2747 }
2748
2749 if （start < 0） {
2750 start = str.length（） + start;
2751 }
2752
2753 if （start < 0） {
2754 start = 0;
2755 }
2756
2757 if （start > str.length（）） {
2758 return EMPTY_STRING;
2759 }
2760
2761 return str.substring（start）;
2762 }
2763
2764 /
2765 取指定字符串的子串。
2766
2767 <p>
2768 负的索引代表从尾部开端策画。若是字符串为<code>null</code>，则返回<code>null</code>。
2769 <pre>
2770 StringUtil.substring（null， ， ） = null
2771 StringUtil.substring（， ， ） = ;
2772 StringUtil.substring（abc， 0， 2） = ab
2773 StringUtil.substring（abc， 2， 0） =
2774 StringUtil.substring（abc， 2， 4） = c
2775 StringUtil.substring（abc， 4， 6） =
2776 StringUtil.substring（abc， 2， 2） =
2777 StringUtil.substring（abc， -2， -1） = b
2778 StringUtil.substring（abc， -4， 2） = ab
2779 </pre>
2780 </p>
2781
2782 ＠param str 字符串
2783 ＠param start 肇端索引，若是为负数，默示从尾部策画
2784 ＠param end 停止索引（不含），若是为负数，默示从尾部策画
2785
2786 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2787 /
2788 public static String substring（String str， int start， int end） {
2789 if （str == null） {
2790 return null;
2791 }
2792
2793 if （end < 0） {
2794 end = str.length（） + end;
2795 }
2796
2797 if （start < 0） {
2798 start = str.length（） + start;
2799 }
2800
2801 if （end > str.length（）） {
2802 end = str.length（）;
2803 }
2804
2805 if （start > end） {
2806 return EMPTY_STRING;
2807 }
2808
2809 if （start < 0） {
2810 start = 0;
2811 }
2812
2813 if （end < 0） {
2814 end = 0;
2815 }
2816
2817 return str.substring（start， end）;
2818 }
2819
2820 /
2821 取得长度为指定字符数的最左边的子串。
2822 <pre>
2823 StringUtil.left（null， ） = null
2824 StringUtil.left（， -ve） =
2825 StringUtil.left（， ） =
2826 StringUtil.left（abc， 0） =
2827 StringUtil.left（abc， 2） = ab
2828 StringUtil.left（abc， 4） = abc
2829 </pre>
2830
2831 ＠param str 字符串
2832 ＠param len 最左子串的长度
2833
2834 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2835 /
2836 public static String left（String str， int len） {
2837 if （str == null） {
2838 return null;
2839 }
2840
2841 if （len < 0） {
2842 return EMPTY_STRING;
2843 }
2844
2845 if （str.length（） <= len） {
2846 return str;
2847 } else {
2848 return str.substring（0， len）;
2849 }
2850 }
2851
2852 /
2853 取得长度为指定字符数的最右边的子串。
2854 <pre>
2855 StringUtil.right（null， ） = null
2856 StringUtil.right（， -ve） =
2857 StringUtil.right（， ） =
2858 StringUtil.right（abc， 0） =
2859 StringUtil.right（abc， 2） = bc
2860 StringUtil.right（abc， 4） = abc
2861 </pre>
2862
2863 ＠param str 字符串
2864 ＠param len 最右子串的长度
2865
2866 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2867 /
2868 public static String right（String str， int len） {
2869 if （str == null） {
2870 return null;
2871 }
2872
2873 if （len < 0） {
2874 return EMPTY_STRING;
2875 }
2876
2877 if （str.length（） <= len） {
2878 return str;
2879 } else {
2880 return str.substring（str.length（） - len）;
2881 }
2882 }
2883
2884 /
2885 取得从指定索引开端策画的、长度为指定字符数的子串。
2886 <pre>
2887 StringUtil.mid（null， ， ） = null
2888 StringUtil.mid（， ， -ve） =
2889 StringUtil.mid（， 0， ） =
2890 StringUtil.mid（abc， 0， 2） = ab
2891 StringUtil.mid（abc， 0， 4） = abc
2892 StringUtil.mid（abc， 2， 4） = c
2893 StringUtil.mid（abc， 4， 2） =
2894 StringUtil.mid（abc， -2， 2） = ab
2895 </pre>
2896
2897 ＠param str 字符串
2898 ＠param pos 肇端索引，若是为负数，则看作<code>0</code>
2899 ＠param len 子串的长度，若是为负数，则看作长度为<code>0</code>
2900
2901 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2902 /
2903 public static String mid（String str， int pos， int len） {
2904 if （str == null） {
2905 return null;
2906 }
2907
2908 if （（len < 0） || （pos > str.length（））） {
2909 return EMPTY_STRING;
2910 }
2911
2912 if （pos < 0） {
2913 pos = 0;
2914 }
2915
2916 if （str.length（） <= （pos + len）） {
2917 return str.substring（pos）;
2918 } else {
2919 return str.substring（pos， pos + len）;
2920 }
2921 }
2922
2923 / ============================================================================ /
2924 / 搜刮并取子串函数。 /
2925 / ============================================================================ /
2926
2927 /
2928 取得第一个呈现的分隔子串之前的子串。
2929
2930 <p>
2931 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
2932 <pre>
2933 StringUtil.substringBefore（null， ） = null
2934 StringUtil.substringBefore（， ） =
2935 StringUtil.substringBefore（abc， a） =
2936 StringUtil.substringBefore（abcba， b） = a
2937 StringUtil.substringBefore（abc， c） = ab
2938 StringUtil.substringBefore（abc， d） = abc
2939 StringUtil.substringBefore（abc， ） =
2940 StringUtil.substringBefore（abc， null） = abc
2941 </pre>
2942 </p>
2943
2944 ＠param str 字符串
2945 ＠param separator 要搜刮的分隔子串
2946
2947 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2948 /
2949 public static String substringBefore（String str， String separator） {
2950 if （（str == null） || （separator == null） || （str.length（） == 0）） {
2951 return str;
2952 }
2953
2954 if （separator.length（） == 0） {
2955 return EMPTY_STRING;
2956 }
2957
2958 int pos = str.indexOf（separator）;
2959
2960 if （pos == -1） {
2961 return str;
2962 }
2963
2964 return str.substring（0， pos）;
2965 }
2966
2967 /
2968 取得第一个呈现的分隔子串之后的子串。
2969
2970 <p>
2971 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
2972 <pre>
2973 StringUtil.substringAfter（null， ） = null
2974 StringUtil.substringAfter（， ） =
2975 StringUtil.substringAfter（， null） =
2976 StringUtil.substringAfter（abc， a） = bc
2977 StringUtil.substringAfter（abcba， b） = cba
2978 StringUtil.substringAfter（abc， c） =
2979 StringUtil.substringAfter（abc， d） =
2980 StringUtil.substringAfter（abc， ） = abc
2981 </pre>
2982 </p>
2983
2984 ＠param str 字符串
2985 ＠param separator 要搜刮的分隔子串
2986
2987 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2988 /
2989 public static String substringAfter（String str， String separator） {
2990 if （（str == null） || （str.length（） == 0）） {
2991 return str;
2992 }
2993
2994 if （separator == null） {
2995 return EMPTY_STRING;
2996 }
2997
2998 int pos = str.indexOf（separator）;
2999
3000 if （pos == -1） {
3001 return EMPTY_STRING;
3002 }
3003
3004 return str.substring（pos + separator.length（））;
3005 }
3006
3007 /
3008 取得最后一个的分隔子串之前的子串。
3009
3010 <p>
3011 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
3012 <pre>
3013 StringUtil.substringBeforeLast（null， ） = null
3014 StringUtil.substringBeforeLast（， ） =
3015 StringUtil.substringBeforeLast（abcba， b） = abc
3016 StringUtil.substringBeforeLast（abc， c） = ab
3017 StringUtil.substringBeforeLast（a， a） =
3018 StringUtil.substringBeforeLast（a， z） = a
3019 StringUtil.substringBeforeLast（a， null） = a
3020 StringUtil.substringBeforeLast（a， ） = a
3021 </pre>
3022 </p>
3023
3024 ＠param str 字符串
3025 ＠param separator 要搜刮的分隔子串
3026
3027 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
3028 /
3029 public static String substringBeforeLast（String str， String separator） {
3030 if （（str == null） || （separator == null） || （str.length（） == 0）
3031 || （separator.length（） == 0）） {
3032 return str;
3033 }
3034
3035 int pos = str.lastIndexOf（separator）;
3036
3037 if （pos == -1） {
3038 return str;
3039 }
3040
3041 return str.substring（0， pos）;
3042 }
3043
3044 /
3045 取得最后一个的分隔子串之后的子串。
3046
3047 <p>
3048 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
3049 <pre>
3050 StringUtil.substringAfterLast（null， ） = null
3051 StringUtil.substringAfterLast（， ） =
3052 StringUtil.substringAfterLast（， ） =
3053 StringUtil.substringAfterLast（， null） =
3054 StringUtil.substringAfterLast（abc， a） = bc
3055 StringUtil.substringAfterLast（abcba， b） = a
3056 StringUtil.substringAfterLast（abc， c） =
3057 StringUtil.substringAfterLast（a， a） =
3058 StringUtil.substringAfterLast（a， z） =
3059 </pre>
3060 </p>
3061
3062 ＠param str 字符串
3063 ＠param separator 要搜刮的分隔子串
3064
3065 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
3066 /
3067 public static String substringAfterLast（String str， String separator） {
3068 if （（str == null） || （str.length（） == 0）） {
3069 return str;
3070 }
3071
3072 if （（separator == null） || （separator.length（） == 0）） {
3073 return EMPTY_STRING;
3074 }
3075
3076 int pos = str.lastIndexOf（separator）;
3077
3078 if （（pos == -1） || （pos == （str.length（） - separator.length（）））） {
3079 return EMPTY_STRING;
3080 }
3081
3082 return str.substring（pos + separator.length（））;
3083 }
3084
3085 /
3086 取得指定分隔符的前两次呈现之间的子串。
3087
3088 <p>
3089 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3090 <pre>
3091 StringUtil.substringBetween（null， ） = null
3092 StringUtil.substringBetween（， ） =
3093 StringUtil.substringBetween（， tag） = null
3094 StringUtil.substringBetween（tagabctag， null） = null
3095 StringUtil.substringBetween（tagabctag， ） =
3096 StringUtil.substringBetween（tagabctag， tag） = abc
3097 </pre>
3098 </p>
3099
3100 ＠param str 字符串
3101 ＠param tag 要搜刮的分隔子串
3102
3103 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3104 /
3105 public static String substringBetween（String str， String tag） {
3106 return substringBetween（str， tag， tag， 0）;
3107 }
3108
3109 /
3110 取得两个分隔符之间的子串。
3111
3112 <p>
3113 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3114 <pre>
3115 StringUtil.substringBetween（null， ， ） = null
3116 StringUtil.substringBetween（， ， ） =
3117 StringUtil.substringBetween（， ， tag） = null
3118 StringUtil.substringBetween（， tag， tag） = null
3119 StringUtil.substringBetween（yabcz， null， null） = null
3120 StringUtil.substringBetween（yabcz， ， ） =
3121 StringUtil.substringBetween（yabcz， y， z） = abc
3122 StringUtil.substringBetween（yabczyabcz， y， z） = abc
3123 </pre>
3124 </p>
3125
3126 ＠param str 字符串
3127 ＠param open 要搜刮的分隔子串1
3128 ＠param close 要搜刮的分隔子串2
3129
3130 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3131 /
3132 public static String substringBetween（String str， String open， String close） {
3133 return substringBetween（str， open， close， 0）;
3134 }
3135
3136 /
3137 取得两个分隔符之间的子串。
3138
3139 <p>
3140 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3141 <pre>
3142 StringUtil.substringBetween（null， ， ） = null
3143 StringUtil.substringBetween（， ， ） =
3144 StringUtil.substringBetween（， ， tag） = null
3145 StringUtil.substringBetween（， tag， tag） = null
3146 StringUtil.substringBetween（yabcz， null， null） = null
3147 StringUtil.substringBetween（yabcz， ， ） =
3148 StringUtil.substringBetween（yabcz， y， z） = abc
3149 StringUtil.substringBetween（yabczyabcz， y， z） = abc
3150 </pre>
3151 </p>
3152
3153 ＠param str 字符串
3154 ＠param open 要搜刮的分隔子串1
3155 ＠param close 要搜刮的分隔子串2
3156 ＠param Index 从指定index处搜刮
3157
3158 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3159 /
3160 public static String substringBetween（String str， String open， String close， int Index） {
3161 if （（str == null） || （open == null） || （close == null）） {
3162 return null;
3163 }
3164
3165 int start = str.indexOf（open， Index）;
3166
3167 if （start != -1） {
3168 int end = str.indexOf（close， start + open.length（））;
3169
3170 if （end != -1） {
3171 return str.substring（start + open.length（）， end）;
3172 }
3173 }
3174
3175 return null;
3176 }
3177
3178 / ============================================================================ /
3179 / 删除字符。 /
3180 / ============================================================================ /
3181
3182 /
3183 删除所有在<code>Character.isWhitespace（char）</code>中所定义的空白。
3184 <pre>
3185 StringUtil.Whitespace（null） = null
3186 StringUtil.Whitespace（） =
3187 StringUtil.Whitespace（abc） = abc
3188 StringUtil.Whitespace（ ab c ） = abc
3189 </pre>
3190
3191 ＠param str 要处理惩罚的字符串
3192
3193 ＠return 去空白后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3194 /
3195 public static String Whitespace（String str） {
3196 if （str == null） {
3197 return null;
3198 }
3199
3200 int sz = str.length（）;
3201 StringBuffer buffer = new StringBuffer（sz）;
3202
3203 for （int i = 0; i < sz; i++） {
3204 if （!Character.isWhitespace（str.charAt（i））） {
3205 buffer.append（str.charAt（i））;
3206 }
3207 }
3208
3209 return buffer.toString（）;
3210 }
3211
3212 / ============================================================================ /
3213 / 调换子串。 /
3214 / ============================================================================ /
3215
3216 /
3217 调换指定的子串，只调换第一个呈现的子串。
3218
3219 <p>
3220 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3221 <pre>
3222 StringUtil.replaceOnce（null， ， ） = null
3223 StringUtil.replaceOnce（， ， ） =
3224 StringUtil.replaceOnce（aba， null， null） = aba
3225 StringUtil.replaceOnce（aba， null， null） = aba
3226 StringUtil.replaceOnce（aba， a， null） = aba
3227 StringUtil.replaceOnce（aba， a， ） = ba
3228 StringUtil.replaceOnce（aba， a， z） = zba
3229 </pre>
3230 </p>
3231
3232 ＠param text 要扫描的字符串
3233 ＠param repl 要搜刮的子串
3234 ＠param with 调换字符串
3235
3236 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3237 /
3238 public static String replaceOnce（String text， String repl， String with） {
3239 return replace（text， repl， with， 1）;
3240 }
3241
3242 /
3243 调换指定的子串，调换所有呈现的子串。
3244
3245 <p>
3246 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3247 <pre>
3248 StringUtil.replace（null， ， ） = null
3249 StringUtil.replace（， ， ） =
3250 StringUtil.replace（aba， null， null） = aba
3251 StringUtil.replace（aba， null， null） = aba
3252 StringUtil.replace（aba， a， null） = aba
3253 StringUtil.replace（aba， a， ） = b
3254 StringUtil.replace（aba， a， z） = zbz
3255 </pre>
3256 </p>
3257
3258 ＠param text 要扫描的字符串
3259 ＠param repl 要搜刮的子串
3260 ＠param with 调换字符串
3261
3262 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3263 /
3264 public static String replace（String text， String repl， String with） {
3265 return replace（text， repl， with， -1）;
3266 }
3267
3268 /
3269 调换指定的子串，调换指定的次数。
3270
3271 <p>
3272 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3273 <pre>
3274 StringUtil.replace（null， ， ， ） = null
3275 StringUtil.replace（， ， ， ） =
3276 StringUtil.replace（abaa， null， null， 1） = abaa
3277 StringUtil.replace（abaa， null， null， 1） = abaa
3278 StringUtil.replace（abaa， a， null， 1） = abaa
3279 StringUtil.replace（abaa， a， ， 1） = baa
3280 StringUtil.replace（abaa， a， z， 0） = abaa
3281 StringUtil.replace（abaa， a， z， 1） = zbaa
3282 StringUtil.replace（abaa， a， z， 2） = zbza
3283 StringUtil.replace（abaa， a， z， -1） = zbzz
3284 </pre>
3285 </p>
3286
3287 ＠param text 要扫描的字符串
3288 ＠param repl 要搜刮的子串
3289 ＠param with 调换字符串
3290 ＠param max maximum number of values to replace， or <code>-1</code> if no maximum
3291
3292 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3293 /
3294 public static String replace（String text， String repl， String with， int max） {
3295 if （（text == null） || （repl == null） || （with == null） || （repl.length（） == 0）
3296 || （max == 0）） {
3297 return text;
3298 }
3299
3300 StringBuffer buf = new StringBuffer（text.length（））;
3301 int start = 0;
3302 int end = 0;
3303
3304 while （（end = text.indexOf（repl， start）） != -1） {
3305 buf.append（text.substring（start， end））.append（with）;
3306 start = end + repl.length（）;
3307
3308 if （--max == 0） {
3309 break;
3310 }
3311 }
3312
3313 buf.append（text.substring（start））;
3314 return buf.toString（）;
3315 }
3316
3317 /
3318 将字符串中所有指定的字符，调换成另一个。
3319
3320 <p>
3321 若是字符串为<code>null</code>则返回<code>null</code>。
3322 <pre>
3323 StringUtil.replaceChars（null， ， ） = null
3324 StringUtil.replaceChars（， ， ） =
3325 StringUtil.replaceChars（abcba， b， y） = aycya
3326 StringUtil.replaceChars（abcba， z， y） = abcba
3327 </pre>
3328 </p>
3329
3330 ＠param str 要扫描的字符串
3331 ＠param searchChar 要搜刮的字符
3332 ＠param replaceChar 调换字符
3333
3334 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3335 /
3336 public static String replaceChars（String str， char searchChar， char replaceChar） {
3337 if （str == null） {
3338 return null;
3339 }
3340
3341 return str.replace（searchChar， replaceChar）;
3342 }
3343
3344 /
3345 将字符串中所有指定的字符，调换成另一个。
3346
3347 <p>
3348 若是字符串为<code>null</code>则返回<code>null</code>。若是搜刮字符串为<code>null</code>或空，则返回原字符串。
3349 </p>
3350
3351 <p>
3352 例如： <code>replaceChars（"hello"， "ho"， "jy"） = jelly</code>。
3353 </p>
3354
3355 <p>
3356 凡是搜刮字符串和调换字符串是等长的，若是搜刮字符串比调换字符串长，则多余的字符将被删除。 若是搜刮字符串比调换字符串短，则缺乏的字符将被忽视。
3357 <pre>
3358 StringUtil.replaceChars（null， ， ） = null
3359 StringUtil.replaceChars（， ， ） =
3360 StringUtil.replaceChars（abc， null， ） = abc
3361 StringUtil.replaceChars（abc， ， ） = abc
3362 StringUtil.replaceChars（abc， b， null） = ac
3363 StringUtil.replaceChars（abc， b， ） = ac
3364 StringUtil.replaceChars（abcba， bc， yz） = ayzya
3365 StringUtil.replaceChars（abcba， bc， y） = ayya
3366 StringUtil.replaceChars（abcba， bc， yzx） = ayzya
3367 </pre>
3368 </p>
3369
3370 ＠param str 要扫描的字符串
3371 ＠param searchChars 要搜刮的字符串
3372 ＠param replaceChars 调换字符串
3373
3374 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3375 /
3376 public static String replaceChars（String str， String searchChars， String replaceChars） {
3377 if （（str == null） || （str.length（） == 0） || （searchChars == null）
3378 || （searchChars.length（） == 0）） {
3379 return str;
3380 }
3381
3382 char[] chars = str.toCharArray（）;
3383 int len = chars.length;
3384 boolean modified = false;
3385
3386 for （int i = 0， isize = searchChars.length（）; i < isize; i++） {
3387 char searchChar = searchChars.charAt（i）;
3388
3389 if （（replaceChars == null） || （i >= replaceChars.length（））） {
3390 // 删除
3391 int pos = 0;
3392
3393 for （int j = 0; j < len; j++） {
3394 if （chars[j] != searchChar） {
3395 chars[pos++] = chars[j];
3396 } else {
3397 modified = true;
3398 }
3399 }
3400
3401 len = pos;
3402 } else {
3403 // 调换
3404 for （int j = 0; j < len; j++） {
3405 if （chars[j] == searchChar） {
3406 chars[j] = replaceChars.charAt（i）;
3407 modified = true;
3408 }
3409 }
3410 }
3411 }
3412
3413 if （!modified） {
3414 return str;
3415 }
3416
3417 return new String（chars， 0， len）;
3418 }
3419
3420 /
3421 将指定的子串用另一指定子串覆盖。
3422
3423 <p>
3424 若是字符串为<code>null</code>，则返回<code>null</code>。 负的索引值将被看作<code>0</code>，越界的索引值将被设置成字符串的长度雷同的值。
3425 <pre>
3426 StringUtil.overlay（null， ， ， ） = null
3427 StringUtil.overlay（， abc， 0， 0） = abc
3428 StringUtil.overlay（abcdef， null， 2， 4） = abef
3429 StringUtil.overlay（abcdef， ， 2， 4） = abef
3430 StringUtil.overlay（abcdef， ， 4， 2） = abef
3431 StringUtil.overlay（abcdef， zzzz， 2， 4） = abzzzzef
3432 StringUtil.overlay（abcdef， zzzz， 4， 2） = abzzzzef
3433 StringUtil.overlay（abcdef， zzzz， -1， 4） = zzzzef
3434 StringUtil.overlay（abcdef， zzzz， 2， 8） = abzzzz
3435 StringUtil.overlay（abcdef， zzzz， -2， -3） = zzzzabcdef
3436 StringUtil.overlay（abcdef， zzzz， 8， 10） = abcdefzzzz
3437 </pre>
3438 </p>
3439
3440 ＠param str 要扫描的字符串
3441 ＠param overlay 用来覆盖的字符串
3442 ＠param start 肇端索引
3443 ＠param end 停止索引
3444
3445 ＠return 被覆盖后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3446 /
3447 public static String overlay（String str， String overlay， int start， int end） {
3448 if （str == null） {
3449 return null;
3450 }
3451
3452 if （overlay == null） {
3453 overlay = EMPTY_STRING;
3454 }
3455
3456 int len = str.length（）;
3457
3458 if （start < 0） {
3459 start = 0;
3460 }
3461
3462 if （start > len） {
3463 start = len;
3464 }
3465
3466 if （end < 0） {
3467 end = 0;
3468 }
3469
3470 if （end > len） {
3471 end = len;
3472 }
3473
3474 if （start > end） {
3475 int temp = start;
3476
3477 start = end;
3478 end = temp;
3479 }
3480
3481 return new StringBuffer（（len + start） - end + overlay.length（） + 1）.append（
3482 str.substring（0， start））.append（overlay）.append（str.substring（end））.toString（）;
3483 }
3484
3485 / ============================================================================ /
3486 / Perl风格的chomp和chop函数。 /
3487 / ============================================================================ /
3488
3489 /
3490 删除字符串末尾的换行符。若是字符串不以换行结尾，则什么也不做。
3491
3492 <p>
3493 换行符有三种景象："<code>\n</code>"、"<code>\r</code>"、"<code>\r\n</code>"。
3494 <pre>
3495 StringUtil.chomp（null） = null
3496 StringUtil.chomp（） =
3497 StringUtil.chomp（abc \r） = abc
3498 StringUtil.chomp（abc\n） = abc
3499 StringUtil.chomp（abc\r\n） = abc
3500 StringUtil.chomp（abc\r\n\r\n） = abc\r\n
3501 StringUtil.chomp（abc\n\r） = abc\n
3502 StringUtil.chomp（abc\n\rabc） = abc\n\rabc
3503 StringUtil.chomp（\r） =
3504 StringUtil.chomp（\n） =
3505 StringUtil.chomp（\r\n） =
3506 </pre>
3507 </p>
3508
3509 ＠param str 要处理惩罚的字符串
3510
3511 ＠return 不以换行结尾的字符串，若是原始字串为<code>null</code>，则返回<code>null</code>
3512 /
3513 public static String chomp（String str） {
3514 if （（str == null） || （str.length（） == 0）） {
3515 return str;
3516 }
3517
3518 if （str.length（） == 1） {
3519 char ch = str.charAt（0）;
3520
3521 if （（ch == \r） || （ch == \n）） {
3522 return EMPTY_STRING;
3523 } else {
3524 return str;
3525 }
3526 }
3527
3528 int lastIdx = str.length（） - 1;
3529 char last = str.charAt（lastIdx）;
3530
3531 if （last == \n） {
3532 if （str.charAt（lastIdx - 1） == \r） {
3533 lastIdx--;
3534 }
3535 } else if （last == \r） {
3536 } else {
3537 lastIdx++;
3538 }
3539
3540 return str.substring（0， lastIdx）;
3541 }
3542
3543 /
3544 删除字符串末尾的指定字符串。若是字符串不以该字符串结尾，则什么也不做。
3545 <pre>
3546 StringUtil.chomp（null， ） = null
3547 StringUtil.chomp（， ） =
3548 StringUtil.chomp（foobar， bar） = foo
3549 StringUtil.chomp（foobar， baz） = foobar
3550 StringUtil.chomp（foo， foo） =
3551 StringUtil.chomp（foo ， foo） = foo
3552 StringUtil.chomp（ foo， foo） =
3553 StringUtil.chomp（foo， foooo） = foo
3554 StringUtil.chomp（foo， ） = foo
3555 StringUtil.chomp（foo， null） = foo
3556 </pre>
3557
3558 ＠param str 要处理惩罚的字符串
3559 ＠param separator 要删除的字符串
3560
3561 ＠return 不以指定字符串结尾的字符串，若是原始字串为<code>null</code>，则返回<code>null</code>
3562 /
3563 public static String chomp（String str， String separator） {
3564 if （（str == null） || （str.length（） == 0） || （separator == null）） {
3565 return str;
3566 }
3567
3568 if （str.endsWith（separator）） {
3569 return str.substring（0， str.length（） - separator.length（））;
3570 }
3571
3572 return str;
3573 }
3574
3575 /
3576 删除最后一个字符。
3577
3578 <p>
3579 若是字符串以<code>\r\n</code>结尾，则同时删除它们。
3580 <pre>
3581 StringUtil.chop（null） = null
3582 StringUtil.chop（） =
3583 StringUtil.chop（abc \r） = abc
3584 StringUtil.chop（abc\n） = abc
3585 StringUtil.chop（abc\r\n） = abc
3586 StringUtil.chop（abc） = ab
3587 StringUtil.chop（abc\nabc） = abc\nab
3588 StringUtil.chop（a） =
3589 StringUtil.chop（\r） =
3590 StringUtil.chop（\n） =
3591 StringUtil.chop（\r\n） =
3592 </pre>
3593 </p>
3594
3595 ＠param str 要处理惩罚的字符串
3596
3597 ＠return 删除最后一个字符的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3598 /
3599 public static String chop（String str） {
3600 if （str == null） {
3601 return null;
3602 }
3603
3604 int strLen = str.length（）;
3605
3606 if （strLen < 2） {
3607 return EMPTY_STRING;
3608 }
3609
3610 int lastIdx = strLen - 1;
3611 String ret = str.substring（0， lastIdx）;
3612 char last = str.charAt（lastIdx）;
3613
3614 if （last == \n） {
3615 if （ret.charAt（lastIdx - 1） == \r） {
3616 return ret.substring（0， lastIdx - 1）;
3617 }
3618 }
3619
3620 return ret;
3621 }
3622
3623 / ============================================================================ /
3624 / 反复/对齐字符串。 /
3625 / ============================================================================ /
3626
3627 /
3628 将指定字符串反复n遍。
3629 <pre>
3630 StringUtil.repeat（null， 2） = null
3631 StringUtil.repeat（， 0） =
3632 StringUtil.repeat（， 2） =
3633 StringUtil.repeat（a， 3） = aaa
3634 StringUtil.repeat（ab， 2） = abab
3635 StringUtil.repeat（abcd， 2） = abcdabcd
3636 StringUtil.repeat（a， -2） =
3637 </pre>
3638
3639 ＠param str 要反复的字符串
3640 ＠param repeat 反复次数，若是小于<code>0</code>，则看作<code>0</code>
3641
3642 ＠return 反复n次的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3643 /
3644 public static String repeat（String str， int repeat） {
3645 if （str == null） {
3646 return null;
3647 }
3648
3649 if （repeat <= 0） {
3650 return EMPTY_STRING;
3651 }
3652
3653 int inputLength = str.length（）;
3654
3655 if （（repeat == 1） || （inputLength == 0）） {
3656 return str;
3657 }
3658
3659 int outputLength = inputLength repeat;
3660
3661 switch （inputLength） {
3662 case 1:
3663
3664 char ch = str.charAt（0）;
3665 char[] output1 = new char[outputLength];
3666
3667 for （int i = repeat - 1; i >= 0; i--） {
3668 output1[i] = ch;
3669 }
3670
3671 return new String（output1）;
3672
3673 case 2:
3674
3675 char ch0 = str.charAt（0）;
3676 char ch1 = str.charAt（1）;
3677 char[] output2 = new char[outputLength];
3678
3679 for （int i = （repeat 2） - 2; i >= 0; i--， i--） {
3680 output2[i] = ch0;
3681 output2[i + 1] = ch1;
3682 }
3683
3684 return new String（output2）;
3685
3686 default:
3687
3688 StringBuffer buf = new StringBuffer（outputLength）;
3689
3690 for （int i = 0; i < repeat; i++） {
3691 buf.append（str）;
3692 }
3693
3694 return buf.toString（）;
3695 }
3696 }
3697
3698 /
3699 扩大并左对齐字符串，用空格<code> </code>填充右边。
3700 <pre>
3701 StringUtil.alignLeft（null， ） = null
3702 StringUtil.alignLeft（， 3） =
3703 StringUtil.alignLeft（bat， 3） = bat
3704 StringUtil.alignLeft（bat， 5） = bat
3705 StringUtil.alignLeft（bat， 1） = bat
3706 StringUtil.alignLeft（bat， -1） = bat
3707 </pre>
3708
3709 ＠param str 要对齐的字符串
3710 ＠param size 扩大字符串到指定宽度
3711
3712 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3713 /
3714 public static String alignLeft（String str， int size） {
3715 return alignLeft（str， size， ）;
3716 }
3717
3718 /
3719 扩大并左对齐字符串，用指定字符填充右边。
3720 <pre>
3721 StringUtil.alignLeft（null， ， ） = null
3722 StringUtil.alignLeft（， 3， z） = zzz
3723 StringUtil.alignLeft（bat， 3， z） = bat
3724 StringUtil.alignLeft（bat， 5， z） = batzz
3725 StringUtil.alignLeft（bat， 1， z） = bat
3726 StringUtil.alignLeft（bat， -1， z） = bat
3727 </pre>
3728
3729 ＠param str 要对齐的字符串
3730 ＠param size 扩大字符串到指定宽度
3731 ＠param padChar 填充字符
3732
3733 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3734 /
3735 public static String alignLeft（String str， int size， char padChar） {
3736 if （str == null） {
3737 return null;
3738 }
3739
3740 int pads = size - str.length（）;
3741
3742 if （pads <= 0） {
3743 return str;
3744 }
3745
3746 return alignLeft（str， size， String.valueOf（padChar））;
3747 }
3748
3749 /
3750 扩大并左对齐字符串，用指定字符串填充右边。
3751 <pre>
3752 StringUtil.alignLeft（null， ， ） = null
3753 StringUtil.alignLeft（， 3， z） = zzz
3754 StringUtil.alignLeft（bat， 3， yz） = bat
3755 StringUtil.alignLeft（bat， 5， yz） = batyz
3756 StringUtil.alignLeft（bat， 8， yz） = batyzyzy
3757 StringUtil.alignLeft（bat， 1， yz） = bat
3758 StringUtil.alignLeft（bat， -1， yz） = bat
3759 StringUtil.alignLeft（bat， 5， null） = bat
3760 StringUtil.alignLeft（bat， 5， ） = bat
3761 </pre>
3762
3763 ＠param str 要对齐的字符串
3764 ＠param size 扩大字符串到指定宽度
3765 ＠param padStr 填充字符串
3766
3767 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3768 /
3769 public static String alignLeft（String str， int size， String padStr） {
3770 if （str == null） {
3771 return null;
3772 }
3773
3774 if （（padStr == null） || （padStr.length（） == 0）） {
3775 padStr = ;
3776 }
3777
3778 int padLen = padStr.length（）;
3779 int strLen = str.length（）;
3780 int pads = size - strLen;
3781
3782 if （pads <= 0） {
3783 return str;
3784 }
3785
3786 if （pads == padLen） {
3787 return str.concat（padStr）;
3788 } else if （pads < padLen） {
3789 return str.concat（padStr.substring（0， pads））;
3790 } else {
3791 char[] padding = new char[pads];
3792 char[] padChars = padStr.toCharArray（）;
3793
3794 for （int i = 0; i < pads; i++） {
3795 padding[i] = padChars[i ％ padLen];
3796 }
3797
3798 return str.concat（new String（padding））;
3799 }
3800 }
3801
3802 /
3803 扩大并右对齐字符串，用空格<code> </code>填充左边。
3804 <pre>
3805 StringUtil.alignRight（null， ） = null
3806 StringUtil.alignRight（， 3） =
3807 StringUtil.alignRight（bat， 3） = bat
3808 StringUtil.alignRight（bat， 5） = bat
3809 StringUtil.alignRight（bat， 1） = bat
3810 StringUtil.alignRight（bat， -1） = bat
3811 </pre>
3812
3813 ＠param str 要对齐的字符串
3814 ＠param size 扩大字符串到指定宽度
3815
3816 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3817 /
3818 public static String alignRight（String str， int size） {
3819 return alignRight（str， size， ）;
3820 }
3821
3822 /
3823 扩大并右对齐字符串，用指定字符填充左边。
3824 <pre>
3825 StringUtil.alignRight（null， ， ） = null
3826 StringUtil.alignRight（， 3， z） = zzz
3827 StringUtil.alignRight（bat， 3， z） = bat
3828 StringUtil.alignRight（bat， 5， z） = zzbat
3829 StringUtil.alignRight（bat， 1， z） = bat
3830 StringUtil.alignRight（bat， -1， z） = bat
3831 </pre>
3832
3833 ＠param str 要对齐的字符串
3834 ＠param size 扩大字符串到指定宽度
3835 ＠param padChar 填充字符
3836
3837 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3838 /
3839 public static String alignRight（String str， int size， char padChar） {
3840 if （str == null） {
3841 return null;
3842 }
3843
3844 int pads = size - str.length（）;
3845
3846 if （pads <= 0） {
3847 return str;
3848 }
3849
3850 return alignRight（str， size， String.valueOf（padChar））;
3851 }
3852
3853 /
3854 扩大并右对齐字符串，用指定字符串填充左边。
3855 <pre>
3856 StringUtil.alignRight（null， ， ） = null
3857 StringUtil.alignRight（， 3， z） = zzz
3858 StringUtil.alignRight（bat， 3， yz） = bat
3859 StringUtil.alignRight（bat， 5， yz） = yzbat
3860 StringUtil.alignRight（bat， 8， yz） = yzyzybat
3861 StringUtil.alignRight（bat， 1， yz） = bat
3862 StringUtil.alignRight（bat， -1， yz） = bat
3863 StringUtil.alignRight（bat， 5， null） = bat
3864 StringUtil.alignRight（bat， 5， ） = bat
3865 </pre>
3866
3867 ＠param str 要对齐的字符串
3868 ＠param size 扩大字符串到指定宽度
3869 ＠param padStr 填充字符串
3870
3871 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3872 /
3873 public static String alignRight（String str， int size， String padStr） {
3874 if （str == null） {
3875 return null;
3876 }
3877
3878 if （（padStr == null） || （padStr.length（） == 0）） {
3879 padStr = ;
3880 }
3881
3882 int padLen = padStr.length（）;
3883 int strLen = str.length（）;
3884 int pads = size - strLen;
3885
3886 if （pads <= 0） {
3887 return str;
3888 }
3889
3890 if （pads == padLen） {
3891 return padStr.concat（str）;
3892 } else if （pads < padLen） {
3893 return padStr.substring（0， pads）.concat（str）;
3894 } else {
3895 char[] padding = new char[pads];
3896 char[] padChars = padStr.toCharArray（）;
3897
3898 for （int i = 0; i < pads; i++） {
3899 padding[i] = padChars[i ％ padLen];
3900 }
3901
3902 return new String（padding）.concat（str）;
3903 }
3904 }
3905
3906 /
3907 扩大并居中字符串，用空格<code> </code>填充两边。
3908 <pre>
3909 StringUtil.center（null， ） = null
3910 StringUtil.center（， 4） =
3911 StringUtil.center（ab， -1） = ab
3912 StringUtil.center（ab， 4） = ab
3913 StringUtil.center（abcd， 2） = abcd
3914 StringUtil.center（a， 4） = a
3915 </pre>
3916
3917 ＠param str 要对齐的字符串
3918 ＠param size 扩大字符串到指定宽度
3919
3920 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3921 /
3922 public static String center（String str， int size） {
3923 return center（str， size， ）;
3924 }
3925
3926 /
3927 扩大并居中字符串，用指定字符填充两边。
3928 <pre>
3929 StringUtil.center（null， ， ） = null
3930 StringUtil.center（， 4， ） =
3931 StringUtil.center（ab， -1， ） = ab
3932 StringUtil.center（ab， 4， ） = ab
3933 StringUtil.center（abcd， 2， ） = abcd
3934 StringUtil.center（a， 4， ） = a
3935 StringUtil.center（a， 4， y） = yayy
3936 </pre>
3937
3938 ＠param str 要对齐的字符串
3939 ＠param size 扩大字符串到指定宽度
3940 ＠param padChar 填充字符
3941
3942 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3943 /
3944 public static String center（String str， int size， char padChar） {
3945 if （（str == null） || （size <= 0）） {
3946 return str;
3947 }
3948
3949 int strLen = str.length（）;
3950 int pads = size - strLen;
3951
3952 if （pads <= 0） {
3953 return str;
3954 }
3955
3956 str = alignRight（str， strLen + （pads / 2）， padChar）;
3957 str = alignLeft（str， size， padChar）;
3958 return str;
3959 }
3960
3961 /
3962 扩大并居中字符串，用指定字符串填充两边。
3963 <pre>
3964 StringUtil.center（null， ， ） = null
3965 StringUtil.center（， 4， ） =
3966 StringUtil.center（ab， -1， ） = ab
3967 StringUtil.center（ab， 4， ） = ab
3968 StringUtil.center（abcd， 2， ） = abcd
3969 StringUtil.center（a， 4， ） = a
3970 StringUtil.center（a， 4， yz） = yayz
3971 StringUtil.center（abc， 7， null） = abc
3972 StringUtil.center（abc， 7， ） = abc
3973 </pre>
3974
3975 ＠param str 要对齐的字符串
3976 ＠param size 扩大字符串到指定宽度
3977 ＠param padStr 填充字符串
3978
3979 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3980 /
3981 public static String center（String str， int size， String padStr） {
3982 if （（str == null） || （size <= 0）） {
3983 return str;
3984 }
3985
3986 if （（padStr == null） || （padStr.length（） == 0）） {
3987 padStr = ;
3988 }
3989
3990 int strLen = str.length（）;
3991 int pads = size - strLen;
3992
3993 if （pads <= 0） {
3994 return str;
3995 }
3996
3997 str = alignRight（str， strLen + （pads / 2）， padStr）;
3998 str = alignLeft（str， size， padStr）;
3999 return str;
4000 }
4001
4002 / ============================================================================ /
4003 / 反转字符串。 /
4004 / ============================================================================ /
4005
4006 /
4007 反转字符串中的字符次序。
4008
4009 <p>
4010 若是字符串为<code>null</code>，则返回<code>null</code>。
4011 </p>
4012 <pre>
4013 StringUtil.reverse（null） = null
4014 StringUtil.reverse（） =
4015 StringUtil.reverse（bat） = tab
4016 </pre>
4017
4018 ＠param str 要反转的字符串
4019
4020 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4021 /
4022 public static String reverse（String str） {
4023 if （（str == null） || （str.length（） == 0）） {
4024 return str;
4025 }
4026
4027 return new StringBuffer（str）.reverse（）.toString（）;
4028 }
4029
4030 /
4031 反转指定分隔符分隔的各子串的次序。
4032
4033 <p>
4034 若是字符串为<code>null</code>，则返回<code>null</code>。
4035 </p>
4036 <pre>
4037 StringUtil.reverseDelimited（null， ） = null
4038 StringUtil.reverseDelimited（， ） =
4039 StringUtil.reverseDelimited（a.b.c， x） = a.b.c
4040 StringUtil.reverseDelimited（a.b.c， .） = c.b.a
4041 </pre>
4042
4043 ＠param str 要反转的字符串
4044 ＠param separatorChar 分隔符
4045
4046 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4047 /
4048 public static String reverseDelimited（String str， char separatorChar） {
4049 if （str == null） {
4050 return null;
4051 }
4052
4053 String[] strs = split（str， separatorChar）;
4054
4055 ArrayUtil.reverse（strs）;
4056
4057 return join（strs， separatorChar）;
4058 }
4059
4060 /
4061 反转指定分隔符分隔的各子串的次序。
4062
4063 <p>
4064 若是字符串为<code>null</code>，则返回<code>null</code>。
4065 </p>
4066 <pre>
4067 StringUtil.reverseDelimited（null， ， ） = null
4068 StringUtil.reverseDelimited（， ， ） =
4069 StringUtil.reverseDelimited（a.b.c， null， null） = a.b.c
4070 StringUtil.reverseDelimited（a.b.c， ， null） = a.b.c
4071 StringUtil.reverseDelimited（a.b.c， .， ，） = c，b，a
4072 StringUtil.reverseDelimited（a.b.c， .， null） = c b a
4073 </pre>
4074
4075 ＠param str 要反转的字符串
4076 ＠param separatorChars 分隔符，若是为<code>null</code>，则默认应用空白字符
4077 ＠param separator 用来连接子串的分隔符，若是为<code>null</code>，默认应用空格
4078
4079 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4080 /
4081 public static String reverseDelimited（String str， String separatorChars， String separator） {
4082 if （str == null） {
4083 return null;
4084 }
4085
4086 String[] strs = split（str， separatorChars）;
4087
4088 ArrayUtil.reverse（strs）;
4089
4090 if （separator == null） {
4091 return join（strs， ）;
4092 }
4093
4094 return join（strs， separator）;
4095 }
4096
4097 / ============================================================================ /
4098 / 取得字符串的缩略。 /
4099 / ============================================================================ /
4100
4101 /
4102 将字符串转换成指定长度的缩略，例如： 将Now is the time for all good men转换成Now is the time for...。
4103
4104 <ul>
4105 <li>
4106 若是<code>str</code>比<code>maxWidth</code>短，直接返回；
4107 </li>
4108 <li>
4109 不然将它转换成缩略：<code>substring（str， 0， max-3） + ...</code>；
4110 </li>
4111 <li>
4112 若是<code>maxWidth</code>小于<code>4</code>抛出<code>IllegalArgumentException</code>；
4113 </li>
4114 <li>
4115 返回的字符串不成能善于指定的<code>maxWidth</code>。
4116 </li>
4117 </ul>
4118
4119 <pre>
4120 StringUtil.abbreviate（null， ） = null
4121 StringUtil.abbreviate（， 4） =
4122 StringUtil.abbreviate（abcdefg， 6） = abc...
4123 StringUtil.abbreviate（abcdefg， 7） = abcdefg
4124 StringUtil.abbreviate（abcdefg， 8） = abcdefg
4125 StringUtil.abbreviate（abcdefg， 4） = a...
4126 StringUtil.abbreviate（abcdefg， 3） = IllegalArgumentException
4127 </pre>
4128
4129 ＠param str 要搜检的字符串
4130 ＠param maxWidth 最大长度，不小于<code>4</code>，若是小于<code>4</code>，则看作<code>4</code>
4131
4132 ＠return 字符串缩略，若是原始字符串为<code>null</code>则返回<code>null</code>
4133 /
4134 public static String abbreviate（String str， int maxWidth） {
4135 return abbreviate（str， 0， maxWidth）;
4136 }
4137
4138 /
4139 将字符串转换成指定长度的缩略，例如： 将Now is the time for all good men转换成...is the time for...。
4140
4141 <p>
4142 和<code>abbreviate（String， int）</code>类似，然则增长了一个“左鸿沟”偏移量。
4143 重视，“左鸿沟”处的字符未必呈如今成果字符串的最左边，但必然呈如今成果字符串中。
4144 </p>
4145
4146 <p>
4147 返回的字符串不成能善于指定的<code>maxWidth</code>。
4148 <pre>
4149 StringUtil.abbreviate（null， ， ） = null
4150 StringUtil.abbreviate（， 0， 4） =
4151 StringUtil.abbreviate（abcdefghijklmno， -1， 10） = abcdefg...
4152 StringUtil.abbreviate（abcdefghijklmno， 0， 10） = abcdefg...
4153 StringUtil.abbreviate（abcdefghijklmno， 1， 10） = abcdefg...
4154 StringUtil.abbreviate（abcdefghijklmno， 4， 10） = abcdefg...
4155 StringUtil.abbreviate（abcdefghijklmno， 5， 10） = ...fghi...
4156 StringUtil.abbreviate（abcdefghijklmno， 6， 10） = ...ghij...
4157 StringUtil.abbreviate（abcdefghijklmno， 8， 10） = ...ijklmno
4158 StringUtil.abbreviate（abcdefghijklmno， 10， 10） = ...ijklmno
4159 StringUtil.abbreviate（abcdefghijklmno， 12， 10） = ...ijklmno
4160 StringUtil.abbreviate（abcdefghij， 0， 3） = IllegalArgumentException
4161 StringUtil.abbreviate（abcdefghij， 5， 6） = IllegalArgumentException
4162 </pre>
4163 </p>
4164
4165 ＠param str 要搜检的字符串
4166 ＠param offset 左鸿沟偏移量
4167 ＠param maxWidth 最大长度，不小于<code>4</code>，若是小于<code>4</code>，则看作<code>4</code>
4168
4169 ＠return 字符串缩略，若是原始字符串为<code>null</code>则返回<code>null</code>
4170 /
4171 public static String abbreviate（String str， int offset， int maxWidth） {
4172 if （str == null） {
4173 return null;
4174 }
4175
4176 // 调剂最大宽度
4177 if （maxWidth < 4） {
4178 maxWidth = 4;
4179 }
4180
4181 if （str.length（） <= maxWidth） {
4182 return str;
4183 }
4184
4185 if （offset > str.length（）） {
4186 offset = str.length（）;
4187 }
4188
4189 if （（str.length（） - offset） < （maxWidth - 3）） {
4190 offset = str.length（） - （maxWidth - 3）;
4191 }
4192
4193 if （offset <= 4） {
4194 return str.substring（0， maxWidth - 3） + ...;
4195 }
4196
4197 // 调剂最大宽度
4198 if （maxWidth < 7） {
4199 maxWidth = 7;
4200 }
4201
4202 if （（offset + （maxWidth - 3）） < str.length（）） {
4203 return ... + abbreviate（str.substring（offset）， maxWidth - 3）;
4204 }
4205
4206 return ... + str.substring（str.length（） - （maxWidth - 3））;
4207 }
4208
4209 / ============================================================================ /
4210 / 斗劲两个字符串的异同。 /
4211 / /
4212 / 查找字符串之间的差别，斗劲字符串的类似度。 /
4213 / ============================================================================ /
4214
4215 /
4216 斗劲两个字符串，取得第二个字符串中，和第一个字符串不合的项目组。
4217 <pre>
4218 StringUtil.difference（i am a machine， i am a robot） = robot
4219 StringUtil.difference（null， null） = null
4220 StringUtil.difference（， ） =
4221 StringUtil.difference（， null） =
4222 StringUtil.difference（， abc） = abc
4223 StringUtil.difference（abc， ） =
4224 StringUtil.difference（abc， abc） =
4225 StringUtil.difference（ab， abxyz） = xyz
4226 StringUtil.difference（abcde， abxyz） = xyz
4227 StringUtil.difference（abcde， xyz） = xyz
4228 </pre>
4229
4230 ＠param str1 字符串1
4231 ＠param str2 字符串2
4232
4233 ＠return 第二个字符串中，和第一个字符串不合的项目组。若是两个字符串雷同，则返回空字符串<code></code>
4234 /
4235 public static String difference（String str1， String str2） {
4236 if （str1 == null） {
4237 return str2;
4238 }
4239
4240 if （str2 == null） {
4241 return str1;
4242 }
4243
4244 int index = indexOfDifference（str1， str2）;
4245
4246 if （index == -1） {
4247 return EMPTY_STRING;
4248 }
4249
4250 return str2.substring（index）;
4251 }
4252
4253 /
4254 斗劲两个字符串，取得两字符串开端不合的索引值。
4255 <pre>
4256 StringUtil.indexOfDifference（i am a machine， i am a robot） = 7
4257 StringUtil.indexOfDifference（null， null） = -1
4258 StringUtil.indexOfDifference（， null） = -1
4259 StringUtil.indexOfDifference（， ） = -1
4260 StringUtil.indexOfDifference（， abc） = 0
4261 StringUtil.indexOfDifference（abc， ） = 0
4262 StringUtil.indexOfDifference（abc， abc） = -1
4263 StringUtil.indexOfDifference（ab， abxyz） = 2
4264 StringUtil.indexOfDifference（abcde， abxyz） = 2
4265 StringUtil.indexOfDifference（abcde， xyz） = 0
4266 </pre>
4267
4268 ＠param str1 字符串1
4269 ＠param str2 字符串2
4270
4271 ＠return 两字符串开端产生差别的索引值，若是两字符串雷同，则返回<code>-1</code>
4272 /
4273 public static int indexOfDifference（String str1， String str2） {
4274 if （（str1 == str2） || （str1 == null） || （str2 == null）） {
4275 return -1;
4276 }
4277
4278 int i;
4279
4280 for （i = 0; （i < str1.length（）） && （i < str2.length（））; ++i） {
4281 if （str1.charAt（i） != str2.charAt（i）） {
4282 break;
4283 }
4284 }
4285
4286 if （（i < str2.length（）） || （i < str1.length（））） {
4287 return i;
4288 }
4289
4290 return -1;
4291 }
4292
4293 /
4294 取得两个字符串的类似度，<code>0</code>代表字符串相等，数字越大默示字符串越不像。
4295
4296 <p>
4297 这个算法取自<a href=http://www.merriampark.com/ld.htm>http://www.merriampark.com/ld.htm</a>。
4298 它策画的是从字符串1改变到字符串2所须要的删除、插入和调换的步调数。
4299 </p>
4300 <pre>
4301 StringUtil.getLevenshteinDistance（null， ） = IllegalArgumentException
4302 StringUtil.getLevenshteinDistance（， null） = IllegalArgumentException
4303 StringUtil.getLevenshteinDistance（，） = 0
4304 StringUtil.getLevenshteinDistance（，a） = 1
4305 StringUtil.getLevenshteinDistance（aaapppp， ） = 7
4306 StringUtil.getLevenshteinDistance（frog， fog） = 1
4307 StringUtil.getLevenshteinDistance（fly， ant） = 3
4308 StringUtil.getLevenshteinDistance（elephant， hippo） = 7
4309 StringUtil.getLevenshteinDistance（hippo， elephant） = 7
4310 StringUtil.getLevenshteinDistance（hippo， zzzzzzzz） = 8
4311 StringUtil.getLevenshteinDistance（hello， hallo） = 1
4312 </pre>
4313
4314 ＠param s 第一个字符串，若是是<code>null</code>，则看作空字符串
4315 ＠param t 第二个字符串，若是是<code>null</code>，则看作空字符串
4316
4317 ＠return 类似度值
4318 /
4319 public static int getLevenshteinDistance（String s， String t） {
4320 s = defaultIfNull（s）;
4321 t = defaultIfNull（t）;
4322
4323 int[][] d; // matrix
4324 int n; // length of s
4325 int m; // length of t
4326 int i; // iterates through s
4327 int j; // iterates through t
4328 char s_i; // ith character of s
4329 char t_j; // jth character of t
4330 int cost; // cost
4331
4332 // Step 1
4333 n = s.length（）;
4334 m = t.length（）;
4335
4336 if （n == 0） {
4337 return m;
4338 }
4339
4340 if （m == 0） {
4341 return n;
4342 }
4343
4344 d = new int[n + 1][m + 1];
4345
4346 // Step 2
4347 for （i = 0; i <= n; i++） {
4348 d[i][0] = i;
4349 }
4350
4351 for （j = 0; j <= m; j++） {
4352 d[0][j] = j;
4353 }
4354
4355 // Step 3
4356 for （i = 1; i <= n; i++） {
4357 s_i = s.charAt（i - 1）;
4358
4359 // Step 4
4360 for （j = 1; j <= m; j++） {
4361 t_j = t.charAt（j - 1）;
4362
4363 // Step 5
4364 if （s_i == t_j） {
4365 cost = 0;
4366 } else {
4367 cost = 1;
4368 }
4369
4370 // Step 6
4371 d[i][j] = min（d[i - 1][j] + 1， d[i][j - 1] + 1， d[i - 1][j - 1] + cost）;
4372 }
4373 }
4374
4375 // Step 7
4376 return d[n][m];
4377 }
4378
4379 /
4380 取得最小数。
4381
4382 ＠param a 整数1
4383 ＠param b 整数2
4384 ＠param c 整数3
4385
4386 ＠return 三个数中的最小值
4387 /
4388 private static int min（int a， int b， int c） {
4389 if （b < a） {
4390 a = b;
4391 }
4392
4393 if （c < a） {
4394 a = c;
4395 }
4396
4397 return a;
4398 }
4399 }
View Code
彼此相爱，却不要让爱成了束缚：不如让它成为涌动的大海，两岸乃是你们的灵魂。互斟满杯，却不要同饮一杯。相赠面包，却不要共食一个。一起歌舞欢喜，却依然各自独立，相互交心，却不是让对方收藏。因为唯有生命之手，方能收容你们的心。站在一起却不要过于靠近。—— 纪伯伦《先知》
每次做项目都邑碰到字符串的处理惩罚，每次都邑去写一个StringUtil，完成一些功能。
但其实每次要的功能都差不久不多：
1.断定类（包含NULL和空串、是否是空白字符串等）
2.默认值
3.去空白（trim）
4.斗劲
5.字符类型断定（是否只包含数字、字母）
6.大小写转换（首字母大小写等）
7.字符串分别
8.字符串连接
9.字符串查找
10.取子串
11.删除字符
12.字符串斗劲
下面是一个字符串的对象类，涵盖了上方列的功能，算是斗劲完全的。
1 /
2 有关字符串处理惩罚的对象类。
3
4 <p>
5 这个类中的每个办法都可以“安然”地处理惩罚<code>null</code>，而不会抛出<code>NullPointerException</code>。
6 </p>
7
8 /
9 public class StringUtil {
10 / ============================================================================ /
11 / 常量和singleton。 /
12 / ============================================================================ /
13
14 / 空字符串。 /
15 public static final String EMPTY_STRING = ;
16
17 / ============================================================================ /
18 / 判空函数。 /
19 / /
20 / 以下办法用来剖断一个字符串是否为： /
21 / 1. null /
22 / 2. empty - /
23 / 3. blank - 全部是空白 - 空白由Character.isWhitespace所定义。 /
24 / ============================================================================ /
25
26 /
27 搜检字符串是否为<code>null</code>或空字符串<code></code>。
28 <pre>
29 StringUtil.isEmpty（null） = true
30 StringUtil.isEmpty（） = true
31 StringUtil.isEmpty（ ） = false
32 StringUtil.isEmpty（bob） = false
33 StringUtil.isEmpty（ bob ） = false
34 </pre>
35
36 ＠param str 要搜检的字符串
37
38 ＠return 若是为空， 则返回<code>true</code>
39 /
40 public static boolean isEmpty（String str） {
41 return （（str == null） || （str.length（） == 0））;
42 }
43
44 /
45 搜检字符串是否不是<code>null</code>和空字符串<code></code>。
46 <pre>
47 StringUtil.isEmpty（null） = false
48 StringUtil.isEmpty（） = false
49 StringUtil.isEmpty（ ） = true
50 StringUtil.isEmpty（bob） = true
51 StringUtil.isEmpty（ bob ） = true
52 </pre>
53
54 ＠param str 要搜检的字符串
55
56 ＠return 若是不为空， 则返回<code>true</code>
57 /
58 public static boolean isNotEmpty（String str） {
59 return （（str != null） && （str.length（） > 0））;
60 }
61
62 /
63 搜检字符串是否是空白：<code>null</code>、空字符串<code></code>或只有空白字符。
64 <pre>
65 StringUtil.isBlank（null） = true
66 StringUtil.isBlank（） = true
67 StringUtil.isBlank（ ） = true
68 StringUtil.isBlank（bob） = false
69 StringUtil.isBlank（ bob ） = false
70 </pre>
71
72 ＠param str 要搜检的字符串
73
74 ＠return 若是为空白， 则返回<code>true</code>
75 /
76 public static boolean isBlank（String str） {
77 int length;
78
79 if （（str == null） || （（length = str.length（）） == 0）） {
80 return true;
81 }
82
83 for （int i = 0; i < length; i++） {
84 if （!Character.isWhitespace（str.charAt（i））） {
85 return false;
86 }
87 }
88
89 return true;
90 }
91
92 /
93 搜检字符串是否不是空白：<code>null</code>、空字符串<code></code>或只有空白字符。
94 <pre>
95 StringUtil.isBlank（null） = false
96 StringUtil.isBlank（） = false
97 StringUtil.isBlank（ ） = false
98 StringUtil.isBlank（bob） = true
99 StringUtil.isBlank（ bob ） = true
100 </pre>
101
102 ＠param str 要搜检的字符串
103
104 ＠return 若是为空白， 则返回<code>true</code>
105 /
106 public static boolean isNotBlank（String str） {
107 int length;
108
109 if （（str == null） || （（length = str.length（）） == 0）） {
110 return false;
111 }
112
113 for （int i = 0; i < length; i++） {
114 if （!Character.isWhitespace（str.charAt（i））） {
115 return true;
116 }
117 }
118
119 return false;
120 }
121
122 / ============================================================================ /
123 / 默认值函数。 /
124 / /
125 / 当字符串为null、empty或blank时，将字符串转换成指定的默认字符串。 /
126 / ============================================================================ /
127
128 /
129 若是字符串是<code>null</code>，则返回空字符串<code></code>，不然返回字符串本身。
130 <pre>
131 StringUtil.defaultIfNull（null） =
132 StringUtil.defaultIfNull（） =
133 StringUtil.defaultIfNull（ ） =
134 StringUtil.defaultIfNull（bat） = bat
135 </pre>
136
137 ＠param str 要转换的字符串
138
139 ＠return 字符串本身或空字符串<code></code>
140 /
141 public static String defaultIfNull（String str） {
142 return （str == null） ？ EMPTY_STRING : str;
143 }
144
145 /
146 若是字符串是<code>null</code>，则返回指定默认字符串，不然返回字符串本身。
147 <pre>
148 StringUtil.defaultIfNull（null， default） = default
149 StringUtil.defaultIfNull（， default） =
150 StringUtil.defaultIfNull（ ， default） =
151 StringUtil.defaultIfNull（bat， default） = bat
152 </pre>
153
154 ＠param str 要转换的字符串
155 ＠param defaultStr 默认字符串
156
157 ＠return 字符串本身或指定的默认字符串
158 /
159 public static String defaultIfNull（String str， String defaultStr） {
160 return （str == null） ？ defaultStr : str;
161 }
162
163 /
164 若是字符串是<code>null</code>或空字符串<code></code>，则返回空字符串<code></code>，不然返回字符串本身。
165
166 <p>
167 此办法实际上和<code>defaultIfNull（String）</code>等效。
168 <pre>
169 StringUtil.defaultIfEmpty（null） =
170 StringUtil.defaultIfEmpty（） =
171 StringUtil.defaultIfEmpty（ ） =
172 StringUtil.defaultIfEmpty（bat） = bat
173 </pre>
174 </p>
175
176 ＠param str 要转换的字符串
177
178 ＠return 字符串本身或空字符串<code></code>
179 /
180 public static String defaultIfEmpty（String str） {
181 return （str == null） ？ EMPTY_STRING : str;
182 }
183
184 /
185 若是字符串是<code>null</code>或空字符串<code></code>，则返回指定默认字符串，不然返回字符串本身。
186 <pre>
187 StringUtil.defaultIfEmpty（null， default） = default
188 StringUtil.defaultIfEmpty（， default） = default
189 StringUtil.defaultIfEmpty（ ， default） =
190 StringUtil.defaultIfEmpty（bat， default） = bat
191 </pre>
192
193 ＠param str 要转换的字符串
194 ＠param defaultStr 默认字符串
195
196 ＠return 字符串本身或指定的默认字符串
197 /
198 public static String defaultIfEmpty（String str， String defaultStr） {
199 return （（str == null） || （str.length（） == 0）） ？ defaultStr : str;
200 }
201
202 /
203 若是字符串是空白：<code>null</code>、空字符串<code></code>或只有空白字符，则返回空字符串<code></code>，不然返回字符串本身。
204 <pre>
205 StringUtil.defaultIfBlank（null） =
206 StringUtil.defaultIfBlank（） =
207 StringUtil.defaultIfBlank（ ） =
208 StringUtil.defaultIfBlank（bat） = bat
209 </pre>
210
211 ＠param str 要转换的字符串
212
213 ＠return 字符串本身或空字符串<code></code>
214 /
215 public static String defaultIfBlank（String str） {
216 return isBlank（str） ？ EMPTY_STRING : str;
217 }
218
219 /
220 若是字符串是<code>null</code>或空字符串<code></code>，则返回指定默认字符串，不然返回字符串本身。
221 <pre>
222 StringUtil.defaultIfBlank（null， default） = default
223 StringUtil.defaultIfBlank（， default） = default
224 StringUtil.defaultIfBlank（ ， default） = default
225 StringUtil.defaultIfBlank（bat， default） = bat
226 </pre>
227
228 ＠param str 要转换的字符串
229 ＠param defaultStr 默认字符串
230
231 ＠return 字符串本身或指定的默认字符串
232 /
233 public static String defaultIfBlank（String str， String defaultStr） {
234 return isBlank（str） ？ defaultStr : str;
235 }
236
237 / ============================================================================ /
238 / 去空白（或指定字符）的函数。 /
239 / /
240 / 以下办法用来除去一个字串中的空白或指定字符。 /
241 / ============================================================================ /
242
243 /
244 除去字符串头尾部的空白，若是字符串是<code>null</code>，依然返回<code>null</code>。
245
246 <p>
247 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
248 因而可以除去英文字符集之外的其它空白，如中文空格。
249 <pre>
250 StringUtil.trim（null） = null
251 StringUtil.trim（） =
252 StringUtil.trim（ ） =
253 StringUtil.trim（abc） = abc
254 StringUtil.trim（ abc ） = abc
255 </pre>
256 </p>
257
258 ＠param str 要处理惩罚的字符串
259
260 ＠return 除去空白的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
261 /
262 public static String trim（String str） {
263 return trim（str， null， 0）;
264 }
265
266 /
267 除去字符串头尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
268 <pre>
269 StringUtil.trim（null， ） = null
270 StringUtil.trim（， ） =
271 StringUtil.trim（abc， null） = abc
272 StringUtil.trim（ abc， null） = abc
273 StringUtil.trim（abc ， null） = abc
274 StringUtil.trim（ abc ， null） = abc
275 StringUtil.trim（ abcyx， xyz） = abc
276 </pre>
277
278 ＠param str 要处理惩罚的字符串
279 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
280
281 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
282 /
283 public static String trim（String str， String stripChars） {
284 return trim（str， stripChars， 0）;
285 }
286
287 /
288 除去字符串头部的空白，若是字符串是<code>null</code>，则返回<code>null</code>。
289
290 <p>
291 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
292 因而可以除去英文字符集之外的其它空白，如中文空格。
293 <pre>
294 StringUtil.trimStart（null） = null
295 StringUtil.trimStart（） =
296 StringUtil.trimStart（abc） = abc
297 StringUtil.trimStart（ abc） = abc
298 StringUtil.trimStart（abc ） = abc
299 StringUtil.trimStart（ abc ） = abc
300 </pre>
301 </p>
302
303 ＠param str 要处理惩罚的字符串
304
305 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
306 /
307 public static String trimStart（String str） {
308 return trim（str， null， -1）;
309 }
310
311 /
312 除去字符串头部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
313 <pre>
314 StringUtil.trimStart（null， ） = null
315 StringUtil.trimStart（， ） =
316 StringUtil.trimStart（abc， ） = abc
317 StringUtil.trimStart（abc， null） = abc
318 StringUtil.trimStart（ abc， null） = abc
319 StringUtil.trimStart（abc ， null） = abc
320 StringUtil.trimStart（ abc ， null） = abc
321 StringUtil.trimStart（yxabc ， xyz） = abc
322 </pre>
323
324 ＠param str 要处理惩罚的字符串
325 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
326
327 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
328 /
329 public static String trimStart（String str， String stripChars） {
330 return trim（str， stripChars， -1）;
331 }
332
333 /
334 除去字符串尾部的空白，若是字符串是<code>null</code>，则返回<code>null</code>。
335
336 <p>
337 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
338 因而可以除去英文字符集之外的其它空白，如中文空格。
339 <pre>
340 StringUtil.trimEnd（null） = null
341 StringUtil.trimEnd（） =
342 StringUtil.trimEnd（abc） = abc
343 StringUtil.trimEnd（ abc） = abc
344 StringUtil.trimEnd（abc ） = abc
345 StringUtil.trimEnd（ abc ） = abc
346 </pre>
347 </p>
348
349 ＠param str 要处理惩罚的字符串
350
351 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
352 /
353 public static String trimEnd（String str） {
354 return trim（str， null， 1）;
355 }
356
357 /
358 除去字符串尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
359 <pre>
360 StringUtil.trimEnd（null， ） = null
361 StringUtil.trimEnd（， ） =
362 StringUtil.trimEnd（abc， ） = abc
363 StringUtil.trimEnd（abc， null） = abc
364 StringUtil.trimEnd（ abc， null） = abc
365 StringUtil.trimEnd（abc ， null） = abc
366 StringUtil.trimEnd（ abc ， null） = abc
367 StringUtil.trimEnd（ abcyx， xyz） = abc
368 </pre>
369
370 ＠param str 要处理惩罚的字符串
371 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
372
373 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
374 /
375 public static String trimEnd（String str， String stripChars） {
376 return trim（str， stripChars， 1）;
377 }
378
379 /
380 除去字符串头尾部的空白，若是成果字符串是空字符串<code></code>，则返回<code>null</code>。
381
382 <p>
383 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
384 因而可以除去英文字符集之外的其它空白，如中文空格。
385 <pre>
386 StringUtil.trimToNull（null） = null
387 StringUtil.trimToNull（） = null
388 StringUtil.trimToNull（ ） = null
389 StringUtil.trimToNull（abc） = abc
390 StringUtil.trimToNull（ abc ） = abc
391 </pre>
392 </p>
393
394 ＠param str 要处理惩罚的字符串
395
396 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
397 /
398 public static String trimToNull（String str） {
399 return trimToNull（str， null）;
400 }
401
402 /
403 除去字符串头尾部的空白，若是成果字符串是空字符串<code></code>，则返回<code>null</code>。
404
405 <p>
406 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
407 因而可以除去英文字符集之外的其它空白，如中文空格。
408 <pre>
409 StringUtil.trim（null， ） = null
410 StringUtil.trim（， ） = null
411 StringUtil.trim（abc， null） = abc
412 StringUtil.trim（ abc， null） = abc
413 StringUtil.trim（abc ， null） = abc
414 StringUtil.trim（ abc ， null） = abc
415 StringUtil.trim（ abcyx， xyz） = abc
416 </pre>
417 </p>
418
419 ＠param str 要处理惩罚的字符串
420 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
421
422 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
423 /
424 public static String trimToNull（String str， String stripChars） {
425 String result = trim（str， stripChars）;
426
427 if （（result == null） || （result.length（） == 0）） {
428 return null;
429 }
430
431 return result;
432 }
433
434 /
435 除去字符串头尾部的空白，若是字符串是<code>null</code>，则返回空字符串<code></code>。
436
437 <p>
438 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
439 因而可以除去英文字符集之外的其它空白，如中文空格。
440 <pre>
441 StringUtil.trimToEmpty（null） =
442 StringUtil.trimToEmpty（） =
443 StringUtil.trimToEmpty（ ） =
444 StringUtil.trimToEmpty（abc） = abc
445 StringUtil.trimToEmpty（ abc ） = abc
446 </pre>
447 </p>
448
449 ＠param str 要处理惩罚的字符串
450
451 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
452 /
453 public static String trimToEmpty（String str） {
454 return trimToEmpty（str， null）;
455 }
456
457 /
458 除去字符串头尾部的空白，若是字符串是<code>null</code>，则返回空字符串<code></code>。
459
460 <p>
461 重视，和<code>String.trim</code>不合，此办法应用<code>Character.isWhitespace</code>来剖断空白，
462 因而可以除去英文字符集之外的其它空白，如中文空格。
463 <pre>
464 StringUtil.trim（null， ） =
465 StringUtil.trim（， ） =
466 StringUtil.trim（abc， null） = abc
467 StringUtil.trim（ abc， null） = abc
468 StringUtil.trim（abc ， null） = abc
469 StringUtil.trim（ abc ， null） = abc
470 StringUtil.trim（ abcyx， xyz） = abc
471 </pre>
472 </p>
473
474 ＠param str 要处理惩罚的字符串
475
476 ＠return 除去空白的字符串，若是原字串为<code>null</code>或成果字符串为<code></code>，则返回<code>null</code>
477 /
478 public static String trimToEmpty（String str， String stripChars） {
479 String result = trim（str， stripChars）;
480
481 if （result == null） {
482 return EMPTY_STRING;
483 }
484
485 return result;
486 }
487
488 /
489 除去字符串头尾部的指定字符，若是字符串是<code>null</code>，依然返回<code>null</code>。
490 <pre>
491 StringUtil.trim（null， ） = null
492 StringUtil.trim（， ） =
493 StringUtil.trim（abc， null） = abc
494 StringUtil.trim（ abc， null） = abc
495 StringUtil.trim（abc ， null） = abc
496 StringUtil.trim（ abc ， null） = abc
497 StringUtil.trim（ abcyx， xyz） = abc
498 </pre>
499
500 ＠param str 要处理惩罚的字符串
501 ＠param stripChars 要除去的字符，若是为<code>null</code>默示除去空白字符
502 ＠param mode <code>-1</code>默示trimStart，<code>0</code>默示trim全部，<code>1</code>默示trimEnd
503
504 ＠return 除去指定字符后的的字符串，若是原字串为<code>null</code>，则返回<code>null</code>
505 /
506 private static String trim（String str， String stripChars， int mode） {
507 if （str == null） {
508 return null;
509 }
510
511 int length = str.length（）;
512 int start = 0;
513 int end = length;
514
515 // 扫描字符串头部
516 if （mode <= 0） {
517 if （stripChars == null） {
518 while （（start < end） && （Character.isWhitespace（str.charAt（start）））） {
519 start++;
520 }
521 } else if （stripChars.length（） == 0） {
522 return str;
523 } else {
524 while （（start < end） && （stripChars.indexOf（str.charAt（start）） != -1）） {
525 start++;
526 }
527 }
528 }
529
530 // 扫描字符串尾部
531 if （mode >= 0） {
532 if （stripChars == null） {
533 while （（start < end） && （Character.isWhitespace（str.charAt（end - 1）））） {
534 end--;
535 }
536 } else if （stripChars.length（） == 0） {
537 return str;
538 } else {
539 while （（start < end） && （stripChars.indexOf（str.charAt（end - 1）） != -1）） {
540 end--;
541 }
542 }
543 }
544
545 if （（start > 0） || （end < length）） {
546 return str.substring（start， end）;
547 }
548
549 return str;
550 }
551
552 / ============================================================================ /
553 / 斗劲函数。 /
554 / /
555 / 以下办法用来斗劲两个字符串是否雷同。 /
556 / ============================================================================ /
557
558 /
559 斗劲两个字符串（大小写敏感）。
560 <pre>
561 StringUtil.equals（null， null） = true
562 StringUtil.equals（null， abc） = false
563 StringUtil.equals（abc， null） = false
564 StringUtil.equals（abc， abc） = true
565 StringUtil.equals（abc， ABC） = false
566 </pre>
567
568 ＠param str1 要斗劲的字符串1
569 ＠param str2 要斗劲的字符串2
570
571 ＠return 若是两个字符串雷同，或者都是<code>null</code>，则返回<code>true</code>
572 /
573 public static boolean equals（String str1， String str2） {
574 if （str1 == null） {
575 return str2 == null;
576 }
577
578 return str1.equals（str2）;
579 }
580
581 /
582 斗劲两个字符串（大小写不敏感）。
583 <pre>
584 StringUtil.equalsIgnoreCase（null， null） = true
585 StringUtil.equalsIgnoreCase（null， abc） = false
586 StringUtil.equalsIgnoreCase（abc， null） = false
587 StringUtil.equalsIgnoreCase（abc， abc） = true
588 StringUtil.equalsIgnoreCase（abc， ABC） = true
589 </pre>
590
591 ＠param str1 要斗劲的字符串1
592 ＠param str2 要斗劲的字符串2
593
594 ＠return 若是两个字符串雷同，或者都是<code>null</code>，则返回<code>true</code>
595 /
596 public static boolean equalsIgnoreCase（String str1， String str2） {
597 if （str1 == null） {
598 return str2 == null;
599 }
600
601 return str1.equalsIgnoreCase（str2）;
602 }
603
604 / ============================================================================ /
605 / 字符串类型剖断函数。 /
606 / /
607 / 剖断字符串的类型是否为：字母、数字、空白等 /
608 / ============================================================================ /
609
610 /
611 断定字符串是否只包含unicode字母。
612
613 <p>
614 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
615 </p>
616 <pre>
617 StringUtil.isAlpha（null） = false
618 StringUtil.isAlpha（） = true
619 StringUtil.isAlpha（ ） = false
620 StringUtil.isAlpha（abc） = true
621 StringUtil.isAlpha（ab2c） = false
622 StringUtil.isAlpha（ab-c） = false
623 </pre>
624
625 ＠param str 要搜检的字符串
626
627 ＠return 若是字符串非<code>null</code>并且全由unicode字母构成，则返回<code>true</code>
628 /
629 public static boolean isAlpha（String str） {
630 if （str == null） {
631 return false;
632 }
633
634 int length = str.length（）;
635
636 for （int i = 0; i < length; i++） {
637 if （!Character.isLetter（str.charAt（i））） {
638 return false;
639 }
640 }
641
642 return true;
643 }
644
645 /
646 断定字符串是否只包含unicode字母和空格<code> </code>。
647
648 <p>
649 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
650 </p>
651 <pre>
652 StringUtil.isAlphaSpace（null） = false
653 StringUtil.isAlphaSpace（） = true
654 StringUtil.isAlphaSpace（ ） = true
655 StringUtil.isAlphaSpace（abc） = true
656 StringUtil.isAlphaSpace（ab c） = true
657 StringUtil.isAlphaSpace（ab2c） = false
658 StringUtil.isAlphaSpace（ab-c） = false
659 </pre>
660
661 ＠param str 要搜检的字符串
662
663 ＠return 若是字符串非<code>null</code>并且全由unicode字母和空格构成，则返回<code>true</code>
664 /
665 public static boolean isAlphaSpace（String str） {
666 if （str == null） {
667 return false;
668 }
669
670 int length = str.length（）;
671
672 for （int i = 0; i < length; i++） {
673 if （!Character.isLetter（str.charAt（i）） && （str.charAt（i） != ）） {
674 return false;
675 }
676 }
677
678 return true;
679 }
680
681 /
682 断定字符串是否只包含unicode字母和数字。
683
684 <p>
685 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
686 </p>
687 <pre>
688 StringUtil.isAlphanumeric（null） = false
689 StringUtil.isAlphanumeric（） = true
690 StringUtil.isAlphanumeric（ ） = false
691 StringUtil.isAlphanumeric（abc） = true
692 StringUtil.isAlphanumeric（ab c） = false
693 StringUtil.isAlphanumeric（ab2c） = true
694 StringUtil.isAlphanumeric（ab-c） = false
695 </pre>
696
697 ＠param str 要搜检的字符串
698
699 ＠return 若是字符串非<code>null</code>并且全由unicode字母数字构成，则返回<code>true</code>
700 /
701 public static boolean isAlphanumeric（String str） {
702 if （str == null） {
703 return false;
704 }
705
706 int length = str.length（）;
707
708 for （int i = 0; i < length; i++） {
709 if （!Character.isLetterOrDigit（str.charAt（i））） {
710 return false;
711 }
712 }
713
714 return true;
715 }
716
717 /
718 断定字符串是否只包含unicode字母数字和空格<code> </code>。
719
720 <p>
721 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
722 </p>
723 <pre>
724 StringUtil.isAlphanumericSpace（null） = false
725 StringUtil.isAlphanumericSpace（） = true
726 StringUtil.isAlphanumericSpace（ ） = true
727 StringUtil.isAlphanumericSpace（abc） = true
728 StringUtil.isAlphanumericSpace（ab c） = true
729 StringUtil.isAlphanumericSpace（ab2c） = true
730 StringUtil.isAlphanumericSpace（ab-c） = false
731 </pre>
732
733 ＠param str 要搜检的字符串
734
735 ＠return 若是字符串非<code>null</code>并且全由unicode字母数字和空格构成，则返回<code>true</code>
736 /
737 public static boolean isAlphanumericSpace（String str） {
738 if （str == null） {
739 return false;
740 }
741
742 int length = str.length（）;
743
744 for （int i = 0; i < length; i++） {
745 if （!Character.isLetterOrDigit（str.charAt（i）） && （str.charAt（i） != ）） {
746 return false;
747 }
748 }
749
750 return true;
751 }
752
753 /
754 断定字符串是否只包含unicode数字。
755
756 <p>
757 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
758 </p>
759 <pre>
760 StringUtil.isNumeric（null） = false
761 StringUtil.isNumeric（） = true
762 StringUtil.isNumeric（ ） = false
763 StringUtil.isNumeric（123） = true
764 StringUtil.isNumeric（12 3） = false
765 StringUtil.isNumeric（ab2c） = false
766 StringUtil.isNumeric（12-3） = false
767 StringUtil.isNumeric（12.3） = false
768 </pre>
769
770 ＠param str 要搜检的字符串
771
772 ＠return 若是字符串非<code>null</code>并且全由unicode数字构成，则返回<code>true</code>
773 /
774 public static boolean isNumeric（String str） {
775 if （str == null） {
776 return false;
777 }
778
779 int length = str.length（）;
780
781 for （int i = 0; i < length; i++） {
782 if （!Character.isDigit（str.charAt（i））） {
783 return false;
784 }
785 }
786
787 return true;
788 }
789
790 /
791 断定字符串是否只包含unicode数字，包含小数。
792
793 <p>
794 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
795 </p>
796 <pre>
797 StringUtil.isNumeric（null） = false
798 StringUtil.isNumeric（） = false
799 StringUtil.isNumeric（ ） = false
800 StringUtil.isNumeric（123） = true
801 StringUtil.isNumeric（12 3） = false
802 StringUtil.isNumeric（ab2c） = false
803 StringUtil.isNumeric（12-3） = false
804 StringUtil.isNumeric（12.3） = true
805 </pre>
806
807 ＠param str 要搜检的字符串
808
809 ＠return 若是字符串非<code>null</code>并且全由unicode数字构成，则返回<code>true</code>
810 /
811 public static boolean isNumber（String str） {
812 if （isBlank（str）） {
813 return false;
814 }
815 int index = str.indexOf（.）;
816 if （index < 0） {
817 return isNumeric（str）;
818 } else {
819 String num1 = str.substring（0， index）;
820 String num2 = str.substring（index + 1）;
821 return isNumeric（num1） && isNumeric（num2）;
822 }
823 }
824
825
826 /
827 断定字符串是否只包含unicode数字和空格<code> </code>。
828
829 <p>
830 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
831 </p>
832 <pre>
833 StringUtil.isNumericSpace（null） = false
834 StringUtil.isNumericSpace（） = true
835 StringUtil.isNumericSpace（ ） = true
836 StringUtil.isNumericSpace（123） = true
837 StringUtil.isNumericSpace（12 3） = true
838 StringUtil.isNumericSpace（ab2c） = false
839 StringUtil.isNumericSpace（12-3） = false
840 StringUtil.isNumericSpace（12.3） = false
841 </pre>
842
843 ＠param str 要搜检的字符串
844
845 ＠return 若是字符串非<code>null</code>并且全由unicode数字和空格构成，则返回<code>true</code>
846 /
847 public static boolean isNumericSpace（String str） {
848 if （str == null） {
849 return false;
850 }
851
852 int length = str.length（）;
853
854 for （int i = 0; i < length; i++） {
855 if （!Character.isDigit（str.charAt（i）） && （str.charAt（i） != ）） {
856 return false;
857 }
858 }
859
860 return true;
861 }
862
863 /
864 断定字符串是否只包含unicode空白。
865
866 <p>
867 <code>null</code>将返回<code>false</code>，空字符串<code></code>将返回<code>true</code>。
868 </p>
869 <pre>
870 StringUtil.isWhitespace（null） = false
871 StringUtil.isWhitespace（） = true
872 StringUtil.isWhitespace（ ） = true
873 StringUtil.isWhitespace（abc） = false
874 StringUtil.isWhitespace（ab2c） = false
875 StringUtil.isWhitespace（ab-c） = false
876 </pre>
877
878 ＠param str 要搜检的字符串
879
880 ＠return 若是字符串非<code>null</code>并且全由unicode空白构成，则返回<code>true</code>
881 /
882 public static boolean isWhitespace（String str） {
883 if （str == null） {
884 return false;
885 }
886
887 int length = str.length（）;
888
889 for （int i = 0; i < length; i++） {
890 if （!Character.isWhitespace（str.charAt（i））） {
891 return false;
892 }
893 }
894
895 return true;
896 }
897
898 / ============================================================================ /
899 / 大小写转换。 /
900 / ============================================================================ /
901
902 /
903 将字符串转换成大写。
904
905 <p>
906 若是字符串是<code>null</code>则返回<code>null</code>。
907 <pre>
908 StringUtil.toUpperCase（null） = null
909 StringUtil.toUpperCase（） =
910 StringUtil.toUpperCase（aBc） = ABC
911 </pre>
912 </p>
913
914 ＠param str 要转换的字符串
915
916 ＠return 大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
917 /
918 public static String toUpperCase（String str） {
919 if （str == null） {
920 return null;
921 }
922
923 return str.toUpperCase（）;
924 }
925
926 /
927 将字符串转换成小写。
928
929 <p>
930 若是字符串是<code>null</code>则返回<code>null</code>。
931 <pre>
932 StringUtil.toLowerCase（null） = null
933 StringUtil.toLowerCase（） =
934 StringUtil.toLowerCase（aBc） = abc
935 </pre>
936 </p>
937
938 ＠param str 要转换的字符串
939
940 ＠return 大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
941 /
942 public static String toLowerCase（String str） {
943 if （str == null） {
944 return null;
945 }
946
947 return str.toLowerCase（）;
948 }
949
950 /
951 将字符串的首字符转成大写（<code>Character.toTitleCase</code>），其它字符不变。
952
953 <p>
954 若是字符串是<code>null</code>则返回<code>null</code>。
955 <pre>
956 StringUtil.capitalize（null） = null
957 StringUtil.capitalize（） =
958 StringUtil.capitalize（cat） = Cat
959 StringUtil.capitalize（cAt） = CAt
960 </pre>
961 </p>
962
963 ＠param str 要转换的字符串
964
965 ＠return 首字符为大写的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
966 /
967 public static String capitalize（String str） {
968 int strLen;
969
970 if （（str == null） || （（strLen = str.length（）） == 0）） {
971 return str;
972 }
973
974 return new StringBuffer（strLen）.append（Character.toTitleCase（str.charAt（0）））.append（
975 str.substring（1））.toString（）;
976 }
977
978 /
979 将字符串的首字符转成小写，其它字符不变。
980
981 <p>
982 若是字符串是<code>null</code>则返回<code>null</code>。
983 <pre>
984 StringUtil.uncapitalize（null） = null
985 StringUtil.uncapitalize（） =
986 StringUtil.uncapitalize（Cat） = cat
987 StringUtil.uncapitalize（CAT） = cAT
988 </pre>
989 </p>
990
991 ＠param str 要转换的字符串
992
993 ＠return 首字符为小写的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
994 /
995 public static String uncapitalize（String str） {
996 int strLen;
997
998 if （（str == null） || （（strLen = str.length（）） == 0）） {
999 return str;
1000 }
1001
1002 return new StringBuffer（strLen）.append（Character.toLowerCase（str.charAt（0）））.append（
1003 str.substring（1））.toString（）;
1004 }
1005
1006 /
1007 反转字符串的大小写。
1008
1009 <p>
1010 若是字符串是<code>null</code>则返回<code>null</code>。
1011 <pre>
1012 StringUtil.swapCase（null） = null
1013 StringUtil.swapCase（） =
1014 StringUtil.swapCase（The dog has a BONE） = tHE DOG HAS A bone
1015 </pre>
1016 </p>
1017
1018 ＠param str 要转换的字符串
1019
1020 ＠return 大小写被反转的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1021 /
1022 public static String swapCase（String str） {
1023 int strLen;
1024
1025 if （（str == null） || （（strLen = str.length（）） == 0）） {
1026 return str;
1027 }
1028
1029 StringBuffer buffer = new StringBuffer（strLen）;
1030
1031 char ch = 0;
1032
1033 for （int i = 0; i < strLen; i++） {
1034 ch = str.charAt（i）;
1035
1036 if （Character.isUpperCase（ch）） {
1037 ch = Character.toLowerCase（ch）;
1038 } else if （Character.isTitleCase（ch）） {
1039 ch = Character.toLowerCase（ch）;
1040 } else if （Character.isLowerCase（ch）） {
1041 ch = Character.toUpperCase（ch）;
1042 }
1043
1044 buffer.append（ch）;
1045 }
1046
1047 return buffer.toString（）;
1048 }
1049
1050 /
1051 将字符串转换成camel case。
1052
1053 <p>
1054 若是字符串是<code>null</code>则返回<code>null</code>。
1055 <pre>
1056 StringUtil.toCamelCase（null） = null
1057 StringUtil.toCamelCase（） =
1058 StringUtil.toCamelCase（aBc） = aBc
1059 StringUtil.toCamelCase（aBc def） = aBcDef
1060 StringUtil.toCamelCase（aBc def_ghi） = aBcDefGhi
1061 StringUtil.toCamelCase（aBc def_ghi 123） = aBcDefGhi123
1062 </pre>
1063 </p>
1064
1065 <p>
1066 此办保存除了下划线和空白以外的所有分隔符。
1067 </p>
1068
1069 ＠param str 要转换的字符串
1070
1071 ＠return camel case字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1072 /
1073 public static String toCamelCase（String str） {
1074 return CAMEL_CASE_TOKENIZER.parse（str）;
1075 }
1076
1077 /
1078 将字符串转换成pascal case。
1079
1080 <p>
1081 若是字符串是<code>null</code>则返回<code>null</code>。
1082 <pre>
1083 StringUtil.toPascalCase（null） = null
1084 StringUtil.toPascalCase（） =
1085 StringUtil.toPascalCase（aBc） = ABc
1086 StringUtil.toPascalCase（aBc def） = ABcDef
1087 StringUtil.toPascalCase（aBc def_ghi） = ABcDefGhi
1088 StringUtil.toPascalCase（aBc def_ghi 123） = aBcDefGhi123
1089 </pre>
1090 </p>
1091
1092 <p>
1093 此办保存除了下划线和空白以外的所有分隔符。
1094 </p>
1095
1096 ＠param str 要转换的字符串
1097
1098 ＠return pascal case字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1099 /
1100 public static String toPascalCase（String str） {
1101 return PASCAL_CASE_TOKENIZER.parse（str）;
1102 }
1103
1104 /
1105 将字符串转换成下划线分隔的大写字符串。
1106
1107 <p>
1108 若是字符串是<code>null</code>则返回<code>null</code>。
1109 <pre>
1110 StringUtil.toUpperCaseWithUnderscores（null） = null
1111 StringUtil.toUpperCaseWithUnderscores（） =
1112 StringUtil.toUpperCaseWithUnderscores（aBc） = A_BC
1113 StringUtil.toUpperCaseWithUnderscores（aBc def） = A_BC_DEF
1114 StringUtil.toUpperCaseWithUnderscores（aBc def_ghi） = A_BC_DEF_GHI
1115 StringUtil.toUpperCaseWithUnderscores（aBc def_ghi 123） = A_BC_DEF_GHI_123
1116 StringUtil.toUpperCaseWithUnderscores（__a__Bc__） = __A__BC__
1117 </pre>
1118 </p>
1119
1120 <p>
1121 此办保存除了空白以外的所有分隔符。
1122 </p>
1123
1124 ＠param str 要转换的字符串
1125
1126 ＠return 下划线分隔的大写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1127 /
1128 public static String toUpperCaseWithUnderscores（String str） {
1129 return UPPER_CASE_WITH_UNDERSCORES_TOKENIZER.parse（str）;
1130 }
1131
1132 /
1133 将字符串转换成下划线分隔的小写字符串。
1134
1135 <p>
1136 若是字符串是<code>null</code>则返回<code>null</code>。
1137 <pre>
1138 StringUtil.toLowerCaseWithUnderscores（null） = null
1139 StringUtil.toLowerCaseWithUnderscores（） =
1140 StringUtil.toLowerCaseWithUnderscores（aBc） = a_bc
1141 StringUtil.toLowerCaseWithUnderscores（aBc def） = a_bc_def
1142 StringUtil.toLowerCaseWithUnderscores（aBc def_ghi） = a_bc_def_ghi
1143 StringUtil.toLowerCaseWithUnderscores（aBc def_ghi 123） = a_bc_def_ghi_123
1144 StringUtil.toLowerCaseWithUnderscores（__a__Bc__） = __a__bc__
1145 </pre>
1146 </p>
1147
1148 <p>
1149 此办保存除了空白以外的所有分隔符。
1150 </p>
1151
1152 ＠param str 要转换的字符串
1153
1154 ＠return 下划线分隔的小写字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
1155 /
1156 public static String toLowerCaseWithUnderscores（String str） {
1157 return LOWER_CASE_WITH_UNDERSCORES_TOKENIZER.parse（str）;
1158 }
1159
1160 / 解析单词的解析器。 /
1161 private static final WordTokenizer CAMEL_CASE_TOKENIZER = new WordTokenizer（） {
1162 protected void startSentence（
1163 StringBuffer buffer，
1164 char ch） {
1165 buffer
1166 .append（Character
1167 .toLowerCase（ch））;
1168 }
1169
1170 protected void startWord（
1171 StringBuffer buffer，
1172 char ch） {
1173 if （!isDelimiter（buffer
1174 .charAt（buffer
1175 .length（） - 1））） {
1176 buffer
1177 .append（Character
1178 .toUpperCase（ch））;
1179 } else {
1180 buffer
1181 .append（Character
1182 .toLowerCase（ch））;
1183 }
1184 }
1185
1186 protected void inWord（
1187 StringBuffer buffer，
1188 char ch） {
1189 buffer
1190 .append（Character
1191 .toLowerCase（ch））;
1192 }
1193
1194 protected void startDigitSentence（
1195 StringBuffer buffer，
1196 char ch） {
1197 buffer
1198 .append（ch）;
1199 }
1200
1201 protected void startDigitWord（
1202 StringBuffer buffer，
1203 char ch） {
1204 buffer
1205 .append（ch）;
1206 }
1207
1208 protected void inDigitWord（
1209 StringBuffer buffer，
1210 char ch） {
1211 buffer
1212 .append（ch）;
1213 }
1214
1215 protected void inDelimiter（
1216 StringBuffer buffer，
1217 char ch） {
1218 if （ch != UNDERSCORE） {
1219 buffer
1220 .append（ch）;
1221 }
1222 }
1223 };
1224
1225 private static final WordTokenizer PASCAL_CASE_TOKENIZER = new WordTokenizer（） {
1226 protected void startSentence（
1227 StringBuffer buffer，
1228 char ch） {
1229 buffer
1230 .append（Character
1231 .toUpperCase（ch））;
1232 }
1233
1234 protected void startWord（
1235 StringBuffer buffer，
1236 char ch） {
1237 buffer
1238 .append（Character
1239 .toUpperCase（ch））;
1240 }
1241
1242 protected void inWord（
1243 StringBuffer buffer，
1244 char ch） {
1245 buffer
1246 .append（Character
1247 .toLowerCase（ch））;
1248 }
1249
1250 protected void startDigitSentence（
1251 StringBuffer buffer，
1252 char ch） {
1253 buffer
1254 .append（ch）;
1255 }
1256
1257 protected void startDigitWord（
1258 StringBuffer buffer，
1259 char ch） {
1260 buffer
1261 .append（ch）;
1262 }
1263
1264 protected void inDigitWord（
1265 StringBuffer buffer，
1266 char ch） {
1267 buffer
1268 .append（ch）;
1269 }
1270
1271 protected void inDelimiter（
1272 StringBuffer buffer，
1273 char ch） {
1274 if （ch != UNDERSCORE） {
1275 buffer
1276 .append（ch）;
1277 }
1278 }
1279 };
1280
1281 private static final WordTokenizer UPPER_CASE_WITH_UNDERSCORES_TOKENIZER = new WordTokenizer（） {
1282 protected void startSentence（
1283 StringBuffer buffer，
1284 char ch） {
1285 buffer
1286 .append（Character
1287 .toUpperCase（ch））;
1288 }
1289
1290 protected void startWord（
1291 StringBuffer buffer，
1292 char ch） {
1293 if （!isDelimiter（buffer
1294 .charAt（buffer
1295 .length（） - 1））） {
1296 buffer
1297 .append（UNDERSCORE）;
1298 }
1299
1300 buffer
1301 .append（Character
1302 .toUpperCase（ch））;
1303 }
1304
1305 protected void inWord（
1306 StringBuffer buffer，
1307 char ch） {
1308 buffer
1309 .append（Character
1310 .toUpperCase（ch））;
1311 }
1312
1313 protected void startDigitSentence（
1314 StringBuffer buffer，
1315 char ch） {
1316 buffer
1317 .append（ch）;
1318 }
1319
1320 protected void startDigitWord（
1321 StringBuffer buffer，
1322 char ch） {
1323 if （!isDelimiter（buffer
1324 .charAt（buffer
1325 .length（） - 1））） {
1326 buffer
1327 .append（UNDERSCORE）;
1328 }
1329
1330 buffer
1331 .append（ch）;
1332 }
1333
1334 protected void inDigitWord（
1335 StringBuffer buffer，
1336 char ch） {
1337 buffer
1338 .append（ch）;
1339 }
1340
1341 protected void inDelimiter（
1342 StringBuffer buffer，
1343 char ch） {
1344 buffer
1345 .append（ch）;
1346 }
1347 };
1348
1349 private static final WordTokenizer LOWER_CASE_WITH_UNDERSCORES_TOKENIZER = new WordTokenizer（） {
1350 protected void startSentence（
1351 StringBuffer buffer，
1352 char ch） {
1353 buffer
1354 .append（Character
1355 .toLowerCase（ch））;
1356 }
1357
1358 protected void startWord（
1359 StringBuffer buffer，
1360 char ch） {
1361 if （!isDelimiter（buffer
1362 .charAt（buffer
1363 .length（） - 1））） {
1364 buffer
1365 .append（UNDERSCORE）;
1366 }
1367
1368 buffer
1369 .append（Character
1370 .toLowerCase（ch））;
1371 }
1372
1373 protected void inWord（
1374 StringBuffer buffer，
1375 char ch） {
1376 buffer
1377 .append（Character
1378 .toLowerCase（ch））;
1379 }
1380
1381 protected void startDigitSentence（
1382 StringBuffer buffer，
1383 char ch） {
1384 buffer
1385 .append（ch）;
1386 }
1387
1388 protected void startDigitWord（
1389 StringBuffer buffer，
1390 char ch） {
1391 if （!isDelimiter（buffer
1392 .charAt（buffer
1393 .length（） - 1））） {
1394 buffer
1395 .append（UNDERSCORE）;
1396 }
1397
1398 buffer
1399 .append（ch）;
1400 }
1401
1402 protected void inDigitWord（
1403 StringBuffer buffer，
1404 char ch） {
1405 buffer
1406 .append（ch）;
1407 }
1408
1409 protected void inDelimiter（
1410 StringBuffer buffer，
1411 char ch） {
1412 buffer
1413 .append（ch）;
1414 }
1415 };
1416
1417 /
1418 解析出下列语法所构成的<code>SENTENCE</code>。
1419 <pre>
1420 SENTENCE = WORD （DELIMITER WORD）
1421
1422 WORD = UPPER_CASE_WORD | LOWER_CASE_WORD | TITLE_CASE_WORD | DIGIT_WORD
1423
1424 UPPER_CASE_WORD = UPPER_CASE_LETTER+
1425 LOWER_CASE_WORD = LOWER_CASE_LETTER+
1426 TITLE_CASE_WORD = UPPER_CASE_LETTER LOWER_CASE_LETTER+
1427 DIGIT_WORD = DIGIT+
1428
1429 UPPER_CASE_LETTER = Character.isUpperCase（）
1430 LOWER_CASE_LETTER = Character.isLowerCase（）
1431 DIGIT = Character.isDigit（）
1432 NON_LETTER_DIGIT = !Character.isUpperCase（） && !Character.isLowerCase（） && !Character.isDigit（）
1433
1434 DELIMITER = WHITESPACE | NON_LETTER_DIGIT
1435 </pre>
1436 /
1437 private abstract static class WordTokenizer {
1438 protected static final char UNDERSCORE = _;
1439
1440 /
1441 Parse sentence。
1442 /
1443 public String parse（String str） {
1444 if （StringUtil.isEmpty（str）） {
1445 return str;
1446 }
1447
1448 int length = str.length（）;
1449 StringBuffer buffer = new StringBuffer（length）;
1450
1451 for （int index = 0; index < length; index++） {
1452 char ch = str.charAt（index）;
1453
1454 // 忽视空白。
1455 if （Character.isWhitespace（ch）） {
1456 continue;
1457 }
1458
1459 // 大写字母开端：UpperCaseWord或是TitleCaseWord。
1460 if （Character.isUpperCase（ch）） {
1461 int wordIndex = index + 1;
1462
1463 while （wordIndex < length） {
1464 char wordChar = str.charAt（wordIndex）;
1465
1466 if （Character.isUpperCase（wordChar）） {
1467 wordIndex++;
1468 } else if （Character.isLowerCase（wordChar）） {
1469 wordIndex--;
1470 break;
1471 } else {
1472 break;
1473 }
1474 }
1475
1476 // 1. wordIndex == length，申明最后一个字母为大写，以upperCaseWord处理惩罚之。
1477 // 2. wordIndex == index，申明index处为一个titleCaseWord。
1478 // 3. wordIndex > index，申明index到wordIndex - 1处全部是大写，以upperCaseWord处理惩罚。
1479 if （（wordIndex == length） || （wordIndex > index）） {
1480 index = parseUpperCaseWord（buffer， str， index， wordIndex）;
1481 } else {
1482 index = parseTitleCaseWord（buffer， str， index）;
1483 }
1484
1485 continue;
1486 }
1487
1488 // 小写字母开端：LowerCaseWord。
1489 if （Character.isLowerCase（ch）） {
1490 index = parseLowerCaseWord（buffer， str， index）;
1491 continue;
1492 }
1493
1494 // 数字开端：DigitWord。
1495 if （Character.isDigit（ch）） {
1496 index = parseDigitWord（buffer， str， index）;
1497 continue;
1498 }
1499
1500 // 非字母数字开端：Delimiter。
1501 inDelimiter（buffer， ch）;
1502 }
1503
1504 return buffer.toString（）;
1505 }
1506
1507 private int parseUpperCaseWord（StringBuffer buffer， String str， int index， int length） {
1508 char ch = str.charAt（index++）;
1509
1510 // 首字母，必定存在且为大写。
1511 if （buffer.length（） == 0） {
1512 startSentence（buffer， ch）;
1513 } else {
1514 startWord（buffer， ch）;
1515 }
1516
1517 // 后续字母，必为小写。
1518 for （; index < length; index++） {
1519 ch = str.charAt（index）;
1520 inWord（buffer， ch）;
1521 }
1522
1523 return index - 1;
1524 }
1525
1526 private int parseLowerCaseWord（StringBuffer buffer， String str， int index） {
1527 char ch = str.charAt（index++）;
1528
1529 // 首字母，必定存在且为小写。
1530 if （buffer.length（） == 0） {
1531 startSentence（buffer， ch）;
1532 } else {
1533 startWord（buffer， ch）;
1534 }
1535
1536 // 后续字母，必为小写。
1537 int length = str.length（）;
1538
1539 for （; index < length; index++） {
1540 ch = str.charAt（index）;
1541
1542 if （Character.isLowerCase（ch）） {
1543 inWord（buffer， ch）;
1544 } else {
1545 break;
1546 }
1547 }
1548
1549 return index - 1;
1550 }
1551
1552 private int parseTitleCaseWord（StringBuffer buffer， String str， int index） {
1553 char ch = str.charAt（index++）;
1554
1555 // 首字母，必定存在且为大写。
1556 if （buffer.length（） == 0） {
1557 startSentence（buffer， ch）;
1558 } else {
1559 startWord（buffer， ch）;
1560 }
1561
1562 // 后续字母，必为小写。
1563 int length = str.length（）;
1564
1565 for （; index < length; index++） {
1566 ch = str.charAt（index）;
1567
1568 if （Character.isLowerCase（ch）） {
1569 inWord（buffer， ch）;
1570 } else {
1571 break;
1572 }
1573 }
1574
1575 return index - 1;
1576 }
1577
1578 private int parseDigitWord（StringBuffer buffer， String str， int index） {
1579 char ch = str.charAt（index++）;
1580
1581 // 首字符，必定存在且为数字。
1582 if （buffer.length（） == 0） {
1583 startDigitSentence（buffer， ch）;
1584 } else {
1585 startDigitWord（buffer， ch）;
1586 }
1587
1588 // 后续字符，必为数字。
1589 int length = str.length（）;
1590
1591 for （; index < length; index++） {
1592 ch = str.charAt（index）;
1593
1594 if （Character.isDigit（ch）） {
1595 inDigitWord（buffer， ch）;
1596 } else {
1597 break;
1598 }
1599 }
1600
1601 return index - 1;
1602 }
1603
1604 protected boolean isDelimiter（char ch） {
1605 return !Character.isUpperCase（ch） && !Character.isLowerCase（ch）
1606 && !Character.isDigit（ch）;
1607 }
1608
1609 protected abstract void startSentence（StringBuffer buffer， char ch）;
1610
1611 protected abstract void startWord（StringBuffer buffer， char ch）;
1612
1613 protected abstract void inWord（StringBuffer buffer， char ch）;
1614
1615 protected abstract void startDigitSentence（StringBuffer buffer， char ch）;
1616
1617 protected abstract void startDigitWord（StringBuffer buffer， char ch）;
1618
1619 protected abstract void inDigitWord（StringBuffer buffer， char ch）;
1620
1621 protected abstract void inDelimiter（StringBuffer buffer， char ch）;
1622 }
1623
1624 / ============================================================================ /
1625 / 字符串分别函数。 /
1626 / /
1627 / 将字符串按指定分隔符分别。 /
1628 / ============================================================================ /
1629
1630 /
1631 将字符串按空白字符分别。
1632
1633 <p>
1634 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1635 <pre>
1636 StringUtil.split（null） = null
1637 StringUtil.split（） = []
1638 StringUtil.split（abc def） = [abc， def]
1639 StringUtil.split（abc def） = [abc， def]
1640 StringUtil.split（ abc ） = [abc]
1641 </pre>
1642 </p>
1643
1644 ＠param str 要分别的字符串
1645
1646 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1647 /
1648 public static String[] split（String str） {
1649 return split（str， null， -1）;
1650 }
1651
1652 /
1653 将字符串按指定字符分别。
1654
1655 <p>
1656 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1657 <pre>
1658 StringUtil.split（null， ） = null
1659 StringUtil.split（， ） = []
1660 StringUtil.split（a.b.c， .） = [a， b， c]
1661 StringUtil.split（a..b.c， .） = [a， b， c]
1662 StringUtil.split（a:b:c， .） = [a:b:c]
1663 StringUtil.split（a b c， ） = [a， b， c]
1664 </pre>
1665 </p>
1666
1667 ＠param str 要分别的字符串
1668 ＠param separatorChar 分隔符
1669
1670 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1671 /
1672 public static String[] split（String str， char separatorChar） {
1673 if （str == null） {
1674 return null;
1675 }
1676
1677 int length = str.length（）;
1678
1679 if （length == 0） {
1680 return ArrayUtil.EMPTY_STRING_ARRAY;
1681 }
1682
1683 List list = new ArrayList（）;
1684 int i = 0;
1685 int start = 0;
1686 boolean match = false;
1687
1688 while （i < length） {
1689 if （str.charAt（i） == separatorChar） {
1690 if （match） {
1691 list.add（str.substring（start， i））;
1692 match = false;
1693 }
1694
1695 start = ++i;
1696 continue;
1697 }
1698
1699 match = true;
1700 i++;
1701 }
1702
1703 if （match） {
1704 list.add（str.substring（start， i））;
1705 }
1706
1707 return （String[]） list.toArray（new String[list.size（）]）;
1708 }
1709
1710 /
1711 将字符串按指定字符分别。
1712
1713 <p>
1714 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1715 <pre>
1716 StringUtil.split（null， ） = null
1717 StringUtil.split（， ） = []
1718 StringUtil.split（abc def， null） = [abc， def]
1719 StringUtil.split（abc def， ） = [abc， def]
1720 StringUtil.split（abc def， ） = [abc， def]
1721 StringUtil.split（ ab: cd::ef ， :） = [ab， cd， ef]
1722 StringUtil.split（abc.def， ） = [abc.def]
1723 </pre>
1724 </p>
1725
1726 ＠param str 要分别的字符串
1727 ＠param separatorChars 分隔符
1728
1729 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1730 /
1731 public static String[] split（String str， String separatorChars） {
1732 return split（str， separatorChars， -1）;
1733 }
1734
1735 /
1736 将字符串按指定字符分别。
1737
1738 <p>
1739 分隔符不会呈如今目标数组中，连气儿的分隔符就被看作一个。若是字符串为<code>null</code>，则返回<code>null</code>。
1740 <pre>
1741 StringUtil.split（null， ， ） = null
1742 StringUtil.split（， ， ） = []
1743 StringUtil.split（ab cd ef， null， 0） = [ab， cd， ef]
1744 StringUtil.split（ ab cd ef ， null， 0） = [ab， cd， ef]
1745 StringUtil.split（ab:cd::ef， :， 0） = [ab， cd， ef]
1746 StringUtil.split（ab:cd:ef， :， 2） = [ab， cdef]
1747 StringUtil.split（abc.def， ， 2） = [abc.def]
1748 </pre>
1749 </p>
1750
1751 ＠param str 要分别的字符串
1752 ＠param separatorChars 分隔符
1753 ＠param max 返回的数组的最大个数，若是小于便是0，则默示无穷制
1754
1755 ＠return 分别后的字符串数组，若是原字符串为<code>null</code>，则返回<code>null</code>
1756 /
1757 public static String[] split（String str， String separatorChars， int max） {
1758 if （str == null） {
1759 return null;
1760 }
1761
1762 int length = str.length（）;
1763
1764 if （length == 0） {
1765 return ArrayUtil.EMPTY_STRING_ARRAY;
1766 }
1767
1768 List list = new ArrayList（）;
1769 int sizePlus1 = 1;
1770 int i = 0;
1771 int start = 0;
1772 boolean match = false;
1773
1774 if （separatorChars == null） {
1775 // null默示应用空白作为分隔符
1776 while （i < length） {
1777 if （Character.isWhitespace（str.charAt（i））） {
1778 if （match） {
1779 if （sizePlus1++ == max） {
1780 i = length;
1781 }
1782
1783 list.add（str.substring（start， i））;
1784 match = false;
1785 }
1786
1787 start = ++i;
1788 continue;
1789 }
1790
1791 match = true;
1792 i++;
1793 }
1794 } else if （separatorChars.length（） == 1） {
1795 // 优化分隔符长度为1的景象
1796 char sep = separatorChars.charAt（0）;
1797
1798 while （i < length） {
1799 if （str.charAt（i） == sep） {
1800 if （match） {
1801 if （sizePlus1++ == max） {
1802 i = length;
1803 }
1804
1805 list.add（str.substring（start， i））;
1806 match = false;
1807 }
1808
1809 start = ++i;
1810 continue;
1811 }
1812
1813 match = true;
1814 i++;
1815 }
1816 } else {
1817 // 一般景象
1818 while （i < length） {
1819 if （separatorChars.indexOf（str.charAt（i）） >= 0） {
1820 if （match） {
1821 if （sizePlus1++ == max） {
1822 i = length;
1823 }
1824
1825 list.add（str.substring（start， i））;
1826 match = false;
1827 }
1828
1829 start = ++i;
1830 continue;
1831 }
1832
1833 match = true;
1834 i++;
1835 }
1836 }
1837
1838 if （match） {
1839 list.add（str.substring（start， i））;
1840 }
1841
1842 return （String[]） list.toArray（new String[list.size（）]）;
1843 }
1844
1845 / ============================================================================ /
1846 / 字符串连接函数。 /
1847 / /
1848 / 将多个对象按指定分隔符连接成字符串。 /
1849 / ============================================================================ /
1850
1851 /
1852 将数组中的元素连接成一个字符串。
1853 <pre>
1854 StringUtil.join（null） = null
1855 StringUtil.join（[]） =
1856 StringUtil.join（[null]） =
1857 StringUtil.join（[a， b， c]） = abc
1858 StringUtil.join（[null， ， a]） = a
1859 </pre>
1860
1861 ＠param array 要连接的数组
1862
1863 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1864 /
1865 public static String join（Object[] array） {
1866 return join（array， null）;
1867 }
1868
1869 /
1870 将数组中的元素连接成一个字符串。
1871 <pre>
1872 StringUtil.join（null， ） = null
1873 StringUtil.join（[]， ） =
1874 StringUtil.join（[null]， ） =
1875 StringUtil.join（[a， b， c]， ;） = a;b;c
1876 StringUtil.join（[a， b， c]， null） = abc
1877 StringUtil.join（[null， ， a]， ;） = ;;a
1878 </pre>
1879
1880 ＠param array 要连接的数组
1881 ＠param separator 分隔符
1882
1883 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1884 /
1885 public static String join（Object[] array， char separator） {
1886 if （array == null） {
1887 return null;
1888 }
1889
1890 int arraySize = array.length;
1891 int bufSize = （arraySize == 0） ？ 0 : （（（（array[0] == null） ？ 16 : array[0].toString（）
1892 .length（）） + 1） arraySize）;
1893 StringBuffer buf = new StringBuffer（bufSize）;
1894
1895 for （int i = 0; i < arraySize; i++） {
1896 if （i > 0） {
1897 buf.append（separator）;
1898 }
1899
1900 if （array[i] != null） {
1901 buf.append（array[i]）;
1902 }
1903 }
1904
1905 return buf.toString（）;
1906 }
1907
1908 /
1909 将数组中的元素连接成一个字符串。
1910 <pre>
1911 StringUtil.join（null， ） = null
1912 StringUtil.join（[]， ） =
1913 StringUtil.join（[null]， ） =
1914 StringUtil.join（[a， b， c]， --） = a--b--c
1915 StringUtil.join（[a， b， c]， null） = abc
1916 StringUtil.join（[a， b， c]， ） = abc
1917 StringUtil.join（[null， ， a]， ，） = ，，a
1918 </pre>
1919
1920 ＠param array 要连接的数组
1921 ＠param separator 分隔符
1922
1923 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1924 /
1925 public static String join（Object[] array， String separator） {
1926 if （array == null） {
1927 return null;
1928 }
1929
1930 if （separator == null） {
1931 separator = EMPTY_STRING;
1932 }
1933
1934 int arraySize = array.length;
1935
1936 // ArraySize == 0: Len = 0
1937 // ArraySize > 0: Len = NofStrings （len（firstString） + len（separator））
1938 // （估计大约所有的字符串都一样长）
1939 int bufSize = （arraySize == 0） ？ 0 : （arraySize （（（array[0] == null） ？ 16 : array[0]
1940 .toString（）.length（）） + （（separator != null） ？ separator.length（） : 0）））;
1941
1942 StringBuffer buf = new StringBuffer（bufSize）;
1943
1944 for （int i = 0; i < arraySize; i++） {
1945 if （（separator != null） && （i > 0）） {
1946 buf.append（separator）;
1947 }
1948
1949 if （array[i] != null） {
1950 buf.append（array[i]）;
1951 }
1952 }
1953
1954 return buf.toString（）;
1955 }
1956
1957 /
1958 将<code>Iterator</code>中的元素连接成一个字符串。
1959 <pre>
1960 StringUtil.join（null， ） = null
1961 StringUtil.join（[]， ） =
1962 StringUtil.join（[null]， ） =
1963 StringUtil.join（[a， b， c]， --） = a--b--c
1964 StringUtil.join（[a， b， c]， null） = abc
1965 StringUtil.join（[a， b， c]， ） = abc
1966 StringUtil.join（[null， ， a]， ，） = ，，a
1967 </pre>
1968
1969 ＠param iterator 要连接的<code>Iterator</code>
1970 ＠param separator 分隔符
1971
1972 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
1973 /
1974 public static String join（Iterator iterator， char separator） {
1975 if （iterator == null） {
1976 return null;
1977 }
1978
1979 StringBuffer buf = new StringBuffer（256）; // Java默认值是16， 可能偏小
1980
1981 while （iterator.hasNext（）） {
1982 Object obj = iterator.next（）;
1983
1984 if （obj != null） {
1985 buf.append（obj）;
1986 }
1987
1988 if （iterator.hasNext（）） {
1989 buf.append（separator）;
1990 }
1991 }
1992
1993 return buf.toString（）;
1994 }
1995
1996 /
1997 将<code>Iterator</code>中的元素连接成一个字符串。
1998 <pre>
1999 StringUtil.join（null， ） = null
2000 StringUtil.join（[]， ） =
2001 StringUtil.join（[null]， ） =
2002 StringUtil.join（[a， b， c]， --） = a--b--c
2003 StringUtil.join（[a， b， c]， null） = abc
2004 StringUtil.join（[a， b， c]， ） = abc
2005 StringUtil.join（[null， ， a]， ，） = ，，a
2006 </pre>
2007
2008 ＠param iterator 要连接的<code>Iterator</code>
2009 ＠param separator 分隔符
2010
2011 ＠return 连接后的字符串，若是原数组为<code>null</code>，则返回<code>null</code>
2012 /
2013 public static String join（Iterator iterator， String separator） {
2014 if （iterator == null） {
2015 return null;
2016 }
2017
2018 StringBuffer buf = new StringBuffer（256）; // Java默认值是16， 可能偏小
2019
2020 while （iterator.hasNext（）） {
2021 Object obj = iterator.next（）;
2022
2023 if （obj != null） {
2024 buf.append（obj）;
2025 }
2026
2027 if （（separator != null） && iterator.hasNext（）） {
2028 buf.append（separator）;
2029 }
2030 }
2031
2032 return buf.toString（）;
2033 }
2034
2035 / ============================================================================ /
2036 / 字符串查找函数 —— 字符或字符串。 /
2037 / /
2038 / 在字符串中查找指定字符或字符串。 /
2039 / ============================================================================ /
2040
2041 /
2042 在字符串中查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2043 <pre>
2044 StringUtil.indexOf（null， ） = -1
2045 StringUtil.indexOf（， ） = -1
2046 StringUtil.indexOf（aabaabaa， a） = 0
2047 StringUtil.indexOf（aabaabaa， b） = 2
2048 </pre>
2049
2050 ＠param str 要扫描的字符串
2051 ＠param searchChar 要查找的字符
2052
2053 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2054 /
2055 public static int indexOf（String str， char searchChar） {
2056 if （（str == null） || （str.length（） == 0）） {
2057 return -1;
2058 }
2059
2060 return str.indexOf（searchChar）;
2061 }
2062
2063 /
2064 在字符串中查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2065 <pre>
2066 StringUtil.indexOf（null， ， ） = -1
2067 StringUtil.indexOf（， ， ） = -1
2068 StringUtil.indexOf（aabaabaa， b， 0） = 2
2069 StringUtil.indexOf（aabaabaa， b， 3） = 5
2070 StringUtil.indexOf（aabaabaa， b， 9） = -1
2071 StringUtil.indexOf（aabaabaa， b， -1） = 2
2072 </pre>
2073
2074 ＠param str 要扫描的字符串
2075 ＠param searchChar 要查找的字符
2076 ＠param startPos 开端搜刮的索引值，若是小于0，则看作0
2077
2078 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2079 /
2080 public static int indexOf（String str， char searchChar， int startPos） {
2081 if （（str == null） || （str.length（） == 0）） {
2082 return -1;
2083 }
2084
2085 return str.indexOf（searchChar， startPos）;
2086 }
2087
2088 /
2089 在字符串中查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2090 <pre>
2091 StringUtil.indexOf（null， ） = -1
2092 StringUtil.indexOf（， null） = -1
2093 StringUtil.indexOf（， ） = 0
2094 StringUtil.indexOf（aabaabaa， a） = 0
2095 StringUtil.indexOf（aabaabaa， b） = 2
2096 StringUtil.indexOf（aabaabaa， ab） = 1
2097 StringUtil.indexOf（aabaabaa， ） = 0
2098 </pre>
2099
2100 ＠param str 要扫描的字符串
2101 ＠param searchStr 要查找的字符串
2102
2103 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2104 /
2105 public static int indexOf（String str， String searchStr） {
2106 if （（str == null） || （searchStr == null）） {
2107 return -1;
2108 }
2109
2110 return str.indexOf（searchStr）;
2111 }
2112
2113 /
2114 在字符串中查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2115 <pre>
2116 StringUtil.indexOf（null， ， ） = -1
2117 StringUtil.indexOf（， null， ） = -1
2118 StringUtil.indexOf（， ， 0） = 0
2119 StringUtil.indexOf（aabaabaa， a， 0） = 0
2120 StringUtil.indexOf（aabaabaa， b， 0） = 2
2121 StringUtil.indexOf（aabaabaa， ab， 0） = 1
2122 StringUtil.indexOf（aabaabaa， b， 3） = 5
2123 StringUtil.indexOf（aabaabaa， b， 9） = -1
2124 StringUtil.indexOf（aabaabaa， b， -1） = 2
2125 StringUtil.indexOf（aabaabaa， ， 2） = 2
2126 StringUtil.indexOf（abc， ， 9） = 3
2127 </pre>
2128
2129 ＠param str 要扫描的字符串
2130 ＠param searchStr 要查找的字符串
2131 ＠param startPos 开端搜刮的索引值，若是小于0，则看作0
2132
2133 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2134 /
2135 public static int indexOf（String str， String searchStr， int startPos） {
2136 if （（str == null） || （searchStr == null）） {
2137 return -1;
2138 }
2139
2140 // JDK1.3及以下版本的bug：不克不及正确处理惩罚下面的景象
2141 if （（searchStr.length（） == 0） && （startPos >= str.length（））） {
2142 return str.length（）;
2143 }
2144
2145 return str.indexOf（searchStr， startPos）;
2146 }
2147
2148 /
2149 在字符串中查找指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2150 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2151 <pre>
2152 StringUtil.indexOfAny（null， ） = -1
2153 StringUtil.indexOfAny（， ） = -1
2154 StringUtil.indexOfAny（， null） = -1
2155 StringUtil.indexOfAny（， []） = -1
2156 StringUtil.indexOfAny（zzabyycdxx，[z，a]） = 0
2157 StringUtil.indexOfAny（zzabyycdxx，[b，y]） = 3
2158 StringUtil.indexOfAny（aba， [z]） = -1
2159 </pre>
2160
2161 ＠param str 要扫描的字符串
2162 ＠param searchChars 要搜刮的字符凑集
2163
2164 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2165 /
2166 public static int indexOfAny（String str， char[] searchChars） {
2167 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2168 || （searchChars.length == 0）） {
2169 return -1;
2170 }
2171
2172 for （int i = 0; i < str.length（）; i++） {
2173 char ch = str.charAt（i）;
2174
2175 for （int j = 0; j < searchChars.length; j++） {
2176 if （searchChars[j] == ch） {
2177 return i;
2178 }
2179 }
2180 }
2181
2182 return -1;
2183 }
2184
2185 /
2186 在字符串中查找指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2187 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2188 <pre>
2189 StringUtil.indexOfAny（null， ） = -1
2190 StringUtil.indexOfAny（， ） = -1
2191 StringUtil.indexOfAny（， null） = -1
2192 StringUtil.indexOfAny（， ） = -1
2193 StringUtil.indexOfAny（zzabyycdxx， za） = 0
2194 StringUtil.indexOfAny（zzabyycdxx， by） = 3
2195 StringUtil.indexOfAny（aba，z） = -1
2196 </pre>
2197
2198 ＠param str 要扫描的字符串
2199 ＠param searchChars 要搜刮的字符凑集
2200
2201 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2202 /
2203 public static int indexOfAny（String str， String searchChars） {
2204 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2205 || （searchChars.length（） == 0）） {
2206 return -1;
2207 }
2208
2209 for （int i = 0; i < str.length（）; i++） {
2210 char ch = str.charAt（i）;
2211
2212 for （int j = 0; j < searchChars.length（）; j++） {
2213 if （searchChars.charAt（j） == ch） {
2214 return i;
2215 }
2216 }
2217 }
2218
2219 return -1;
2220 }
2221
2222 /
2223 在字符串中查找指定字符串凑集中的字符串，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2224 若是字符串凑集为<code>null</code>或空，也返回<code>-1</code>。
2225 若是字符串凑集包含<code></code>，并且字符串不为<code>null</code>，则返回<code>str.length（）</code>
2226 <pre>
2227 StringUtil.indexOfAny（null， ） = -1
2228 StringUtil.indexOfAny（， null） = -1
2229 StringUtil.indexOfAny（， []） = -1
2230 StringUtil.indexOfAny（zzabyycdxx， [ab，cd]） = 2
2231 StringUtil.indexOfAny（zzabyycdxx， [cd，ab]） = 2
2232 StringUtil.indexOfAny（zzabyycdxx， [mn，op]） = -1
2233 StringUtil.indexOfAny（zzabyycdxx， [zab，aby]） = 1
2234 StringUtil.indexOfAny（zzabyycdxx， []） = 0
2235 StringUtil.indexOfAny（， []） = 0
2236 StringUtil.indexOfAny（， [a]） = -1
2237 </pre>
2238
2239 ＠param str 要扫描的字符串
2240 ＠param searchStrs 要搜刮的字符串凑集
2241
2242 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2243 /
2244 public static int indexOfAny（String str， String[] searchStrs） {
2245 if （（str == null） || （searchStrs == null）） {
2246 return -1;
2247 }
2248
2249 int sz = searchStrs.length;
2250
2251 // Strings cant have a MAX_VALUEth index.
2252 int ret = Integer.MAX_VALUE;
2253
2254 int tmp = 0;
2255
2256 for （int i = 0; i < sz; i++） {
2257 String search = searchStrs[i];
2258
2259 if （search == null） {
2260 continue;
2261 }
2262
2263 tmp = str.indexOf（search）;
2264
2265 if （tmp == -1） {
2266 continue;
2267 }
2268
2269 if （tmp < ret） {
2270 ret = tmp;
2271 }
2272 }
2273
2274 return （ret == Integer.MAX_VALUE） ？ （-1） : ret;
2275 }
2276
2277 /
2278 在字符串中查找不在指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2279 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2280 <pre>
2281 StringUtil.indexOfAnyBut（null， ） = -1
2282 StringUtil.indexOfAnyBut（， ） = -1
2283 StringUtil.indexOfAnyBut（， null） = -1
2284 StringUtil.indexOfAnyBut（， []） = -1
2285 StringUtil.indexOfAnyBut（zzabyycdxx，za） = 3
2286 StringUtil.indexOfAnyBut（zzabyycdxx， by） = 0
2287 StringUtil.indexOfAnyBut（aba， ab） = -1
2288 </pre>
2289
2290 ＠param str 要扫描的字符串
2291 ＠param searchChars 要搜刮的字符凑集
2292
2293 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2294 /
2295 public static int indexOfAnyBut（String str， char[] searchChars） {
2296 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2297 || （searchChars.length == 0）） {
2298 return -1;
2299 }
2300
2301 outer: for （int i = 0; i < str.length（）; i++） {
2302 char ch = str.charAt（i）;
2303
2304 for （int j = 0; j < searchChars.length; j++） {
2305 if （searchChars[j] == ch） {
2306 continue outer;
2307 }
2308 }
2309
2310 return i;
2311 }
2312
2313 return -1;
2314 }
2315
2316 /
2317 在字符串中查找不在指定字符凑集中的字符，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2318 若是字符凑集为<code>null</code>或空，也返回<code>-1</code>。
2319 <pre>
2320 StringUtil.indexOfAnyBut（null， ） = -1
2321 StringUtil.indexOfAnyBut（， ） = -1
2322 StringUtil.indexOfAnyBut（， null） = -1
2323 StringUtil.indexOfAnyBut（， ） = -1
2324 StringUtil.indexOfAnyBut（zzabyycdxx， za） = 3
2325 StringUtil.indexOfAnyBut（zzabyycdxx， by） = 0
2326 StringUtil.indexOfAnyBut（aba，ab） = -1
2327 </pre>
2328
2329 ＠param str 要扫描的字符串
2330 ＠param searchChars 要搜刮的字符凑集
2331
2332 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2333 /
2334 public static int indexOfAnyBut（String str， String searchChars） {
2335 if （（str == null） || （str.length（） == 0） || （searchChars == null）
2336 || （searchChars.length（） == 0）） {
2337 return -1;
2338 }
2339
2340 for （int i = 0; i < str.length（）; i++） {
2341 if （searchChars.indexOf（str.charAt（i）） < 0） {
2342 return i;
2343 }
2344 }
2345
2346 return -1;
2347 }
2348
2349 /
2350 从字符串尾部开端查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2351 <pre>
2352 StringUtil.lastIndexOf（null， ） = -1
2353 StringUtil.lastIndexOf（， ） = -1
2354 StringUtil.lastIndexOf（aabaabaa， a） = 7
2355 StringUtil.lastIndexOf（aabaabaa， b） = 5
2356 </pre>
2357
2358 ＠param str 要扫描的字符串
2359 ＠param searchChar 要查找的字符
2360
2361 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2362 /
2363 public static int lastIndexOf（String str， char searchChar） {
2364 if （（str == null） || （str.length（） == 0）） {
2365 return -1;
2366 }
2367
2368 return str.lastIndexOf（searchChar）;
2369 }
2370
2371 /
2372 从字符串尾部开端查找指定字符，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2373 <pre>
2374 StringUtil.lastIndexOf（null， ， ） = -1
2375 StringUtil.lastIndexOf（， ， ） = -1
2376 StringUtil.lastIndexOf（aabaabaa， b， 8） = 5
2377 StringUtil.lastIndexOf（aabaabaa， b， 4） = 2
2378 StringUtil.lastIndexOf（aabaabaa， b， 0） = -1
2379 StringUtil.lastIndexOf（aabaabaa， b， 9） = 5
2380 StringUtil.lastIndexOf（aabaabaa， b， -1） = -1
2381 StringUtil.lastIndexOf（aabaabaa， a， 0） = 0
2382 </pre>
2383
2384 ＠param str 要扫描的字符串
2385 ＠param searchChar 要查找的字符
2386 ＠param startPos 从指定索引开端向前搜刮
2387
2388 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2389 /
2390 public static int lastIndexOf（String str， char searchChar， int startPos） {
2391 if （（str == null） || （str.length（） == 0）） {
2392 return -1;
2393 }
2394
2395 return str.lastIndexOf（searchChar， startPos）;
2396 }
2397
2398 /
2399 从字符串尾部开端查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2400 <pre>
2401 StringUtil.lastIndexOf（null， ） = -1
2402 StringUtil.lastIndexOf（， ） = -1
2403 StringUtil.lastIndexOf（aabaabaa， a） = 7
2404 StringUtil.lastIndexOf（aabaabaa， b） = 5
2405 </pre>
2406
2407 ＠param str 要扫描的字符串
2408 ＠param searchStr 要查找的字符串
2409
2410 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2411 /
2412 public static int lastIndexOf（String str， String searchStr） {
2413 if （（str == null） || （searchStr == null）） {
2414 return -1;
2415 }
2416
2417 return str.lastIndexOf（searchStr）;
2418 }
2419
2420 /
2421 从字符串尾部开端查找指定字符串，并返回第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>。
2422 <pre>
2423 StringUtil.lastIndexOf（null， ， ） = -1
2424 StringUtil.lastIndexOf（， null， ） = -1
2425 StringUtil.lastIndexOf（aabaabaa， a， 8） = 7
2426 StringUtil.lastIndexOf（aabaabaa， b， 8） = 5
2427 StringUtil.lastIndexOf（aabaabaa， ab， 8） = 4
2428 StringUtil.lastIndexOf（aabaabaa， b， 9） = 5
2429 StringUtil.lastIndexOf（aabaabaa， b， -1） = -1
2430 StringUtil.lastIndexOf（aabaabaa， a， 0） = 0
2431 StringUtil.lastIndexOf（aabaabaa， b， 0） = -1
2432 </pre>
2433
2434 ＠param str 要扫描的字符串
2435 ＠param searchStr 要查找的字符串
2436 ＠param startPos 从指定索引开端向前搜刮
2437
2438 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2439 /
2440 public static int lastIndexOf（String str， String searchStr， int startPos） {
2441 if （（str == null） || （searchStr == null）） {
2442 return -1;
2443 }
2444
2445 return str.lastIndexOf（searchStr， startPos）;
2446 }
2447
2448 /
2449 从字符串尾部开端查找指定字符串凑集中的字符串，并返回第一个匹配的肇端索引。 若是字符串为<code>null</code>，则返回<code>-1</code>。
2450 若是字符串凑集为<code>null</code>或空，也返回<code>-1</code>。
2451 若是字符串凑集包含<code></code>，并且字符串不为<code>null</code>，则返回<code>str.length（）</code>
2452 <pre>
2453 StringUtil.lastIndexOfAny（null， ） = -1
2454 StringUtil.lastIndexOfAny（， null） = -1
2455 StringUtil.lastIndexOfAny（， []） = -1
2456 StringUtil.lastIndexOfAny（， [null]） = -1
2457 StringUtil.lastIndexOfAny（zzabyycdxx， [ab，cd]） = 6
2458 StringUtil.lastIndexOfAny（zzabyycdxx， [cd，ab]） = 6
2459 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，op]） = -1
2460 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，op]） = -1
2461 StringUtil.lastIndexOfAny（zzabyycdxx， [mn，]） = 10
2462 </pre>
2463
2464 ＠param str 要扫描的字符串
2465 ＠param searchStrs 要搜刮的字符串凑集
2466
2467 ＠return 第一个匹配的索引值。若是字符串为<code>null</code>或未找到，则返回<code>-1</code>
2468 /
2469 public static int lastIndexOfAny（String str， String[] searchStrs） {
2470 if （（str == null） || （searchStrs == null）） {
2471 return -1;
2472 }
2473
2474 int searchStrsLength = searchStrs.length;
2475 int index = -1;
2476 int tmp = 0;
2477
2478 for （int i = 0; i < searchStrsLength; i++） {
2479 String search = searchStrs[i];
2480
2481 if （search == null） {
2482 continue;
2483 }
2484
2485 tmp = str.lastIndexOf（search）;
2486
2487 if （tmp > index） {
2488 index = tmp;
2489 }
2490 }
2491
2492 return index;
2493 }
2494
2495 /
2496 搜检字符串中是否包含指定的字符。若是字符串为<code>null</code>，将返回<code>false</code>。
2497 <pre>
2498 StringUtil.contains（null， ） = false
2499 StringUtil.contains（， ） = false
2500 StringUtil.contains（abc， a） = true
2501 StringUtil.contains（abc， z） = false
2502 </pre>
2503
2504 ＠param str 要扫描的字符串
2505 ＠param searchChar 要查找的字符
2506
2507 ＠return 若是找到，则返回<code>true</code>
2508 /
2509 public static boolean contains（String str， char searchChar） {
2510 if （（str == null） || （str.length（） == 0）） {
2511 return false;
2512 }
2513
2514 return str.indexOf（searchChar） >= 0;
2515 }
2516
2517 /
2518 搜检字符串中是否包含指定的字符串。若是字符串为<code>null</code>，将返回<code>false</code>。
2519 <pre>
2520 StringUtil.contains（null， ） = false
2521 StringUtil.contains（， null） = false
2522 StringUtil.contains（， ） = true
2523 StringUtil.contains（abc， ） = true
2524 StringUtil.contains（abc， a） = true
2525 StringUtil.contains（abc， z） = false
2526 </pre>
2527
2528 ＠param str 要扫描的字符串
2529 ＠param searchStr 要查找的字符串
2530
2531 ＠return 若是找到，则返回<code>true</code>
2532 /
2533 public static boolean contains（String str， String searchStr） {
2534 if （（str == null） || （searchStr == null）） {
2535 return false;
2536 }
2537
2538 return str.indexOf（searchStr） >= 0;
2539 }
2540
2541 /
2542 搜检字符串是是否只包含指定字符凑集中的字符。
2543
2544 <p>
2545 若是字符串为<code>null</code>，则返回<code>false</code>。
2546 若是字符凑集为<code>null</code>则返回<code>false</code>。 然则空字符串永远返回<code>true</code>.
2547 </p>
2548 <pre>
2549 StringUtil.containsOnly（null， ） = false
2550 StringUtil.containsOnly（， null） = false
2551 StringUtil.containsOnly（， ） = true
2552 StringUtil.containsOnly（ab， ） = false
2553 StringUtil.containsOnly（abab， abc） = true
2554 StringUtil.containsOnly（ab1， abc） = false
2555 StringUtil.containsOnly（abz， abc） = false
2556 </pre>
2557
2558 ＠param str 要扫描的字符串
2559 ＠param valid 要查找的字符串
2560
2561 ＠return 若是找到，则返回<code>true</code>
2562 /
2563 public static boolean containsOnly（String str， char[] valid） {
2564 if （（valid == null） || （str == null）） {
2565 return false;
2566 }
2567
2568 if （str.length（） == 0） {
2569 return true;
2570 }
2571
2572 if （valid.length == 0） {
2573 return false;
2574 }
2575
2576 return indexOfAnyBut（str， valid） == -1;
2577 }
2578
2579 /
2580 搜检字符串是是否只包含指定字符凑集中的字符。
2581
2582 <p>
2583 若是字符串为<code>null</code>，则返回<code>false</code>。
2584 若是字符凑集为<code>null</code>则返回<code>false</code>。 然则空字符串永远返回<code>true</code>.
2585 </p>
2586 <pre>
2587 StringUtil.containsOnly（null， ） = false
2588 StringUtil.containsOnly（， null） = false
2589 StringUtil.containsOnly（， ） = true
2590 StringUtil.containsOnly（ab， ） = false
2591 StringUtil.containsOnly（abab， abc） = true
2592 StringUtil.containsOnly（ab1， abc） = false
2593 StringUtil.containsOnly（abz， abc） = false
2594 </pre>
2595
2596 ＠param str 要扫描的字符串
2597 ＠param valid 要查找的字符串
2598
2599 ＠return 若是找到，则返回<code>true</code>
2600 /
2601 public static boolean containsOnly（String str， String valid） {
2602 if （（str == null） || （valid == null）） {
2603 return false;
2604 }
2605
2606 return containsOnly（str， valid.toCharArray（））;
2607 }
2608
2609 /
2610 搜检字符串是是否不包含指定字符凑集中的字符。
2611
2612 <p>
2613 若是字符串为<code>null</code>，则返回<code>false</code>。 若是字符凑集为<code>null</code>则返回<code>true</code>。
2614 然则空字符串永远返回<code>true</code>.
2615 </p>
2616 <pre>
2617 StringUtil.containsNone（null， ） = true
2618 StringUtil.containsNone（， null） = true
2619 StringUtil.containsNone（， ） = true
2620 StringUtil.containsNone（ab， ） = true
2621 StringUtil.containsNone（abab， xyz） = true
2622 StringUtil.containsNone（ab1， xyz） = true
2623 StringUtil.containsNone（abz， xyz） = false
2624 </pre>
2625
2626 ＠param str 要扫描的字符串
2627 ＠param invalid 要查找的字符串
2628
2629 ＠return 若是找到，则返回<code>true</code>
2630 /
2631 public static boolean containsNone（String str， char[] invalid） {
2632 if （（str == null） || （invalid == null）） {
2633 return true;
2634 }
2635
2636 int strSize = str.length（）;
2637 int validSize = invalid.length;
2638
2639 for （int i = 0; i < strSize; i++） {
2640 char ch = str.charAt（i）;
2641
2642 for （int j = 0; j < validSize; j++） {
2643 if （invalid[j] == ch） {
2644 return false;
2645 }
2646 }
2647 }
2648
2649 return true;
2650 }
2651
2652 /
2653 搜检字符串是是否不包含指定字符凑集中的字符。
2654
2655 <p>
2656 若是字符串为<code>null</code>，则返回<code>false</code>。 若是字符凑集为<code>null</code>则返回<code>true</code>。
2657 然则空字符串永远返回<code>true</code>.
2658 </p>
2659 <pre>
2660 StringUtil.containsNone（null， ） = true
2661 StringUtil.containsNone（， null） = true
2662 StringUtil.containsNone（， ） = true
2663 StringUtil.containsNone（ab， ） = true
2664 StringUtil.containsNone（abab， xyz） = true
2665 StringUtil.containsNone（ab1， xyz） = true
2666 StringUtil.containsNone（abz， xyz） = false
2667 </pre>
2668
2669 ＠param str 要扫描的字符串
2670 ＠param invalidChars 要查找的字符串
2671
2672 ＠return 若是找到，则返回<code>true</code>
2673 /
2674 public static boolean containsNone（String str， String invalidChars） {
2675 if （（str == null） || （invalidChars == null）） {
2676 return true;
2677 }
2678
2679 return containsNone（str， invalidChars.toCharArray（））;
2680 }
2681
2682 /
2683 取得指定子串在字符串中呈现的次数。
2684
2685 <p>
2686 若是字符串为<code>null</code>或空，则返回<code>0</code>。
2687 <pre>
2688 StringUtil.countMatches（null， ） = 0
2689 StringUtil.countMatches（， ） = 0
2690 StringUtil.countMatches（abba， null） = 0
2691 StringUtil.countMatches（abba， ） = 0
2692 StringUtil.countMatches（abba， a） = 2
2693 StringUtil.countMatches（abba， ab） = 1
2694 StringUtil.countMatches（abba， xxx） = 0
2695 </pre>
2696 </p>
2697
2698 ＠param str 要扫描的字符串
2699 ＠param subStr 子字符串
2700
2701 ＠return 子串在字符串中呈现的次数，若是字符串为<code>null</code>或空，则返回<code>0</code>
2702 /
2703 public static int countMatches（String str， String subStr） {
2704 if （（str == null） || （str.length（） == 0） || （subStr == null） || （subStr.length（） == 0）） {
2705 return 0;
2706 }
2707
2708 int count = 0;
2709 int index = 0;
2710
2711 while （（index = str.indexOf（subStr， index）） != -1） {
2712 count++;
2713 index += subStr.length（）;
2714 }
2715
2716 return count;
2717 }
2718
2719 / ============================================================================ /
2720 / 取子串函数。 /
2721 / ============================================================================ /
2722
2723 /
2724 取指定字符串的子串。
2725
2726 <p>
2727 负的索引代表从尾部开端策画。若是字符串为<code>null</code>，则返回<code>null</code>。
2728 <pre>
2729 StringUtil.substring（null， ） = null
2730 StringUtil.substring（， ） =
2731 StringUtil.substring（abc， 0） = abc
2732 StringUtil.substring（abc， 2） = c
2733 StringUtil.substring（abc， 4） =
2734 StringUtil.substring（abc， -2） = bc
2735 StringUtil.substring（abc， -4） = abc
2736 </pre>
2737 </p>
2738
2739 ＠param str 字符串
2740 ＠param start 肇端索引，若是为负数，默示从尾部查找
2741
2742 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2743 /
2744 public static String substring（String str， int start） {
2745 if （str == null） {
2746 return null;
2747 }
2748
2749 if （start < 0） {
2750 start = str.length（） + start;
2751 }
2752
2753 if （start < 0） {
2754 start = 0;
2755 }
2756
2757 if （start > str.length（）） {
2758 return EMPTY_STRING;
2759 }
2760
2761 return str.substring（start）;
2762 }
2763
2764 /
2765 取指定字符串的子串。
2766
2767 <p>
2768 负的索引代表从尾部开端策画。若是字符串为<code>null</code>，则返回<code>null</code>。
2769 <pre>
2770 StringUtil.substring（null， ， ） = null
2771 StringUtil.substring（， ， ） = ;
2772 StringUtil.substring（abc， 0， 2） = ab
2773 StringUtil.substring（abc， 2， 0） =
2774 StringUtil.substring（abc， 2， 4） = c
2775 StringUtil.substring（abc， 4， 6） =
2776 StringUtil.substring（abc， 2， 2） =
2777 StringUtil.substring（abc， -2， -1） = b
2778 StringUtil.substring（abc， -4， 2） = ab
2779 </pre>
2780 </p>
2781
2782 ＠param str 字符串
2783 ＠param start 肇端索引，若是为负数，默示从尾部策画
2784 ＠param end 停止索引（不含），若是为负数，默示从尾部策画
2785
2786 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2787 /
2788 public static String substring（String str， int start， int end） {
2789 if （str == null） {
2790 return null;
2791 }
2792
2793 if （end < 0） {
2794 end = str.length（） + end;
2795 }
2796
2797 if （start < 0） {
2798 start = str.length（） + start;
2799 }
2800
2801 if （end > str.length（）） {
2802 end = str.length（）;
2803 }
2804
2805 if （start > end） {
2806 return EMPTY_STRING;
2807 }
2808
2809 if （start < 0） {
2810 start = 0;
2811 }
2812
2813 if （end < 0） {
2814 end = 0;
2815 }
2816
2817 return str.substring（start， end）;
2818 }
2819
2820 /
2821 取得长度为指定字符数的最左边的子串。
2822 <pre>
2823 StringUtil.left（null， ） = null
2824 StringUtil.left（， -ve） =
2825 StringUtil.left（， ） =
2826 StringUtil.left（abc， 0） =
2827 StringUtil.left（abc， 2） = ab
2828 StringUtil.left（abc， 4） = abc
2829 </pre>
2830
2831 ＠param str 字符串
2832 ＠param len 最左子串的长度
2833
2834 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2835 /
2836 public static String left（String str， int len） {
2837 if （str == null） {
2838 return null;
2839 }
2840
2841 if （len < 0） {
2842 return EMPTY_STRING;
2843 }
2844
2845 if （str.length（） <= len） {
2846 return str;
2847 } else {
2848 return str.substring（0， len）;
2849 }
2850 }
2851
2852 /
2853 取得长度为指定字符数的最右边的子串。
2854 <pre>
2855 StringUtil.right（null， ） = null
2856 StringUtil.right（， -ve） =
2857 StringUtil.right（， ） =
2858 StringUtil.right（abc， 0） =
2859 StringUtil.right（abc， 2） = bc
2860 StringUtil.right（abc， 4） = abc
2861 </pre>
2862
2863 ＠param str 字符串
2864 ＠param len 最右子串的长度
2865
2866 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2867 /
2868 public static String right（String str， int len） {
2869 if （str == null） {
2870 return null;
2871 }
2872
2873 if （len < 0） {
2874 return EMPTY_STRING;
2875 }
2876
2877 if （str.length（） <= len） {
2878 return str;
2879 } else {
2880 return str.substring（str.length（） - len）;
2881 }
2882 }
2883
2884 /
2885 取得从指定索引开端策画的、长度为指定字符数的子串。
2886 <pre>
2887 StringUtil.mid（null， ， ） = null
2888 StringUtil.mid（， ， -ve） =
2889 StringUtil.mid（， 0， ） =
2890 StringUtil.mid（abc， 0， 2） = ab
2891 StringUtil.mid（abc， 0， 4） = abc
2892 StringUtil.mid（abc， 2， 4） = c
2893 StringUtil.mid（abc， 4， 2） =
2894 StringUtil.mid（abc， -2， 2） = ab
2895 </pre>
2896
2897 ＠param str 字符串
2898 ＠param pos 肇端索引，若是为负数，则看作<code>0</code>
2899 ＠param len 子串的长度，若是为负数，则看作长度为<code>0</code>
2900
2901 ＠return 子串，若是原始字串为<code>null</code>，则返回<code>null</code>
2902 /
2903 public static String mid（String str， int pos， int len） {
2904 if （str == null） {
2905 return null;
2906 }
2907
2908 if （（len < 0） || （pos > str.length（））） {
2909 return EMPTY_STRING;
2910 }
2911
2912 if （pos < 0） {
2913 pos = 0;
2914 }
2915
2916 if （str.length（） <= （pos + len）） {
2917 return str.substring（pos）;
2918 } else {
2919 return str.substring（pos， pos + len）;
2920 }
2921 }
2922
2923 / ============================================================================ /
2924 / 搜刮并取子串函数。 /
2925 / ============================================================================ /
2926
2927 /
2928 取得第一个呈现的分隔子串之前的子串。
2929
2930 <p>
2931 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
2932 <pre>
2933 StringUtil.substringBefore（null， ） = null
2934 StringUtil.substringBefore（， ） =
2935 StringUtil.substringBefore（abc， a） =
2936 StringUtil.substringBefore（abcba， b） = a
2937 StringUtil.substringBefore（abc， c） = ab
2938 StringUtil.substringBefore（abc， d） = abc
2939 StringUtil.substringBefore（abc， ） =
2940 StringUtil.substringBefore（abc， null） = abc
2941 </pre>
2942 </p>
2943
2944 ＠param str 字符串
2945 ＠param separator 要搜刮的分隔子串
2946
2947 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2948 /
2949 public static String substringBefore（String str， String separator） {
2950 if （（str == null） || （separator == null） || （str.length（） == 0）） {
2951 return str;
2952 }
2953
2954 if （separator.length（） == 0） {
2955 return EMPTY_STRING;
2956 }
2957
2958 int pos = str.indexOf（separator）;
2959
2960 if （pos == -1） {
2961 return str;
2962 }
2963
2964 return str.substring（0， pos）;
2965 }
2966
2967 /
2968 取得第一个呈现的分隔子串之后的子串。
2969
2970 <p>
2971 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
2972 <pre>
2973 StringUtil.substringAfter（null， ） = null
2974 StringUtil.substringAfter（， ） =
2975 StringUtil.substringAfter（， null） =
2976 StringUtil.substringAfter（abc， a） = bc
2977 StringUtil.substringAfter（abcba， b） = cba
2978 StringUtil.substringAfter（abc， c） =
2979 StringUtil.substringAfter（abc， d） =
2980 StringUtil.substringAfter（abc， ） = abc
2981 </pre>
2982 </p>
2983
2984 ＠param str 字符串
2985 ＠param separator 要搜刮的分隔子串
2986
2987 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
2988 /
2989 public static String substringAfter（String str， String separator） {
2990 if （（str == null） || （str.length（） == 0）） {
2991 return str;
2992 }
2993
2994 if （separator == null） {
2995 return EMPTY_STRING;
2996 }
2997
2998 int pos = str.indexOf（separator）;
2999
3000 if （pos == -1） {
3001 return EMPTY_STRING;
3002 }
3003
3004 return str.substring（pos + separator.length（））;
3005 }
3006
3007 /
3008 取得最后一个的分隔子串之前的子串。
3009
3010 <p>
3011 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
3012 <pre>
3013 StringUtil.substringBeforeLast（null， ） = null
3014 StringUtil.substringBeforeLast（， ） =
3015 StringUtil.substringBeforeLast（abcba， b） = abc
3016 StringUtil.substringBeforeLast（abc， c） = ab
3017 StringUtil.substringBeforeLast（a， a） =
3018 StringUtil.substringBeforeLast（a， z） = a
3019 StringUtil.substringBeforeLast（a， null） = a
3020 StringUtil.substringBeforeLast（a， ） = a
3021 </pre>
3022 </p>
3023
3024 ＠param str 字符串
3025 ＠param separator 要搜刮的分隔子串
3026
3027 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
3028 /
3029 public static String substringBeforeLast（String str， String separator） {
3030 if （（str == null） || （separator == null） || （str.length（） == 0）
3031 || （separator.length（） == 0）） {
3032 return str;
3033 }
3034
3035 int pos = str.lastIndexOf（separator）;
3036
3037 if （pos == -1） {
3038 return str;
3039 }
3040
3041 return str.substring（0， pos）;
3042 }
3043
3044 /
3045 取得最后一个的分隔子串之后的子串。
3046
3047 <p>
3048 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>或未找到该子串，则返回原字符串。
3049 <pre>
3050 StringUtil.substringAfterLast（null， ） = null
3051 StringUtil.substringAfterLast（， ） =
3052 StringUtil.substringAfterLast（， ） =
3053 StringUtil.substringAfterLast（， null） =
3054 StringUtil.substringAfterLast（abc， a） = bc
3055 StringUtil.substringAfterLast（abcba， b） = a
3056 StringUtil.substringAfterLast（abc， c） =
3057 StringUtil.substringAfterLast（a， a） =
3058 StringUtil.substringAfterLast（a， z） =
3059 </pre>
3060 </p>
3061
3062 ＠param str 字符串
3063 ＠param separator 要搜刮的分隔子串
3064
3065 ＠return 子串，若是原始串为<code>null</code>，则返回<code>null</code>
3066 /
3067 public static String substringAfterLast（String str， String separator） {
3068 if （（str == null） || （str.length（） == 0）） {
3069 return str;
3070 }
3071
3072 if （（separator == null） || （separator.length（） == 0）） {
3073 return EMPTY_STRING;
3074 }
3075
3076 int pos = str.lastIndexOf（separator）;
3077
3078 if （（pos == -1） || （pos == （str.length（） - separator.length（）））） {
3079 return EMPTY_STRING;
3080 }
3081
3082 return str.substring（pos + separator.length（））;
3083 }
3084
3085 /
3086 取得指定分隔符的前两次呈现之间的子串。
3087
3088 <p>
3089 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3090 <pre>
3091 StringUtil.substringBetween（null， ） = null
3092 StringUtil.substringBetween（， ） =
3093 StringUtil.substringBetween（， tag） = null
3094 StringUtil.substringBetween（tagabctag， null） = null
3095 StringUtil.substringBetween（tagabctag， ） =
3096 StringUtil.substringBetween（tagabctag， tag） = abc
3097 </pre>
3098 </p>
3099
3100 ＠param str 字符串
3101 ＠param tag 要搜刮的分隔子串
3102
3103 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3104 /
3105 public static String substringBetween（String str， String tag） {
3106 return substringBetween（str， tag， tag， 0）;
3107 }
3108
3109 /
3110 取得两个分隔符之间的子串。
3111
3112 <p>
3113 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3114 <pre>
3115 StringUtil.substringBetween（null， ， ） = null
3116 StringUtil.substringBetween（， ， ） =
3117 StringUtil.substringBetween（， ， tag） = null
3118 StringUtil.substringBetween（， tag， tag） = null
3119 StringUtil.substringBetween（yabcz， null， null） = null
3120 StringUtil.substringBetween（yabcz， ， ） =
3121 StringUtil.substringBetween（yabcz， y， z） = abc
3122 StringUtil.substringBetween（yabczyabcz， y， z） = abc
3123 </pre>
3124 </p>
3125
3126 ＠param str 字符串
3127 ＠param open 要搜刮的分隔子串1
3128 ＠param close 要搜刮的分隔子串2
3129
3130 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3131 /
3132 public static String substringBetween（String str， String open， String close） {
3133 return substringBetween（str， open， close， 0）;
3134 }
3135
3136 /
3137 取得两个分隔符之间的子串。
3138
3139 <p>
3140 若是字符串为<code>null</code>，则返回<code>null</code>。 若是分隔子串为<code>null</code>，则返回<code>null</code>。
3141 <pre>
3142 StringUtil.substringBetween（null， ， ） = null
3143 StringUtil.substringBetween（， ， ） =
3144 StringUtil.substringBetween（， ， tag） = null
3145 StringUtil.substringBetween（， tag， tag） = null
3146 StringUtil.substringBetween（yabcz， null， null） = null
3147 StringUtil.substringBetween（yabcz， ， ） =
3148 StringUtil.substringBetween（yabcz， y， z） = abc
3149 StringUtil.substringBetween（yabczyabcz， y， z） = abc
3150 </pre>
3151 </p>
3152
3153 ＠param str 字符串
3154 ＠param open 要搜刮的分隔子串1
3155 ＠param close 要搜刮的分隔子串2
3156 ＠param Index 从指定index处搜刮
3157
3158 ＠return 子串，若是原始串为<code>null</code>或未找到分隔子串，则返回<code>null</code>
3159 /
3160 public static String substringBetween（String str， String open， String close， int Index） {
3161 if （（str == null） || （open == null） || （close == null）） {
3162 return null;
3163 }
3164
3165 int start = str.indexOf（open， Index）;
3166
3167 if （start != -1） {
3168 int end = str.indexOf（close， start + open.length（））;
3169
3170 if （end != -1） {
3171 return str.substring（start + open.length（）， end）;
3172 }
3173 }
3174
3175 return null;
3176 }
3177
3178 / ============================================================================ /
3179 / 删除字符。 /
3180 / ============================================================================ /
3181
3182 /
3183 删除所有在<code>Character.isWhitespace（char）</code>中所定义的空白。
3184 <pre>
3185 StringUtil.Whitespace（null） = null
3186 StringUtil.Whitespace（） =
3187 StringUtil.Whitespace（abc） = abc
3188 StringUtil.Whitespace（ ab c ） = abc
3189 </pre>
3190
3191 ＠param str 要处理惩罚的字符串
3192
3193 ＠return 去空白后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3194 /
3195 public static String Whitespace（String str） {
3196 if （str == null） {
3197 return null;
3198 }
3199
3200 int sz = str.length（）;
3201 StringBuffer buffer = new StringBuffer（sz）;
3202
3203 for （int i = 0; i < sz; i++） {
3204 if （!Character.isWhitespace（str.charAt（i））） {
3205 buffer.append（str.charAt（i））;
3206 }
3207 }
3208
3209 return buffer.toString（）;
3210 }
3211
3212 / ============================================================================ /
3213 / 调换子串。 /
3214 / ============================================================================ /
3215
3216 /
3217 调换指定的子串，只调换第一个呈现的子串。
3218
3219 <p>
3220 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3221 <pre>
3222 StringUtil.replaceOnce（null， ， ） = null
3223 StringUtil.replaceOnce（， ， ） =
3224 StringUtil.replaceOnce（aba， null， null） = aba
3225 StringUtil.replaceOnce（aba， null， null） = aba
3226 StringUtil.replaceOnce（aba， a， null） = aba
3227 StringUtil.replaceOnce（aba， a， ） = ba
3228 StringUtil.replaceOnce（aba， a， z） = zba
3229 </pre>
3230 </p>
3231
3232 ＠param text 要扫描的字符串
3233 ＠param repl 要搜刮的子串
3234 ＠param with 调换字符串
3235
3236 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3237 /
3238 public static String replaceOnce（String text， String repl， String with） {
3239 return replace（text， repl， with， 1）;
3240 }
3241
3242 /
3243 调换指定的子串，调换所有呈现的子串。
3244
3245 <p>
3246 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3247 <pre>
3248 StringUtil.replace（null， ， ） = null
3249 StringUtil.replace（， ， ） =
3250 StringUtil.replace（aba， null， null） = aba
3251 StringUtil.replace（aba， null， null） = aba
3252 StringUtil.replace（aba， a， null） = aba
3253 StringUtil.replace（aba， a， ） = b
3254 StringUtil.replace（aba， a， z） = zbz
3255 </pre>
3256 </p>
3257
3258 ＠param text 要扫描的字符串
3259 ＠param repl 要搜刮的子串
3260 ＠param with 调换字符串
3261
3262 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3263 /
3264 public static String replace（String text， String repl， String with） {
3265 return replace（text， repl， with， -1）;
3266 }
3267
3268 /
3269 调换指定的子串，调换指定的次数。
3270
3271 <p>
3272 若是字符串为<code>null</code>则返回<code>null</code>，若是指定子串为<code>null</code>，则返回原字符串。
3273 <pre>
3274 StringUtil.replace（null， ， ， ） = null
3275 StringUtil.replace（， ， ， ） =
3276 StringUtil.replace（abaa， null， null， 1） = abaa
3277 StringUtil.replace（abaa， null， null， 1） = abaa
3278 StringUtil.replace（abaa， a， null， 1） = abaa
3279 StringUtil.replace（abaa， a， ， 1） = baa
3280 StringUtil.replace（abaa， a， z， 0） = abaa
3281 StringUtil.replace（abaa， a， z， 1） = zbaa
3282 StringUtil.replace（abaa， a， z， 2） = zbza
3283 StringUtil.replace（abaa， a， z， -1） = zbzz
3284 </pre>
3285 </p>
3286
3287 ＠param text 要扫描的字符串
3288 ＠param repl 要搜刮的子串
3289 ＠param with 调换字符串
3290 ＠param max maximum number of values to replace， or <code>-1</code> if no maximum
3291
3292 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3293 /
3294 public static String replace（String text， String repl， String with， int max） {
3295 if （（text == null） || （repl == null） || （with == null） || （repl.length（） == 0）
3296 || （max == 0）） {
3297 return text;
3298 }
3299
3300 StringBuffer buf = new StringBuffer（text.length（））;
3301 int start = 0;
3302 int end = 0;
3303
3304 while （（end = text.indexOf（repl， start）） != -1） {
3305 buf.append（text.substring（start， end））.append（with）;
3306 start = end + repl.length（）;
3307
3308 if （--max == 0） {
3309 break;
3310 }
3311 }
3312
3313 buf.append（text.substring（start））;
3314 return buf.toString（）;
3315 }
3316
3317 /
3318 将字符串中所有指定的字符，调换成另一个。
3319
3320 <p>
3321 若是字符串为<code>null</code>则返回<code>null</code>。
3322 <pre>
3323 StringUtil.replaceChars（null， ， ） = null
3324 StringUtil.replaceChars（， ， ） =
3325 StringUtil.replaceChars（abcba， b， y） = aycya
3326 StringUtil.replaceChars（abcba， z， y） = abcba
3327 </pre>
3328 </p>
3329
3330 ＠param str 要扫描的字符串
3331 ＠param searchChar 要搜刮的字符
3332 ＠param replaceChar 调换字符
3333
3334 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3335 /
3336 public static String replaceChars（String str， char searchChar， char replaceChar） {
3337 if （str == null） {
3338 return null;
3339 }
3340
3341 return str.replace（searchChar， replaceChar）;
3342 }
3343
3344 /
3345 将字符串中所有指定的字符，调换成另一个。
3346
3347 <p>
3348 若是字符串为<code>null</code>则返回<code>null</code>。若是搜刮字符串为<code>null</code>或空，则返回原字符串。
3349 </p>
3350
3351 <p>
3352 例如： <code>replaceChars（"hello"， "ho"， "jy"） = jelly</code>。
3353 </p>
3354
3355 <p>
3356 凡是搜刮字符串和调换字符串是等长的，若是搜刮字符串比调换字符串长，则多余的字符将被删除。 若是搜刮字符串比调换字符串短，则缺乏的字符将被忽视。
3357 <pre>
3358 StringUtil.replaceChars（null， ， ） = null
3359 StringUtil.replaceChars（， ， ） =
3360 StringUtil.replaceChars（abc， null， ） = abc
3361 StringUtil.replaceChars（abc， ， ） = abc
3362 StringUtil.replaceChars（abc， b， null） = ac
3363 StringUtil.replaceChars（abc， b， ） = ac
3364 StringUtil.replaceChars（abcba， bc， yz） = ayzya
3365 StringUtil.replaceChars（abcba， bc， y） = ayya
3366 StringUtil.replaceChars（abcba， bc， yzx） = ayzya
3367 </pre>
3368 </p>
3369
3370 ＠param str 要扫描的字符串
3371 ＠param searchChars 要搜刮的字符串
3372 ＠param replaceChars 调换字符串
3373
3374 ＠return 被调换后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3375 /
3376 public static String replaceChars（String str， String searchChars， String replaceChars） {
3377 if （（str == null） || （str.length（） == 0） || （searchChars == null）
3378 || （searchChars.length（） == 0）） {
3379 return str;
3380 }
3381
3382 char[] chars = str.toCharArray（）;
3383 int len = chars.length;
3384 boolean modified = false;
3385
3386 for （int i = 0， isize = searchChars.length（）; i < isize; i++） {
3387 char searchChar = searchChars.charAt（i）;
3388
3389 if （（replaceChars == null） || （i >= replaceChars.length（））） {
3390 // 删除
3391 int pos = 0;
3392
3393 for （int j = 0; j < len; j++） {
3394 if （chars[j] != searchChar） {
3395 chars[pos++] = chars[j];
3396 } else {
3397 modified = true;
3398 }
3399 }
3400
3401 len = pos;
3402 } else {
3403 // 调换
3404 for （int j = 0; j < len; j++） {
3405 if （chars[j] == searchChar） {
3406 chars[j] = replaceChars.charAt（i）;
3407 modified = true;
3408 }
3409 }
3410 }
3411 }
3412
3413 if （!modified） {
3414 return str;
3415 }
3416
3417 return new String（chars， 0， len）;
3418 }
3419
3420 /
3421 将指定的子串用另一指定子串覆盖。
3422
3423 <p>
3424 若是字符串为<code>null</code>，则返回<code>null</code>。 负的索引值将被看作<code>0</code>，越界的索引值将被设置成字符串的长度雷同的值。
3425 <pre>
3426 StringUtil.overlay（null， ， ， ） = null
3427 StringUtil.overlay（， abc， 0， 0） = abc
3428 StringUtil.overlay（abcdef， null， 2， 4） = abef
3429 StringUtil.overlay（abcdef， ， 2， 4） = abef
3430 StringUtil.overlay（abcdef， ， 4， 2） = abef
3431 StringUtil.overlay（abcdef， zzzz， 2， 4） = abzzzzef
3432 StringUtil.overlay（abcdef， zzzz， 4， 2） = abzzzzef
3433 StringUtil.overlay（abcdef， zzzz， -1， 4） = zzzzef
3434 StringUtil.overlay（abcdef， zzzz， 2， 8） = abzzzz
3435 StringUtil.overlay（abcdef， zzzz， -2， -3） = zzzzabcdef
3436 StringUtil.overlay（abcdef， zzzz， 8， 10） = abcdefzzzz
3437 </pre>
3438 </p>
3439
3440 ＠param str 要扫描的字符串
3441 ＠param overlay 用来覆盖的字符串
3442 ＠param start 肇端索引
3443 ＠param end 停止索引
3444
3445 ＠return 被覆盖后的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3446 /
3447 public static String overlay（String str， String overlay， int start， int end） {
3448 if （str == null） {
3449 return null;
3450 }
3451
3452 if （overlay == null） {
3453 overlay = EMPTY_STRING;
3454 }
3455
3456 int len = str.length（）;
3457
3458 if （start < 0） {
3459 start = 0;
3460 }
3461
3462 if （start > len） {
3463 start = len;
3464 }
3465
3466 if （end < 0） {
3467 end = 0;
3468 }
3469
3470 if （end > len） {
3471 end = len;
3472 }
3473
3474 if （start > end） {
3475 int temp = start;
3476
3477 start = end;
3478 end = temp;
3479 }
3480
3481 return new StringBuffer（（len + start） - end + overlay.length（） + 1）.append（
3482 str.substring（0， start））.append（overlay）.append（str.substring（end））.toString（）;
3483 }
3484
3485 / ============================================================================ /
3486 / Perl风格的chomp和chop函数。 /
3487 / ============================================================================ /
3488
3489 /
3490 删除字符串末尾的换行符。若是字符串不以换行结尾，则什么也不做。
3491
3492 <p>
3493 换行符有三种景象："<code>\n</code>"、"<code>\r</code>"、"<code>\r\n</code>"。
3494 <pre>
3495 StringUtil.chomp（null） = null
3496 StringUtil.chomp（） =
3497 StringUtil.chomp（abc \r） = abc
3498 StringUtil.chomp（abc\n） = abc
3499 StringUtil.chomp（abc\r\n） = abc
3500 StringUtil.chomp（abc\r\n\r\n） = abc\r\n
3501 StringUtil.chomp（abc\n\r） = abc\n
3502 StringUtil.chomp（abc\n\rabc） = abc\n\rabc
3503 StringUtil.chomp（\r） =
3504 StringUtil.chomp（\n） =
3505 StringUtil.chomp（\r\n） =
3506 </pre>
3507 </p>
3508
3509 ＠param str 要处理惩罚的字符串
3510
3511 ＠return 不以换行结尾的字符串，若是原始字串为<code>null</code>，则返回<code>null</code>
3512 /
3513 public static String chomp（String str） {
3514 if （（str == null） || （str.length（） == 0）） {
3515 return str;
3516 }
3517
3518 if （str.length（） == 1） {
3519 char ch = str.charAt（0）;
3520
3521 if （（ch == \r） || （ch == \n）） {
3522 return EMPTY_STRING;
3523 } else {
3524 return str;
3525 }
3526 }
3527
3528 int lastIdx = str.length（） - 1;
3529 char last = str.charAt（lastIdx）;
3530
3531 if （last == \n） {
3532 if （str.charAt（lastIdx - 1） == \r） {
3533 lastIdx--;
3534 }
3535 } else if （last == \r） {
3536 } else {
3537 lastIdx++;
3538 }
3539
3540 return str.substring（0， lastIdx）;
3541 }
3542
3543 /
3544 删除字符串末尾的指定字符串。若是字符串不以该字符串结尾，则什么也不做。
3545 <pre>
3546 StringUtil.chomp（null， ） = null
3547 StringUtil.chomp（， ） =
3548 StringUtil.chomp（foobar， bar） = foo
3549 StringUtil.chomp（foobar， baz） = foobar
3550 StringUtil.chomp（foo， foo） =
3551 StringUtil.chomp（foo ， foo） = foo
3552 StringUtil.chomp（ foo， foo） =
3553 StringUtil.chomp（foo， foooo） = foo
3554 StringUtil.chomp（foo， ） = foo
3555 StringUtil.chomp（foo， null） = foo
3556 </pre>
3557
3558 ＠param str 要处理惩罚的字符串
3559 ＠param separator 要删除的字符串
3560
3561 ＠return 不以指定字符串结尾的字符串，若是原始字串为<code>null</code>，则返回<code>null</code>
3562 /
3563 public static String chomp（String str， String separator） {
3564 if （（str == null） || （str.length（） == 0） || （separator == null）） {
3565 return str;
3566 }
3567
3568 if （str.endsWith（separator）） {
3569 return str.substring（0， str.length（） - separator.length（））;
3570 }
3571
3572 return str;
3573 }
3574
3575 /
3576 删除最后一个字符。
3577
3578 <p>
3579 若是字符串以<code>\r\n</code>结尾，则同时删除它们。
3580 <pre>
3581 StringUtil.chop（null） = null
3582 StringUtil.chop（） =
3583 StringUtil.chop（abc \r） = abc
3584 StringUtil.chop（abc\n） = abc
3585 StringUtil.chop（abc\r\n） = abc
3586 StringUtil.chop（abc） = ab
3587 StringUtil.chop（abc\nabc） = abc\nab
3588 StringUtil.chop（a） =
3589 StringUtil.chop（\r） =
3590 StringUtil.chop（\n） =
3591 StringUtil.chop（\r\n） =
3592 </pre>
3593 </p>
3594
3595 ＠param str 要处理惩罚的字符串
3596
3597 ＠return 删除最后一个字符的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3598 /
3599 public static String chop（String str） {
3600 if （str == null） {
3601 return null;
3602 }
3603
3604 int strLen = str.length（）;
3605
3606 if （strLen < 2） {
3607 return EMPTY_STRING;
3608 }
3609
3610 int lastIdx = strLen - 1;
3611 String ret = str.substring（0， lastIdx）;
3612 char last = str.charAt（lastIdx）;
3613
3614 if （last == \n） {
3615 if （ret.charAt（lastIdx - 1） == \r） {
3616 return ret.substring（0， lastIdx - 1）;
3617 }
3618 }
3619
3620 return ret;
3621 }
3622
3623 / ============================================================================ /
3624 / 反复/对齐字符串。 /
3625 / ============================================================================ /
3626
3627 /
3628 将指定字符串反复n遍。
3629 <pre>
3630 StringUtil.repeat（null， 2） = null
3631 StringUtil.repeat（， 0） =
3632 StringUtil.repeat（， 2） =
3633 StringUtil.repeat（a， 3） = aaa
3634 StringUtil.repeat（ab， 2） = abab
3635 StringUtil.repeat（abcd， 2） = abcdabcd
3636 StringUtil.repeat（a， -2） =
3637 </pre>
3638
3639 ＠param str 要反复的字符串
3640 ＠param repeat 反复次数，若是小于<code>0</code>，则看作<code>0</code>
3641
3642 ＠return 反复n次的字符串，若是原始字符串为<code>null</code>，则返回<code>null</code>
3643 /
3644 public static String repeat（String str， int repeat） {
3645 if （str == null） {
3646 return null;
3647 }
3648
3649 if （repeat <= 0） {
3650 return EMPTY_STRING;
3651 }
3652
3653 int inputLength = str.length（）;
3654
3655 if （（repeat == 1） || （inputLength == 0）） {
3656 return str;
3657 }
3658
3659 int outputLength = inputLength repeat;
3660
3661 switch （inputLength） {
3662 case 1:
3663
3664 char ch = str.charAt（0）;
3665 char[] output1 = new char[outputLength];
3666
3667 for （int i = repeat - 1; i >= 0; i--） {
3668 output1[i] = ch;
3669 }
3670
3671 return new String（output1）;
3672
3673 case 2:
3674
3675 char ch0 = str.charAt（0）;
3676 char ch1 = str.charAt（1）;
3677 char[] output2 = new char[outputLength];
3678
3679 for （int i = （repeat 2） - 2; i >= 0; i--， i--） {
3680 output2[i] = ch0;
3681 output2[i + 1] = ch1;
3682 }
3683
3684 return new String（output2）;
3685
3686 default:
3687
3688 StringBuffer buf = new StringBuffer（outputLength）;
3689
3690 for （int i = 0; i < repeat; i++） {
3691 buf.append（str）;
3692 }
3693
3694 return buf.toString（）;
3695 }
3696 }
3697
3698 /
3699 扩大并左对齐字符串，用空格<code> </code>填充右边。
3700 <pre>
3701 StringUtil.alignLeft（null， ） = null
3702 StringUtil.alignLeft（， 3） =
3703 StringUtil.alignLeft（bat， 3） = bat
3704 StringUtil.alignLeft（bat， 5） = bat
3705 StringUtil.alignLeft（bat， 1） = bat
3706 StringUtil.alignLeft（bat， -1） = bat
3707 </pre>
3708
3709 ＠param str 要对齐的字符串
3710 ＠param size 扩大字符串到指定宽度
3711
3712 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3713 /
3714 public static String alignLeft（String str， int size） {
3715 return alignLeft（str， size， ）;
3716 }
3717
3718 /
3719 扩大并左对齐字符串，用指定字符填充右边。
3720 <pre>
3721 StringUtil.alignLeft（null， ， ） = null
3722 StringUtil.alignLeft（， 3， z） = zzz
3723 StringUtil.alignLeft（bat， 3， z） = bat
3724 StringUtil.alignLeft（bat， 5， z） = batzz
3725 StringUtil.alignLeft（bat， 1， z） = bat
3726 StringUtil.alignLeft（bat， -1， z） = bat
3727 </pre>
3728
3729 ＠param str 要对齐的字符串
3730 ＠param size 扩大字符串到指定宽度
3731 ＠param padChar 填充字符
3732
3733 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3734 /
3735 public static String alignLeft（String str， int size， char padChar） {
3736 if （str == null） {
3737 return null;
3738 }
3739
3740 int pads = size - str.length（）;
3741
3742 if （pads <= 0） {
3743 return str;
3744 }
3745
3746 return alignLeft（str， size， String.valueOf（padChar））;
3747 }
3748
3749 /
3750 扩大并左对齐字符串，用指定字符串填充右边。
3751 <pre>
3752 StringUtil.alignLeft（null， ， ） = null
3753 StringUtil.alignLeft（， 3， z） = zzz
3754 StringUtil.alignLeft（bat， 3， yz） = bat
3755 StringUtil.alignLeft（bat， 5， yz） = batyz
3756 StringUtil.alignLeft（bat， 8， yz） = batyzyzy
3757 StringUtil.alignLeft（bat， 1， yz） = bat
3758 StringUtil.alignLeft（bat， -1， yz） = bat
3759 StringUtil.alignLeft（bat， 5， null） = bat
3760 StringUtil.alignLeft（bat， 5， ） = bat
3761 </pre>
3762
3763 ＠param str 要对齐的字符串
3764 ＠param size 扩大字符串到指定宽度
3765 ＠param padStr 填充字符串
3766
3767 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3768 /
3769 public static String alignLeft（String str， int size， String padStr） {
3770 if （str == null） {
3771 return null;
3772 }
3773
3774 if （（padStr == null） || （padStr.length（） == 0）） {
3775 padStr = ;
3776 }
3777
3778 int padLen = padStr.length（）;
3779 int strLen = str.length（）;
3780 int pads = size - strLen;
3781
3782 if （pads <= 0） {
3783 return str;
3784 }
3785
3786 if （pads == padLen） {
3787 return str.concat（padStr）;
3788 } else if （pads < padLen） {
3789 return str.concat（padStr.substring（0， pads））;
3790 } else {
3791 char[] padding = new char[pads];
3792 char[] padChars = padStr.toCharArray（）;
3793
3794 for （int i = 0; i < pads; i++） {
3795 padding[i] = padChars[i ％ padLen];
3796 }
3797
3798 return str.concat（new String（padding））;
3799 }
3800 }
3801
3802 /
3803 扩大并右对齐字符串，用空格<code> </code>填充左边。
3804 <pre>
3805 StringUtil.alignRight（null， ） = null
3806 StringUtil.alignRight（， 3） =
3807 StringUtil.alignRight（bat， 3） = bat
3808 StringUtil.alignRight（bat， 5） = bat
3809 StringUtil.alignRight（bat， 1） = bat
3810 StringUtil.alignRight（bat， -1） = bat
3811 </pre>
3812
3813 ＠param str 要对齐的字符串
3814 ＠param size 扩大字符串到指定宽度
3815
3816 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3817 /
3818 public static String alignRight（String str， int size） {
3819 return alignRight（str， size， ）;
3820 }
3821
3822 /
3823 扩大并右对齐字符串，用指定字符填充左边。
3824 <pre>
3825 StringUtil.alignRight（null， ， ） = null
3826 StringUtil.alignRight（， 3， z） = zzz
3827 StringUtil.alignRight（bat， 3， z） = bat
3828 StringUtil.alignRight（bat， 5， z） = zzbat
3829 StringUtil.alignRight（bat， 1， z） = bat
3830 StringUtil.alignRight（bat， -1， z） = bat
3831 </pre>
3832
3833 ＠param str 要对齐的字符串
3834 ＠param size 扩大字符串到指定宽度
3835 ＠param padChar 填充字符
3836
3837 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3838 /
3839 public static String alignRight（String str， int size， char padChar） {
3840 if （str == null） {
3841 return null;
3842 }
3843
3844 int pads = size - str.length（）;
3845
3846 if （pads <= 0） {
3847 return str;
3848 }
3849
3850 return alignRight（str， size， String.valueOf（padChar））;
3851 }
3852
3853 /
3854 扩大并右对齐字符串，用指定字符串填充左边。
3855 <pre>
3856 StringUtil.alignRight（null， ， ） = null
3857 StringUtil.alignRight（， 3， z） = zzz
3858 StringUtil.alignRight（bat， 3， yz） = bat
3859 StringUtil.alignRight（bat， 5， yz） = yzbat
3860 StringUtil.alignRight（bat， 8， yz） = yzyzybat
3861 StringUtil.alignRight（bat， 1， yz） = bat
3862 StringUtil.alignRight（bat， -1， yz） = bat
3863 StringUtil.alignRight（bat， 5， null） = bat
3864 StringUtil.alignRight（bat， 5， ） = bat
3865 </pre>
3866
3867 ＠param str 要对齐的字符串
3868 ＠param size 扩大字符串到指定宽度
3869 ＠param padStr 填充字符串
3870
3871 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3872 /
3873 public static String alignRight（String str， int size， String padStr） {
3874 if （str == null） {
3875 return null;
3876 }
3877
3878 if （（padStr == null） || （padStr.length（） == 0）） {
3879 padStr = ;
3880 }
3881
3882 int padLen = padStr.length（）;
3883 int strLen = str.length（）;
3884 int pads = size - strLen;
3885
3886 if （pads <= 0） {
3887 return str;
3888 }
3889
3890 if （pads == padLen） {
3891 return padStr.concat（str）;
3892 } else if （pads < padLen） {
3893 return padStr.substring（0， pads）.concat（str）;
3894 } else {
3895 char[] padding = new char[pads];
3896 char[] padChars = padStr.toCharArray（）;
3897
3898 for （int i = 0; i < pads; i++） {
3899 padding[i] = padChars[i ％ padLen];
3900 }
3901
3902 return new String（padding）.concat（str）;
3903 }
3904 }
3905
3906 /
3907 扩大并居中字符串，用空格<code> </code>填充两边。
3908 <pre>
3909 StringUtil.center（null， ） = null
3910 StringUtil.center（， 4） =
3911 StringUtil.center（ab， -1） = ab
3912 StringUtil.center（ab， 4） = ab
3913 StringUtil.center（abcd， 2） = abcd
3914 StringUtil.center（a， 4） = a
3915 </pre>
3916
3917 ＠param str 要对齐的字符串
3918 ＠param size 扩大字符串到指定宽度
3919
3920 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3921 /
3922 public static String center（String str， int size） {
3923 return center（str， size， ）;
3924 }
3925
3926 /
3927 扩大并居中字符串，用指定字符填充两边。
3928 <pre>
3929 StringUtil.center（null， ， ） = null
3930 StringUtil.center（， 4， ） =
3931 StringUtil.center（ab， -1， ） = ab
3932 StringUtil.center（ab， 4， ） = ab
3933 StringUtil.center（abcd， 2， ） = abcd
3934 StringUtil.center（a， 4， ） = a
3935 StringUtil.center（a， 4， y） = yayy
3936 </pre>
3937
3938 ＠param str 要对齐的字符串
3939 ＠param size 扩大字符串到指定宽度
3940 ＠param padChar 填充字符
3941
3942 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3943 /
3944 public static String center（String str， int size， char padChar） {
3945 if （（str == null） || （size <= 0）） {
3946 return str;
3947 }
3948
3949 int strLen = str.length（）;
3950 int pads = size - strLen;
3951
3952 if （pads <= 0） {
3953 return str;
3954 }
3955
3956 str = alignRight（str， strLen + （pads / 2）， padChar）;
3957 str = alignLeft（str， size， padChar）;
3958 return str;
3959 }
3960
3961 /
3962 扩大并居中字符串，用指定字符串填充两边。
3963 <pre>
3964 StringUtil.center（null， ， ） = null
3965 StringUtil.center（， 4， ） =
3966 StringUtil.center（ab， -1， ） = ab
3967 StringUtil.center（ab， 4， ） = ab
3968 StringUtil.center（abcd， 2， ） = abcd
3969 StringUtil.center（a， 4， ） = a
3970 StringUtil.center（a， 4， yz） = yayz
3971 StringUtil.center（abc， 7， null） = abc
3972 StringUtil.center（abc， 7， ） = abc
3973 </pre>
3974
3975 ＠param str 要对齐的字符串
3976 ＠param size 扩大字符串到指定宽度
3977 ＠param padStr 填充字符串
3978
3979 ＠return 扩大后的字符串，若是字符串为<code>null</code>，则返回<code>null</code>
3980 /
3981 public static String center（String str， int size， String padStr） {
3982 if （（str == null） || （size <= 0）） {
3983 return str;
3984 }
3985
3986 if （（padStr == null） || （padStr.length（） == 0）） {
3987 padStr = ;
3988 }
3989
3990 int strLen = str.length（）;
3991 int pads = size - strLen;
3992
3993 if （pads <= 0） {
3994 return str;
3995 }
3996
3997 str = alignRight（str， strLen + （pads / 2）， padStr）;
3998 str = alignLeft（str， size， padStr）;
3999 return str;
4000 }
4001
4002 / ============================================================================ /
4003 / 反转字符串。 /
4004 / ============================================================================ /
4005
4006 /
4007 反转字符串中的字符次序。
4008
4009 <p>
4010 若是字符串为<code>null</code>，则返回<code>null</code>。
4011 </p>
4012 <pre>
4013 StringUtil.reverse（null） = null
4014 StringUtil.reverse（） =
4015 StringUtil.reverse（bat） = tab
4016 </pre>
4017
4018 ＠param str 要反转的字符串
4019
4020 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4021 /
4022 public static String reverse（String str） {
4023 if （（str == null） || （str.length（） == 0）） {
4024 return str;
4025 }
4026
4027 return new StringBuffer（str）.reverse（）.toString（）;
4028 }
4029
4030 /
4031 反转指定分隔符分隔的各子串的次序。
4032
4033 <p>
4034 若是字符串为<code>null</code>，则返回<code>null</code>。
4035 </p>
4036 <pre>
4037 StringUtil.reverseDelimited（null， ） = null
4038 StringUtil.reverseDelimited（， ） =
4039 StringUtil.reverseDelimited（a.b.c， x） = a.b.c
4040 StringUtil.reverseDelimited（a.b.c， .） = c.b.a
4041 </pre>
4042
4043 ＠param str 要反转的字符串
4044 ＠param separatorChar 分隔符
4045
4046 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4047 /
4048 public static String reverseDelimited（String str， char separatorChar） {
4049 if （str == null） {
4050 return null;
4051 }
4052
4053 String[] strs = split（str， separatorChar）;
4054
4055 ArrayUtil.reverse（strs）;
4056
4057 return join（strs， separatorChar）;
4058 }
4059
4060 /
4061 反转指定分隔符分隔的各子串的次序。
4062
4063 <p>
4064 若是字符串为<code>null</code>，则返回<code>null</code>。
4065 </p>
4066 <pre>
4067 StringUtil.reverseDelimited（null， ， ） = null
4068 StringUtil.reverseDelimited（， ， ） =
4069 StringUtil.reverseDelimited（a.b.c， null， null） = a.b.c
4070 StringUtil.reverseDelimited（a.b.c， ， null） = a.b.c
4071 StringUtil.reverseDelimited（a.b.c， .， ，） = c，b，a
4072 StringUtil.reverseDelimited（a.b.c， .， null） = c b a
4073 </pre>
4074
4075 ＠param str 要反转的字符串
4076 ＠param separatorChars 分隔符，若是为<code>null</code>，则默认应用空白字符
4077 ＠param separator 用来连接子串的分隔符，若是为<code>null</code>，默认应用空格
4078
4079 ＠return 反转后的字符串，若是原字符串为<code>null</code>，则返回<code>null</code>
4080 /
4081 public static String reverseDelimited（String str， String separatorChars， String separator） {
4082 if （str == null） {
4083 return null;
4084 }
4085
4086 String[] strs = split（str， separatorChars）;
4087
4088 ArrayUtil.reverse（strs）;
4089
4090 if （separator == null） {
4091 return join（strs， ）;
4092 }
4093
4094 return join（strs， separator）;
4095 }
4096
4097 / ============================================================================ /
4098 / 取得字符串的缩略。 /
4099 / ============================================================================ /
4100
4101 /
4102 将字符串转换成指定长度的缩略，例如： 将Now is the time for all good men转换成Now is the time for...。
4103
4104 <ul>
4105 <li>
4106 若是<code>str</code>比<code>maxWidth</code>短，直接返回；
4107 </li>
4108 <li>
4109 不然将它转换成缩略：<code>substring（str， 0， max-3） + ...</code>；
4110 </li>
4111 <li>
4112 若是<code>maxWidth</code>小于<code>4</code>抛出<code>IllegalArgumentException</code>；
4113 </li>
4114 <li>
4115 返回的字符串不成能善于指定的<code>maxWidth</code>。
4116 </li>
4117 </ul>
4118
4119 <pre>
4120 StringUtil.abbreviate（null， ） = null
4121 StringUtil.abbreviate（， 4） =
4122 StringUtil.abbreviate（abcdefg， 6） = abc...
4123 StringUtil.abbreviate（abcdefg， 7） = abcdefg
4124 StringUtil.abbreviate（abcdefg， 8） = abcdefg
4125 StringUtil.abbreviate（abcdefg， 4） = a...
4126 StringUtil.abbreviate（abcdefg， 3） = IllegalArgumentException
4127 </pre>
4128
4129 ＠param str 要搜检的字符串
4130 ＠param maxWidth 最大长度，不小于<code>4</code>，若是小于<code>4</code>，则看作<code>4</code>
4131
4132 ＠return 字符串缩略，若是原始字符串为<code>null</code>则返回<code>null</code>
4133 /
4134 public static String abbreviate（String str， int maxWidth） {
4135 return abbreviate（str， 0， maxWidth）;
4136 }
4137
4138 /
4139 将字符串转换成指定长度的缩略，例如： 将Now is the time for all good men转换成...is the time for...。
4140
4141 <p>
4142 和<code>abbreviate（String， int）</code>类似，然则增长了一个“左鸿沟”偏移量。
4143 重视，“左鸿沟”处的字符未必呈如今成果字符串的最左边，但必然呈如今成果字符串中。
4144 </p>
4145
4146 <p>
4147 返回的字符串不成能善于指定的<code>maxWidth</code>。
4148 <pre>
4149 StringUtil.abbreviate（null， ， ） = null
4150 StringUtil.abbreviate（， 0， 4） =
4151 StringUtil.abbreviate（abcdefghijklmno， -1， 10） = abcdefg...
4152 StringUtil.abbreviate（abcdefghijklmno， 0， 10） = abcdefg...
4153 StringUtil.abbreviate（abcdefghijklmno， 1， 10） = abcdefg...
4154 StringUtil.abbreviate（abcdefghijklmno， 4， 10） = abcdefg...
4155 StringUtil.abbreviate（abcdefghijklmno， 5， 10） = ...fghi...
4156 StringUtil.abbreviate（abcdefghijklmno， 6， 10） = ...ghij...
4157 StringUtil.abbreviate（abcdefghijklmno， 8， 10） = ...ijklmno
4158 StringUtil.abbreviate（abcdefghijklmno， 10， 10） = ...ijklmno
4159 StringUtil.abbreviate（abcdefghijklmno， 12， 10） = ...ijklmno
4160 StringUtil.abbreviate（abcdefghij， 0， 3） = IllegalArgumentException
4161 StringUtil.abbreviate（abcdefghij， 5， 6） = IllegalArgumentException
4162 </pre>
4163 </p>
4164
4165 ＠param str 要搜检的字符串
4166 ＠param offset 左鸿沟偏移量
4167 ＠param maxWidth 最大长度，不小于<code>4</code>，若是小于<code>4</code>，则看作<code>4</code>
4168
4169 ＠return 字符串缩略，若是原始字符串为<code>null</code>则返回<code>null</code>
4170 /
4171 public static String abbreviate（String str， int offset， int maxWidth） {
4172 if （str == null） {
4173 return null;
4174 }
4175
4176 // 调剂最大宽度
4177 if （maxWidth < 4） {
4178 maxWidth = 4;
4179 }
4180
4181 if （str.length（） <= maxWidth） {
4182 return str;
4183 }
4184
4185 if （offset > str.length（）） {
4186 offset = str.length（）;
4187 }
4188
4189 if （（str.length（） - offset） < （maxWidth - 3）） {
4190 offset = str.length（） - （maxWidth - 3）;
4191 }
4192
4193 if （offset <= 4） {
4194 return str.substring（0， maxWidth - 3） + ...;
4195 }
4196
4197 // 调剂最大宽度
4198 if （maxWidth < 7） {
4199 maxWidth = 7;
4200 }
4201
4202 if （（offset + （maxWidth - 3）） < str.length（）） {
4203 return ... + abbreviate（str.substring（offset）， maxWidth - 3）;
4204 }
4205
4206 return ... + str.substring（str.length（） - （maxWidth - 3））;
4207 }
4208
4209 / ============================================================================ /
4210 / 斗劲两个字符串的异同。 /
4211 / /
4212 / 查找字符串之间的差别，斗劲字符串的类似度。 /
4213 / ============================================================================ /
4214
4215 /
4216 斗劲两个字符串，取得第二个字符串中，和第一个字符串不合的项目组。
4217 <pre>
4218 StringUtil.difference（i am a machine， i am a robot） = robot
4219 StringUtil.difference（null， null） = null
4220 StringUtil.difference（， ） =
4221 StringUtil.difference（， null） =
4222 StringUtil.difference（， abc） = abc
4223 StringUtil.difference（abc， ） =
4224 StringUtil.difference（abc， abc） =
4225 StringUtil.difference（ab， abxyz） = xyz
4226 StringUtil.difference（abcde， abxyz） = xyz
4227 StringUtil.difference（abcde， xyz） = xyz
4228 </pre>
4229
4230 ＠param str1 字符串1
4231 ＠param str2 字符串2
4232
4233 ＠return 第二个字符串中，和第一个字符串不合的项目组。若是两个字符串雷同，则返回空字符串<code></code>
4234 /
4235 public static String difference（String str1， String str2） {
4236 if （str1 == null） {
4237 return str2;
4238 }
4239
4240 if （str2 == null） {
4241 return str1;
4242 }
4243
4244 int index = indexOfDifference（str1， str2）;
4245
4246 if （index == -1） {
4247 return EMPTY_STRING;
4248 }
4249
4250 return str2.substring（index）;
4251 }
4252
4253 /
4254 斗劲两个字符串，取得两字符串开端不合的索引值。
4255 <pre>
4256 StringUtil.indexOfDifference（i am a machine， i am a robot） = 7
4257 StringUtil.indexOfDifference（null， null） = -1
4258 StringUtil.indexOfDifference（， null） = -1
4259 StringUtil.indexOfDifference（， ） = -1
4260 StringUtil.indexOfDifference（， abc） = 0
4261 StringUtil.indexOfDifference（abc， ） = 0
4262 StringUtil.indexOfDifference（abc， abc） = -1
4263 StringUtil.indexOfDifference（ab， abxyz） = 2
4264 StringUtil.indexOfDifference（abcde， abxyz） = 2
4265 StringUtil.indexOfDifference（abcde， xyz） = 0
4266 </pre>
4267
4268 ＠param str1 字符串1
4269 ＠param str2 字符串2
4270
4271 ＠return 两字符串开端产生差别的索引值，若是两字符串雷同，则返回<code>-1</code>
4272 /
4273 public static int indexOfDifference（String str1， String str2） {
4274 if （（str1 == str2） || （str1 == null） || （str2 == null）） {
4275 return -1;
4276 }
4277
4278 int i;
4279
4280 for （i = 0; （i < str1.length（）） && （i < str2.length（））; ++i） {
4281 if （str1.charAt（i） != str2.charAt（i）） {
4282 break;
4283 }
4284 }
4285
4286 if （（i < str2.length（）） || （i < str1.length（））） {
4287 return i;
4288 }
4289
4290 return -1;
4291 }
4292
4293 /
4294 取得两个字符串的类似度，<code>0</code>代表字符串相等，数字越大默示字符串越不像。
4295
4296 <p>
4297 这个算法取自<a href=http://www.merriampark.com/ld.htm>http://www.merriampark.com/ld.htm</a>。
4298 它策画的是从字符串1改变到字符串2所须要的删除、插入和调换的步调数。
4299 </p>
4300 <pre>
4301 StringUtil.getLevenshteinDistance（null， ） = IllegalArgumentException
4302 StringUtil.getLevenshteinDistance（， null） = IllegalArgumentException
4303 StringUtil.getLevenshteinDistance（，） = 0
4304 StringUtil.getLevenshteinDistance（，a） = 1
4305 StringUtil.getLevenshteinDistance（aaapppp， ） = 7
4306 StringUtil.getLevenshteinDistance（frog， fog） = 1
4307 StringUtil.getLevenshteinDistance（fly， ant） = 3
4308 StringUtil.getLevenshteinDistance（elephant， hippo） = 7
4309 StringUtil.getLevenshteinDistance（hippo， elephant） = 7
4310 StringUtil.getLevenshteinDistance（hippo， zzzzzzzz） = 8
4311 StringUtil.getLevenshteinDistance（hello， hallo） = 1
4312 </pre>
4313
4314 ＠param s 第一个字符串，若是是<code>null</code>，则看作空字符串
4315 ＠param t 第二个字符串，若是是<code>null</code>，则看作空字符串
4316
4317 ＠return 类似度值
4318 /
4319 public static int getLevenshteinDistance（String s， String t） {
4320 s = defaultIfNull（s）;
4321 t = defaultIfNull（t）;
4322
4323 int[][] d; // matrix
4324 int n; // length of s
4325 int m; // length of t
4326 int i; // iterates through s
4327 int j; // iterates through t
4328 char s_i; // ith character of s
4329 char t_j; // jth character of t
4330 int cost; // cost
4331
4332 // Step 1
4333 n = s.length（）;
4334 m = t.length（）;
4335
4336 if （n == 0） {
4337 return m;
4338 }
4339
4340 if （m == 0） {
4341 return n;
4342 }
4343
4344 d = new int[n + 1][m + 1];
4345
4346 // Step 2
4347 for （i = 0; i <= n; i++） {
4348 d[i][0] = i;
4349 }
4350
4351 for （j = 0; j <= m; j++） {
4352 d[0][j] = j;
4353 }
4354
4355 // Step 3
4356 for （i = 1; i <= n; i++） {
4357 s_i = s.charAt（i - 1）;
4358
4359 // Step 4
4360 for （j = 1; j <= m; j++） {
4361 t_j = t.charAt（j - 1）;
4362
4363 // Step 5
4364 if （s_i == t_j） {
4365 cost = 0;
4366 } else {
4367 cost = 1;
4368 }
4369
4370 // Step 6
4371 d[i][j] = min（d[i - 1][j] + 1， d[i][j - 1] + 1， d[i - 1][j - 1] + cost）;
4372 }
4373 }
4374
4375 // Step 7
4376 return d[n][m];
4377 }
4378
4379 /
4380 取得最小数。
4381
4382 ＠param a 整数1
4383 ＠param b 整数2
4384 ＠param c 整数3
4385
4386 ＠return 三个数中的最小值
4387 /
4388 private static int min（int a， int b， int c） {
4389 if （b < a） {
4390 a = b;
4391 }
4392
4393 if （c < a） {
4394 a = c;
4395 }
4396
4397 return a;
4398 }
4399 }
View Code
彼此相爱，却不要让爱成了束缚：不如让它成为涌动的大海，两岸乃是你们的灵魂。互斟满杯，却不要同饮一杯。相赠面包，却不要共食一个。一起歌舞欢喜，却依然各自独立，相互交心，却不是让对方收藏。因为唯有生命之手，方能收容你们的心。站在一起却不要过于靠近。—— 纪伯伦《先知》
