1 import java.util.ArrayList;   2 import java.util.List;   3    4 /**   5 * 字符串相关的工具类   6 *   7 * @author Fsx   8 *   9 */  10 public class StringUtil {  11 /**  12 * 判断一个字符串是否为空或等于空字符串  13 *  14 * @param s  15 *            字符串  16 * @return 是否为空或空字符串  17 */  18 public static final boolean isEmpty(String s) {  19 return s == null || s.trim().length() == 0;  20 }  21   22 /**  23 * 判断一个字符串是否不为空且不等于空字符串  24 *  25 * @param s  26 *            字符串  27 * @return 是否不为空且不等于空字符串  28 */  29 public static final boolean isNotEmpty(String s) {  30 return s != null && s.trim().length() > 0;  31 }  32   33 /**  34 * 判断一个字符串是否不为空且不等于空字符串 也不等于"0"  35 *  36 * @param s  37 *            字符串  38 * @return 是否不为空且不等于空字符串 也不等于"0"  39 */  40 public static final boolean isNotEmptyOr0(String s) {  41 return isNotEmpty(s) && !s.trim().equals("0");  42 }  43   44 /**  45 * 去除字符串的头尾空格(包括中文空格)  46 *  47 * @param input  48 *            输入的字符串  49 * @return 去掉头尾空格后的字符串  50 */  51 public static String trimAll(String input) {  52 return input.replaceAll("(^\\pZ+)|(\\pZ+$)", "");  53 }  54   55 /**  56 * 去除字符串的头部空格(包括中文空格)  57 *  58 * @param input  59 *            输入的字符串  60 * @return 去掉头部空格后的字符串  61 */  62 public static String trimAllHead(String input) {  63 return input.replaceAll("^\\pZ+", "");  64 }  65   66 /**  67 * 去除字符串的尾部空格(包括中文空格)  68 *  69 * @param input  70 *            输入的字符串  71 * @return 去掉尾部空格后的字符串  72 */  73 public static String trimAllTail(String input) {  74 return input.replaceAll("\\pZ+$", "");  75 }  76   77 /**  78 * 去掉字符串中的单引号和双引号 为了避免输入法中自带的分词符号和自动完成组件同时使用时导致SQL错误的BUG  79 *  80 * @param input  81 *            输入的字符串  82 * @return 去掉单引号和双引号后的字符串  83 */  84 public static final String removeQuote(String input) {  85 if (input == null) {  86 return null;  87 }  88 return input.replace("\‘", "").replace("\"", "");  89 }  90   91 /**  92 * 将一个对象转化为字符串(为了避免JAVA本身的空对象转换为null这种情况)  93 *  94 * @param object  95 *            要转化成字符串的对象  96 * @return 转化成的字符串  97 */  98 public static final String toString(Object object) {  99 return object != null ? object.toString() : ""; 100 } 101  102 /** 103 * 将字符串数组拼接成"a,b,c,d"的形式 默认以逗号拼接 104 * 105 * @param stringArray 106 *            字符串数组 107 * @return 拼接后的字符串 108 */ 109 public static final String join(String[] stringArray) { 110 return join(stringArray, ‘,‘); 111 } 112  113 /** 114 * 将字符串数组拼接成"a b c d"的形式 中间以空格拼接 115 * 116 * @param stringArray 117 *            字符串数组 118 * @return 拼接后的字符串 119 */ 120 public static final String joinWithSpace(String[] stringArray) { 121 return join(stringArray, ‘ ‘); 122 } 123  124 /** 125 * 将字符串数组拼接成"a b c d"的形式 中间以separator分隔 126 * 127 * @param stringArray 128 *            字符串数组 129 * @param separator 130 *            分隔符 131 * @return 拼接后的字符串 132 */ 133 public static final String join(String[] stringArray, char separator) { 134 return join(stringArray, String.valueOf(separator)); 135 } 136  137 /** 138 * 将字符串数组拼接成"a b c d"的形式 中间以separator分隔 139 * 140 * @param stringArray 141 *            字符串数组 142 * @param separator 143 *            分隔字符串 144 * @return 拼接后的字符串 145 */ 146 public static final String join(String[] stringArray, String separator) { 147 if (stringArray == null || stringArray.length == 0) { 148 return ""; 149 } 150 if (stringArray.length == 1) { 151 return stringArray[0]; 152 } 153 StringBuilder stringBuilder = new StringBuilder(); 154 stringBuilder.append(stringArray[0]); 155 for (int i = 1; i < stringArray.length; i++) { 156 if (stringArray[i] == null) { 157 continue; 158 } 159 stringBuilder.append(separator).append(stringArray[i]); 160 } 161 return stringBuilder.toString(); 162 } 163  164 /** 165 * 将字符串列表拼接成"a,b,c,d"的形式 默认以逗号拼接 166 * 167 * @param stringList 168 *            字符串列表 169 * @return 拼接后的字符串 170 */ 171 public static final String join(List<String> stringList) { 172 return join(stringList, ‘,‘); 173 } 174  175 /** 176 * 将字符串列表拼接成"a b c d"的形式 中间以空格拼接 177 * 178 * @param stringList 179 *            字符串列表 180 * @return 拼接后的字符串 181 */ 182 public static final String joinWithSpace(List<String> stringList) { 183 return join(stringList, ‘ ‘); 184 } 185  186 /** 187 * 将字符串列表拼接成"a b c d"的形式 中间以separator分隔 188 * 189 * @param stringList 190 *            字符串列表 191 * @param separator 192 *            分隔符 193 * @return 拼接后的字符串 194 */ 195 public static final String join(List<String> stringList, char separator) { 196 return join(stringList, String.valueOf(separator)); 197 } 198  199 /** 200 * 将字符串列表拼接成"a b c d"的形式 中间以separator分隔 201 * 202 * @param stringList 203 *            字符串列表 204 * @param separator 205 *            分隔字符串 206 * @return 拼接后的字符串 207 */ 208 public static final String join(List<String> stringList, String separator) { 209 if (stringList == null || stringList.size() == 0) { 210 return ""; 211 } 212 if (stringList.size() == 1) { 213 return stringList.get(0); 214 } 215 StringBuilder stringBuilder = new StringBuilder(); 216 stringBuilder.append(stringList.get(0)); 217 for (int i = 1; i < stringList.size(); i++) { 218 if (stringList.get(i) == null) { 219 continue; 220 } 221 stringBuilder.append(separator).append(stringList.get(i)); 222 } 223 return stringBuilder.toString(); 224 } 225  226 /** 227 * 将长整数数组拼接成"a,b,c,d"的形式 默认以逗号拼接 228 * 229 * @param longArray 230 *            长整数数组 231 * @return 拼接后的字符串 232 */ 233 public static final String joinLong(Long[] longArray) { 234 return joinLong(longArray, ‘,‘); 235 } 236  237 /** 238 * 将长整数数组拼接成"a b c d"的形式 中间以空格拼接 239 * 240 * @param longArray 241 *            长整数数组 242 * @return 拼接后的字符串 243 */ 244 public static final String joinLongWithSpace(Long[] longArray) { 245 return joinLong(longArray, ‘ ‘); 246 } 247  248 /** 249 * 将长整数数组拼接成"a b c d"的形式 中间以separator分隔 250 * 251 * @param longArray 252 *            长整数数组 253 * @param separator 254 *            分隔符 255 * @return 拼接后的字符串 256 */ 257 public static final String joinLong(Long[] longArray, char separator) { 258 return joinLong(longArray, String.valueOf(separator)); 259 } 260  261 /** 262 * 将长整数数组拼接成"a b c d"的形式 中间以separator分隔 263 * 264 * @param longArray 265 *            长整数数组 266 * @param separator 267 *            分隔字符串 268 * @return 拼接后的字符串 269 */ 270 public static final String joinLong(Long[] longArray, String separator) { 271 if (longArray == null || longArray.length == 0) { 272 return ""; 273 } 274 if (longArray.length == 1) { 275 return longArray[0].toString(); 276 } 277 StringBuilder stringBuilder = new StringBuilder(); 278 stringBuilder.append(longArray[0]); 279 for (int i = 1; i < longArray.length; i++) { 280 if (longArray[i] == null) { 281 continue; 282 } 283 stringBuilder.append(separator).append(longArray[i].longValue()); 284 } 285 return stringBuilder.toString(); 286 } 287  288 /** 289 * 将长整数列表拼接成"a,b,c,d"的形式 默认以逗号拼接 290 * 291 * @param longList 292 *            长整数列表 293 * @return 拼接后的字符串 294 */ 295 public static final String joinLong(List<Long> longList) { 296 return joinLong(longList, ‘,‘); 297 } 298  299 /** 300 * 将长整数列表拼接成"a b c d"的形式 中间以空格拼接 301 * 302 * @param longList 303 *            长整数列表 304 * @return 拼接后的字符串 305 */ 306 public static final String joinLongWithSpace(List<Long> longList) { 307 return joinLong(longList, ‘ ‘); 308 } 309  310 /** 311 * 将长整数列表拼接成"a b c d"的形式 中间以separator分隔 312 * 313 * @param longList 314 *            长整数列表 315 * @param separator 316 *            分隔符 317 * @return 拼接后的字符串 318 */ 319 public static final String joinLong(List<Long> longList, char separator) { 320 return joinLong(longList, String.valueOf(separator)); 321 } 322  323 /** 324 * 将长整数列表拼接成"a b c d"的形式 中间以separator分隔 325 * 326 * @param longList 327 *            长整数列表 328 * @param separator 329 *            分隔字符串 330 * @return 拼接后的字符串 331 */ 332 public static final String joinLong(List<Long> longList, String separator) { 333 if (longList == null || longList.size() == 0) { 334 return ""; 335 } 336 if (longList.size() == 1) { 337 return longList.get(0).toString(); 338 } 339 StringBuilder stringBuilder = new StringBuilder(); 340 stringBuilder.append(longList.get(0)); 341 for (int i = 1; i < longList.size(); i++) { 342 if (longList.get(i) == null) { 343 continue; 344 } 345 stringBuilder.append(separator).append(longList.get(i).longValue()); 346 } 347 return stringBuilder.toString(); 348 } 349  350 /** 351 * 将整数数组拼接成"a,b,c,d"的形式 默认以逗号拼接 352 * 353 * @param integerArray 354 *            整数数组 355 * @return 拼接后的字符串 356 */ 357 public static final String joinInteger(Integer[] integerArray) { 358 return joinInteger(integerArray, ‘,‘); 359 } 360  361 /** 362 * 将整数数组拼接成"a b c d"的形式 中间以空格拼接 363 * 364 * @param integerArray 365 *            整数数组 366 * @return 拼接后的字符串 367 */ 368 public static final String joinIntegerWithSpace(Integer[] integerArray) { 369 return joinInteger(integerArray, ‘ ‘); 370 } 371  372 /** 373 * 将整数数组拼接成"a b c d"的形式 中间以separator分隔 374 * 375 * @param integerArray 376 *            整数数组 377 * @param separator 378 *            分隔符 379 * @return 拼接后的字符串 380 */ 381 public static final String joinInteger(Integer[] integerArray, char separator) { 382 return joinInteger(integerArray, String.valueOf(separator)); 383 } 384  385 /** 386 * 将整数数组拼接成"a b c d"的形式 中间以separator分隔 387 * 388 * @param integerArray 389 *            整数数组 390 * @param separator 391 *            分隔字符串 392 * @return 拼接后的字符串 393 */ 394 public static final String joinInteger(Integer[] integerArray, String separator) { 395 if (integerArray == null || integerArray.length == 0) { 396 return ""; 397 } 398 if (integerArray.length == 1) { 399 return integerArray[0].toString(); 400 } 401 StringBuilder stringBuilder = new StringBuilder(); 402 stringBuilder.append(integerArray[0]); 403 for (int i = 1; i < integerArray.length; i++) { 404 if (integerArray[i] == null) { 405 continue; 406 } 407 stringBuilder.append(separator).append(integerArray[i].intValue()); 408 } 409 return stringBuilder.toString(); 410 } 411  412 /** 413 * 将整数列表拼接成"a,b,c,d"的形式 默认以逗号拼接 414 * 415 * @param integerList 416 *            整数列表 417 * @return 拼接后的字符串 418 */ 419 public static final String joinInteger(List<Integer> integerList) { 420 return joinInteger(integerList, ‘,‘); 421 } 422  423 /** 424 * 将整数列表拼接成"a b c d"的形式 中间以空格拼接 425 * 426 * @param integerList 427 *            整数列表 428 * @return 拼接后的字符串 429 */ 430 public static final String joinIntegerWithSpace(List<Integer> integerList) { 431 return joinInteger(integerList, ‘ ‘); 432 } 433  434 /** 435 * 将整数列表拼接成"a b c d"的形式 中间以separator分隔 436 * 437 * @param integerList 438 *            整数列表 439 * @param separator 440 *            分隔符 441 * @return 拼接后的字符串 442 */ 443 public static final String joinInteger(List<Integer> integerList, char separator) { 444 return joinInteger(integerList, String.valueOf(separator)); 445 } 446  447 /** 448 * 将整数列表拼接成"a b c d"的形式 中间以separator分隔 449 * 450 * @param integerList 451 *            整数列表 452 * @param separator 453 *            分隔字符串 454 * @return 拼接后的字符串 455 */ 456 public static final String joinInteger(List<Integer> integerList, String separator) { 457 if (integerList == null || integerList.size() == 0) { 458 return ""; 459 } 460 if (integerList.size() == 1) { 461 return integerList.get(0).toString(); 462 } 463 StringBuilder stringBuilder = new StringBuilder(); 464 stringBuilder.append(integerList.get(0)); 465 for (int i = 1; i < integerList.size(); i++) { 466 if (integerList.get(i) == null) { 467 continue; 468 } 469 stringBuilder.append(separator).append(integerList.get(i).intValue()); 470 } 471 return stringBuilder.toString(); 472 } 473  474 /** 475 * 将短整数数组拼接成"a,b,c,d"的形式 默认以逗号拼接 476 * 477 * @param shortArray 478 *            短整数数组 479 * @return 拼接后的字符串 480 */ 481 public static final String joinShort(Short[] shortArray) { 482 return joinShort(shortArray, ‘,‘); 483 } 484  485 /** 486 * 将短整数数组拼接成"a b c d"的形式 中间以空格拼接 487 * 488 * @param shortArray 489 *            短整数数组 490 * @return 拼接后的字符串 491 */ 492 public static final String joinShortWithSpace(Short[] shortArray) { 493 return joinShort(shortArray, ‘ ‘); 494 } 495  496 /** 497 * 将短整数数组拼接成"a b c d"的形式 中间以separator分隔 498 * 499 * @param shortArray 500 *            短整数数组 501 * @param separator 502 *            分隔符 503 * @return 拼接后的字符串 504 */ 505 public static final String joinShort(Short[] shortArray, char separator) { 506 return joinShort(shortArray, String.valueOf(separator)); 507 } 508  509 /** 510 * 将短整数数组拼接成"a b c d"的形式 中间以separator分隔 511 * 512 * @param shortArray 513 *            短整数数组 514 * @param separator 515 *            分隔字符串 516 * @return 拼接后的字符串 517 */ 518 public static final String joinShort(Short[] shortArray, String separator) { 519 if (shortArray == null || shortArray.length == 0) { 520 return ""; 521 } 522 if (shortArray.length == 1) { 523 return shortArray[0].toString(); 524 } 525 StringBuilder stringBuilder = new StringBuilder(); 526 stringBuilder.append(shortArray[0]); 527 for (int i = 1; i < shortArray.length; i++) { 528 if (shortArray[i] == null) { 529 continue; 530 } 531 stringBuilder.append(separator).append(shortArray[i].intValue()); 532 } 533 return stringBuilder.toString(); 534 } 535  536 /** 537 * 将短整数列表拼接成"a,b,c,d"的形式 默认以逗号拼接 538 * 539 * @param shortList 540 *            短整数列表 541 * @return 拼接后的字符串 542 */ 543 public static final String joinShort(List<Short> shortList) { 544 return joinShort(shortList, ‘,‘); 545 } 546  547 /** 548 * 将短整数列表拼接成"a b c d"的形式 中间以空格拼接 549 * 550 * @param shortList 551 *            短整数列表 552 * @return 拼接后的字符串 553 */ 554 public static final String joinShortWithSpace(List<Short> shortList) { 555 return joinShort(shortList, ‘ ‘); 556 } 557  558 /** 559 * 将短整数列表拼接成"a b c d"的形式 中间以separator分隔 560 * 561 * @param shortList 562 *            短整数列表 563 * @param separator 564 *            分隔符 565 * @return 拼接后的字符串 566 */ 567 public static final String joinShort(List<Short> shortList, char separator) { 568 return joinShort(shortList, String.valueOf(separator)); 569 } 570  571 /** 572 * 将短整数列表拼接成"a b c d"的形式 中间以separator分隔 573 * 574 * @param shortList 575 *            短整数列表 576 * @param separator 577 *            分隔字符串 578 * @return 拼接后的字符串 579 */ 580 public static final String joinShort(List<Short> shortList, String separator) { 581 if (shortList == null || shortList.size() == 0) { 582 return ""; 583 } 584 if (shortList.size() == 1) { 585 return shortList.get(0).toString(); 586 } 587 StringBuilder stringBuilder = new StringBuilder(); 588 stringBuilder.append(shortList.get(0)); 589 for (int i = 1; i < shortList.size(); i++) { 590 if (shortList.get(i) == null) { 591 continue; 592 } 593 stringBuilder.append(separator).append(shortList.get(i).intValue()); 594 } 595 return stringBuilder.toString(); 596 } 597  598 /** 599 * 将字符串分隔成字符串数组 默认以逗号分隔 600 * 601 * @param param 602 *            字符串 603 * @return 分隔成的字符串数组 604 */ 605 public static final String[] toStringArray(String param) { 606 return toStringArray(param, ‘,‘); 607 } 608  609 /** 610 * 将字符串分隔成字符串数组 以空格分隔 611 * 612 * @param param 613 *            字符串 614 * @return 分隔成的字符串数组 615 */ 616 public static final String[] toStringArrayBySpace(String param) { 617 return toStringArray(param, ‘ ‘); 618 } 619  620 /** 621 * 将字符串分隔成字符串数组 以separator分隔 622 * 623 * @param param 624 *            字符串 625 * @param separator 626 *            分隔符 627 * @return 分隔成的字符串数组 628 */ 629 public static final String[] toStringArray(String param, char separator) { 630 return toStringArray(param, String.valueOf(separator)); 631 } 632  633 /** 634 * 将字符串分隔成字符串数组 以separator分隔 635 * 636 * @param param 637 *            字符串 638 * @param separator 639 *            分隔字符串 640 * @return 分隔成的字符串数组 641 */ 642 public static final String[] toStringArray(String param, String separator) { 643 if (isEmpty(param)) { 644 return new String[0]; 645 } 646 return param.split(separator.equals(",") ? "\\," : separator); 647 } 648  649 /** 650 * 将字符串分隔成字符串列表 默认以逗号分隔 651 * 652 * @param param 653 *            字符串 654 * @return 分隔成的字符串列表 655 */ 656 public static final List<String> toStringList(String param) { 657 return toStringList(param, ‘,‘); 658 } 659  660 /** 661 * 将字符串分隔成字符串列表 以空格分隔 662 * 663 * @param param 664 *            字符串 665 * @return 分隔成的字符串列表 666 */ 667 public static final List<String> toStringListByWhiteSpace(String param) { 668 return toStringList(param, ‘ ‘); 669 } 670  671 /** 672 * 将字符串分隔成字符串列表 以separator分隔 673 * 674 * @param param 675 *            字符串 676 * @return 分隔成的字符串列表 677 */ 678 public static final List<String> toStringList(String param, char separator) { 679 return toStringList(param, String.valueOf(separator)); 680 } 681  682 /** 683 * 将字符串分隔成字符串列表 以separator分隔 684 * 685 * @param param 686 *            字符串 687 * @param separator 688 *            分隔字符串 689 * @return 分隔成的字符串列表 690 */ 691 public static final List<String> toStringList(String param, String separator) { 692 String[] stringArray = toStringArray(param, separator); 693 List<String> stringList = new ArrayList<String>(); 694 for (int i = 0; i < stringArray.length; i++) { 695 stringList.add(stringArray[i]); 696 } 697 return stringList; 698 } 699  700 /** 701 * 将字符串分隔成长整数数组 默认以逗号分隔 702 * 703 * @param param 704 *            字符串 705 * @return 分隔成的长整数数组 706 */ 707 public static final Long[] toLongArray(String param) { 708 return toLongArray(param, ‘,‘); 709 } 710  711 /** 712 * 将字符串分隔成长整数数组 以空格分隔 713 * 714 * @param param 715 *            字符串 716 * @return 分隔成的长整数数组 717 */ 718 public static final Long[] toLongArrayBySpace(String param) { 719 return toLongArray(param, ‘ ‘); 720 } 721  722 /** 723 * 将字符串分隔成长整数数组 以separator分隔 724 * 725 * @param param 726 *            字符串 727 * @param separator 728 *            分隔符 729 * @return 分隔成的长整数数组 730 */ 731 public static final Long[] toLongArray(String param, char separator) { 732 return toLongArray(param, String.valueOf(separator)); 733 } 734  735 /** 736 * 将字符串分隔成长整数数组 以separator分隔 737 * 738 * @param param 739 *            字符串 740 * @param separator 741 *            分隔字符串 742 * @return 分隔成的长整数数组 743 */ 744 public static final Long[] toLongArray(String param, String separator) { 745 String[] stringArray = toStringArray(param, separator); 746 Long[] longArray = new Long[stringArray.length]; 747 for (int i = 0; i < stringArray.length; i++) { 748 longArray[i] = Long.parseLong(stringArray[i]); 749 } 750 return longArray; 751 } 752  753 /** 754 * 将字符串分隔成长整数列表 默认以逗号分隔 755 * 756 * @param param 757 *            字符串 758 * @return 分隔成的长整数列表 759 */ 760 public static final List<Long> toLongList(String param) { 761 return toLongList(param, ‘,‘); 762 } 763  764 /** 765 * 将字符串分隔成长整数列表 以空格分隔 766 * 767 * @param param 768 *            字符串 769 * @return 分隔成的长整数列表 770 */ 771 public static final List<Long> toLongListByWhiteSpace(String param) { 772 return toLongList(param, ‘ ‘); 773 } 774  775 /** 776 * 将字符串分隔成长整数列表 以separator分隔 777 * 778 * @param param 779 *            字符串 780 * @return 分隔成的长整数列表 781 */ 782 public static final List<Long> toLongList(String param, char separator) { 783 return toLongList(param, String.valueOf(separator)); 784 } 785  786 /** 787 * 将字符串分隔成长整数列表 以separator分隔 788 * 789 * @param param 790 *            字符串 791 * @param separator 792 *            分隔字符串 793 * @return 分隔成的长整数列表 794 */ 795 public static final List<Long> toLongList(String param, String separator) { 796 List<String> stringList = toStringList(param, separator); 797 List<Long> longList = new ArrayList<Long>(stringList.size()); 798 for (int i = 0; i < stringList.size(); i++) { 799 longList.add(Long.parseLong(stringList.get(i))); 800 } 801 return longList; 802 } 803  804 /** 805 * 将字符串分隔成整数数组 默认以逗号分隔 806 * 807 * @param param 808 *            字符串 809 * @return 分隔成的整数数组 810 */ 811 public static final Integer[] toIntegerArray(String param) { 812 return toIntegerArray(param, ‘,‘); 813 } 814  815 /** 816 * 将字符串分隔成整数数组 以空格分隔 817 * 818 * @param param 819 *            字符串 820 * @return 分隔成的整数数组 821 */ 822 public static final Integer[] toIntegerArrayBySpace(String param) { 823 return toIntegerArray(param, ‘ ‘); 824 } 825  826 /** 827 * 将字符串分隔成整数数组 以separator分隔 828 * 829 * @param param 830 *            字符串 831 * @param separator 832 *            分隔符 833 * @return 分隔成的整数数组 834 */ 835 public static final Integer[] toIntegerArray(String param, char separator) { 836 return toIntegerArray(param, String.valueOf(separator)); 837 } 838  839 /** 840 * 将字符串分隔成整数数组 以separator分隔 841 * 842 * @param param 843 *            字符串 844 * @param separator 845 *            分隔字符串 846 * @return 分隔成的整数数组 847 */ 848 public static final Integer[] toIntegerArray(String param, String separator) { 849 String[] stringArray = toStringArray(param, separator); 850 Integer[] integerArray = new Integer[stringArray.length]; 851 for (int i = 0; i < stringArray.length; i++) { 852 integerArray[i] = Integer.parseInt(stringArray[i]); 853 } 854 return integerArray; 855 } 856  857 /** 858 * 将字符串分隔成整数列表 默认以逗号分隔 859 * 860 * @param param 861 *            字符串 862 * @return 分隔成的整数列表 863 */ 864 public static final List<Integer> toIntegerList(String param) { 865 return toIntegerList(param, ‘,‘); 866 } 867  868 /** 869 * 将字符串分隔成整数列表 以空格分隔 870 * 871 * @param param 872 *            字符串 873 * @return 分隔成的整数列表 874 */ 875 public static final List<Integer> toIntegerListByWhiteSpace(String param) { 876 return toIntegerList(param, ‘ ‘); 877 } 878  879 /** 880 * 将字符串分隔成整数列表 以separator分隔 881 * 882 * @param param 883 *            字符串 884 * @return 分隔成的整数列表 885 */ 886 public static final List<Integer> toIntegerList(String param, char separator) { 887 return toIntegerList(param, String.valueOf(separator)); 888 } 889  890 /** 891 * 将字符串分隔成整数列表 以separator分隔 892 * 893 * @param param 894 *            字符串 895 * @param separator 896 *            分隔字符串 897 * @return 分隔成的整数列表 898 */ 899 public static final List<Integer> toIntegerList(String param, String separator) { 900 List<String> stringList = toStringList(param, separator); 901 List<Integer> integerList = new ArrayList<Integer>(stringList.size()); 902 for (int i = 0; i < stringList.size(); i++) { 903 integerList.add(Integer.parseInt(stringList.get(i))); 904 } 905 return integerList; 906 } 907  908 /** 909 * 将字符串分隔成短整数数组 默认以逗号分隔 910 * 911 * @param param 912 *            字符串 913 * @return 分隔成的短整数数组 914 */ 915 public static final Short[] toShortArray(String param) { 916 return toShortArray(param, ‘,‘); 917 } 918  919 /** 920 * 将字符串分隔成短整数数组 以空格分隔 921 * 922 * @param param 923 *            字符串 924 * @return 分隔成的短整数数组 925 */ 926 public static final Short[] toShortArrayBySpace(String param) { 927 return toShortArray(param, ‘ ‘); 928 } 929  930 /** 931 * 将字符串分隔成短整数数组 以separator分隔 932 * 933 * @param param 934 *            字符串 935 * @param separator 936 *            分隔符 937 * @return 分隔成的短整数数组 938 */ 939 public static final Short[] toShortArray(String param, char separator) { 940 return toShortArray(param, String.valueOf(separator)); 941 } 942  943 /** 944 * 将字符串分隔成短整数数组 以separator分隔 945 * 946 * @param param 947 *            字符串 948 * @param separator 949 *            分隔字符串 950 * @return 分隔成的短整数数组 951 */ 952 public static final Short[] toShortArray(String param, String separator) { 953 String[] stringArray = toStringArray(param, separator); 954 Short[] shortArray = new Short[stringArray.length]; 955 for (int i = 0; i < stringArray.length; i++) { 956 shortArray[i] = Short.parseShort(stringArray[i]); 957 } 958 return shortArray; 959 } 960  961 /** 962 * 将字符串分隔成短整数列表 默认以逗号分隔 963 * 964 * @param param 965 *            字符串 966 * @return 分隔成的短整数列表 967 */ 968 public static final List<Short> toShortList(String param) { 969 return toShortList(param, ‘,‘); 970 } 971  972 /** 973 * 将字符串分隔成短整数列表 以空格分隔 974 * 975 * @param param 976 *            字符串 977 * @return 分隔成的短整数列表 978 */ 979 public static final List<Short> toShortListByWhiteSpace(String param) { 980 return toShortList(param, ‘ ‘); 981 } 982  983 /** 984 * 将字符串分隔成短整数列表 以separator分隔 985 * 986 * @param param 987 *            字符串 988 * @return 分隔成的短整数列表 989 */ 990 public static final List<Short> toShortList(String param, char separator) { 991 return toShortList(param, String.valueOf(separator)); 992 } 993  994 /** 995 * 将字符串分隔成短整数列表 以separator分隔 996 * 997 * @param param 998 *            字符串 999 * @param separator1000 *            分隔字符串1001 * @return 分隔成的短整数列表1002 */1003 public static final List<Short> toShortList(String param, String separator) {1004 List<String> stringList = toStringList(param, separator);1005 List<Short> shortList = new ArrayList<Short>(stringList.size());1006 for (int i = 0; i < stringList.size(); i++) {1007 shortList.add(Short.parseShort(stringList.get(i)));1008 }1009 return shortList;1010 }1011 }