Java 字符串工具类持续更新中非原创

   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 separator
1000 *            分隔字符串
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 }