StringHelper

   1 /**
   2  * <html>
   3  * <body>
   4  *  <P> Copyright 1994 JsonInternational</p>
   5  *  <p> All rights reserved.</p>
   6  *  <p> Created on 19941115</p>
   7  *  <p> Created by Jason</p>
   8  *  </body>
   9  * </html>
  10  */
  11 package cn.ucaner.alpaca.framework.utils.string;
  12 
  13 import java.io.UnsupportedEncodingException;
  14 import java.net.URLEncoder;
  15 import java.text.DecimalFormat;
  16 import java.text.SimpleDateFormat;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.Date;
  20 import java.util.HashMap;
  21 import java.util.Iterator;
  22 import java.util.LinkedHashSet;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Map.Entry;
  26 import java.util.Random;
  27 import java.util.Set;
  28 import java.util.StringTokenizer;
  29 
  30 import org.apache.commons.lang3.StringUtils;
  31 import org.apache.commons.logging.Log;
  32 import org.apache.commons.logging.LogFactory;
  33 
  34 /**
  35 * @Package：cn.ucaner.framework.utils   
  36 * @ClassName：StringHelper   
  37 * @Description：   <p>---字符串工具类---</p>
  38 * @Author： - Jason 
  39 * @CreatTime：2017年8月30日 下午2:06:53   
  40 * @Modify By：   
  41 * @ModifyTime：  
  42 * @Modify marker：   
  43 * @version    V1.0
  44  */
  45 public class StringHelper {
  46 
  47     public static Log logger = LogFactory.getLog(StringHelper.class);
  48 
  49     /**
  50      * 前导标识
  51      */
  52     public static final int BEFORE = 1;
  53 
  54     /**
  55      * 后继标识
  56      */
  57     public static final int AFTER = 2;
  58 
  59     public static final String DEFAULT_PATH_SEPARATOR = ",";
  60 
  61     /**
  62      * 将一个中间带逗号分隔符的字符串转换为ArrayList对象
  63      * 
  64      * @param str
  65      *            待转换的符串对象
  66      * @return ArrayList对象
  67      */
  68     public static ArrayList<?> strToArrayList(String str) {
  69         return strToArrayListManager(str, DEFAULT_PATH_SEPARATOR);
  70     }
  71 
  72     /**
  73      * 将字符串对象按给定的分隔符separator转象为ArrayList对象
  74      * 
  75      * @param str
  76      *            待转换的字符串对象
  77      * @param separator
  78      *            字符型分隔符
  79      * @return ArrayList对象
  80      */
  81     public static ArrayList<String> strToArrayList(String str, String separator) {
  82         return strToArrayListManager(str, separator);
  83     }
  84 
  85     /**
  86      * @Description: 分割
  87      * @param str
  88      * @param separator
  89      * @return ArrayList<String>
  90      * @Autor: jasonandy@hotmail.com
  91      */
  92     private static ArrayList<String> strToArrayListManager(String str, String separator) {
  93 
  94         StringTokenizer strTokens = new StringTokenizer(str, separator);
  95         ArrayList<String> list = new ArrayList<String>();
  96 
  97         while (strTokens.hasMoreTokens()) {
  98             list.add(strTokens.nextToken().trim());
  99         }
 100 
 101         return list;
 102     }
 103 
 104     /**
 105      * 将一个中间带逗号分隔符的字符串转换为字符型数组对象
 106      * 
 107      * @param str
 108      *            待转换的符串对象
 109      * @return 字符型数组
 110      */
 111     public static String[] strToStrArray(String str) {
 112         return strToStrArrayManager(str, DEFAULT_PATH_SEPARATOR);
 113     }
 114 
 115     /**
 116      * 将字符串对象按给定的分隔符separator转象为字符型数组对象
 117      * 
 118      * @param str  待转换的符串对象
 119      * @param separator 字符型分隔符
 120      * @return 字符型数组
 121      */
 122     public static String[] strToStrArray(String str, String separator) {
 123         return strToStrArrayManager(str, separator);
 124     }
 125 
 126     private static String[] strToStrArrayManager(String str, String separator) {
 127 
 128         StringTokenizer strTokens = new StringTokenizer(str, separator);
 129         String[] strArray = new String[strTokens.countTokens()];
 130         int i = 0;
 131 
 132         while (strTokens.hasMoreTokens()) {
 133             strArray[i] = strTokens.nextToken().trim();
 134             i++;
 135         }
 136 
 137         return strArray;
 138     }
 139 
 140     public static Set<String> strToSet(String str) {
 141         return strToSet(str, DEFAULT_PATH_SEPARATOR);
 142     }
 143 
 144     public static Set<String> strToSet(String str, String separator) {
 145         String[] values = strToStrArray(str, separator);
 146         Set<String> result = new LinkedHashSet<String>();
 147         for (int i = 0; i < values.length; i++) {
 148             result.add(values[i]);
 149         }
 150         return result;
 151     }
 152 
 153     /**
 154      * 将一个数组，用逗号分隔变为一个字符串
 155      * @param array
 156      * @return modify by yuce reason:user StringBuffer replace "+"
 157      */
 158     public static String ArrayToStr(Object[] array) {
 159         if (array == null || array.length < 0) {
 160             return null;
 161         }
 162         StringBuffer sb = new StringBuffer();
 163         for (Object obj : array) {
 164             if (StringUtils.isNotBlank(obj.toString())) {
 165                 if (sb.length() > 0) {
 166                     sb.append(DEFAULT_PATH_SEPARATOR);
 167                 }
 168                 sb.append(obj.toString());
 169             }
 170         }
 171         return sb.toString();
 172     }
 173 
 174     public static String CollectionToStr(Collection<String> coll) {
 175         StringBuffer sb = new StringBuffer();
 176         int i = 0;
 177         for (String string : coll) {
 178             if (i > 0) {
 179                 sb.append(",");
 180             }
 181             i++;
 182             sb.append(string);
 183         }
 184         return sb.toString();
 185     }
 186 
 187     /**
 188      * 转换给定字符串的编码格式
 189      * @param inputString  待转换字符串对象
 190      * @param inencoding 待转换字符串的编码格式
 191      * @param outencoding  准备转换为的编码格式
 192      * @return 指定编码与字符串的字符串对象
 193      */
 194     public static String encodingTransfer(String inputString, String inencoding, String outencoding) {
 195         if (inputString == null || inputString.length() == 0) {
 196             return inputString;
 197         }
 198         try {
 199             return new String(inputString.getBytes(outencoding), inencoding);
 200         } catch (Exception e) {
 201             return inputString;
 202         }
 203     }
 204 
 205     /**
 206      * 删除字符串中指定的字符 只要在delStrs参数中出现的字符，并且在inputString中也出现都会将其它删除
 207      * @param inputString 待做删除处理的字符串
 208      * @param delStrs  作为删除字符的参照数据，用逗号分隔。如果要删除逗号可以在这个字符串再加一个逗号
 209      * @return 返回一个以inputString为基础不在delStrs出现新字符串
 210      */
 211     public static String delString(String inputString, String delStrs) {
 212         if (inputString == null || inputString.length() == 0) {
 213             return inputString;
 214         }
 215         String[] strs = strToStrArray(delStrs);
 216         for (int i = 0; i < strs.length; i++) {
 217             if ("".equals(strs[i])) {
 218                 inputString = inputString.replaceAll(" ", "");
 219             } else {
 220                 if (strs[i].compareTo("a") >= 0) {
 221                     inputString = replace(inputString, strs[i], "");
 222                 } else {
 223                     inputString = inputString.replaceAll("\\" + strs[i], "");
 224                 }
 225             }
 226         }
 227         if (subCount(delStrs, ",") > strs.length) {
 228             inputString = inputString.replaceAll("\\,", "");
 229         }
 230         return inputString;
 231     }
 232 
 233     /**
 234      * 去除左边多余的空格。
 235      * @param value  待去左边空格的字符串
 236      * @return 去掉左边空格后的字符串
 237      */
 238     public static String trimLeft(String value) {
 239         String result = value;
 240         if (result == null) {
 241             return result;
 242         }
 243         char[] ch = result.toCharArray();
 244         int index = -1;
 245         for (int i = 0; i < ch.length; i++) {
 246             if (Character.isWhitespace(ch[i])) {
 247                 index = i;
 248             } else {
 249                 break;
 250             }
 251         }
 252         if (index != -1) {
 253             result = result.substring(index + 1);
 254         }
 255         return result;
 256     }
 257 
 258     /**
 259      * 去除右边多余的空格。
 260      * @param value 待去右边空格的字符串
 261      * @return 去掉右边空格后的字符串
 262      */
 263     public static String trimRight(String value) {
 264         String result = value;
 265         if (result == null) {
 266             return result;
 267         }
 268         char[] ch = result.toCharArray();
 269         int endIndex = -1;
 270         for (int i = ch.length - 1; i > -1; i--) {
 271             if (Character.isWhitespace(ch[i])) {
 272                 endIndex = i;
 273             } else {
 274                 break;
 275             }
 276         }
 277         if (endIndex != -1) {
 278             result = result.substring(0, endIndex);
 279         }
 280         return result;
 281     }
 282 
 283     /**
 284      * 判断一个字符串中是否包含另一个字符串
 285      * @param parentStr  父串
 286      * @param subStr  子串
 287      * @return 如果父串包含子串的内容返回真，否则返回假
 288      */
 289     public static boolean isInclude(String parentStr, String subStr) {
 290         return parentStr.indexOf(subStr) >= 0;
 291     }
 292 
 293     /**
 294      * 判断一个字符串中是否包含另一个字符串数组的任何一个
 295      * @param parentStr    父串
 296      * @param subStrs  子串集合(以逗号分隔的字符串)
 297      * @return 如果父串包含子串的内容返回真，否则返回假
 298      */
 299     public static boolean isIncludes(String parentStr, String subStrs) {
 300         String[] subStrArray = strToStrArray(subStrs);
 301         for (int j = 0; j < subStrArray.length; j++) {
 302             String subStr = subStrArray[j];
 303             if (isInclude(parentStr, subStr)) {
 304                 return true;
 305             } else {
 306                 continue;
 307             }
 308         }
 309         return false;
 310     }
 311 
 312     /**
 313      * 判断一个子字符串在父串中重复出现的次数
 314      * @param parentStr 父串
 315      * @param subStr  子串
 316      * @return 子字符串在父字符串中重得出现的次数
 317      */
 318     public static int subCount(String parentStr, String subStr) {
 319         int count = 0;
 320 
 321         for (int i = 0; i < ( parentStr.length() - subStr.length() ); i++) {
 322             String tempString = parentStr.substring(i, i + subStr.length());
 323             if (subStr.equals(tempString)) {
 324                 count++;
 325             }
 326         }
 327         return count;
 328     }
 329 
 330     /**
 331      * 得到在字符串中从开始字符串到结止字符串中间的子串
 332      * @param parentStr 父串
 333      * @param startStr 开始串
 334      * @param endStr 结止串
 335      * @return 返回开始串与结止串之间的子串
 336      */
 337     public static String subString(String parentStr, String startStr, String endStr) {
 338         return parentStr.substring(parentStr.indexOf(startStr) + startStr.length(), parentStr.indexOf(endStr));
 339     }
 340 
 341     /**
 342      * 得到在字符串中从开始字符串到结止字符串中间的子串的集合
 343      * @param parentStr  父串
 344      * @param startStr 开始串
 345      * @param endStr 结止串
 346      * @return 返回开始串与结止串之间的子串的集合
 347      */
 348     public static List<String> subStringList(String parentStr, String startStr, String endStr) {
 349         List<String> result = new ArrayList<String>();
 350         List<String> elements = dividToList(parentStr, startStr, endStr);
 351         for (String element : elements) {
 352             if (!isIncludes(element, startStr) || !isIncludes(element, endStr)) {
 353                 continue;
 354             }
 355             result.add(subString(element, startStr, endStr));
 356         }
 357         return result;
 358 
 359     }
 360 
 361     /**
 362      * 将指定的String转换为Unicode的等价值
 363      * 基础知识： 所有的转义字符都是由 '\' 打头的第二个字符 0-9 :八进制 u :是Unicode转意，长度固定为6位 Other:则为以下字母中的一个 b,t,n,f,r,",\ 都不满足，则产生一个编译错误
 364      * 提供八进制也是为了和C语言兼容. b,t,n,f,r 则是为控制字符.书上的意思为:描述数据流的发送者希望那些信息如何被格式化或者被表示. 它可以写在代码的任意位置，只要转义后是合法的. 例如: int c=0\u003b
 365      * 上面的代码可以编译通过，等同于int c=0; \u003b也就是';'的Unicode代码
 366      * 
 367      * @param str 待转换为Unicode的等价字符串
 368      * @return Unicode的字符串
 369      */
 370     public static String getUnicodeStr(String inStr) {
 371         char[] myBuffer = inStr.toCharArray();
 372         StringBuffer sb = new StringBuffer();
 373 
 374         for (int i = 0; i < inStr.length(); i++) {
 375             byte b = (byte) myBuffer[i];
 376             short s = (short) myBuffer[i];
 377             String hexB = Integer.toHexString(b);
 378             String hexS = Integer.toHexString(s);
 379             /*
 380              * //输出为大写 String hexB = Integer.toHexString(b).toUpperCase(); String hexS =
 381              * Integer.toHexString(s).toUpperCase(); //print char sb.append("char["); sb.append(i); sb.append("]='");
 382              * sb.append(myBuffer[i]); sb.append("'\t");
 383              * 
 384              * //byte value sb.append("byte="); sb.append(b); sb.append(" \\u"); sb.append(hexB); sb.append('\t');
 385              */
 386 
 387             // short value
 388             sb.append(" \\u");
 389             sb.append(fillStr(hexS, "0", 4, AFTER));
 390             // sb.append('\t');
 391             // Unicode Block
 392             // sb.append(Character.UnicodeBlock.of(myBuffer[i]));
 393         }
 394 
 395         return sb.toString();
 396 
 397     }
 398 
 399     /**
 400      * 判断一个字符串是否是合法的Java标识符
 401      * @param s 待判断的字符串
 402      * @return 如果参数s是一个合法的Java标识符返回真，否则返回假
 403      */
 404     public static boolean isJavaIdentifier(String s) {
 405         if (s.length() == 0 || Character.isJavaIdentifierStart(s.charAt(0))) {
 406             return false;
 407         }
 408         for (int i = 0; i < s.length(); i++)
 409             if (!Character.isJavaIdentifierPart(s.charAt(i))) {
 410                 return false;
 411             }
 412         return true;
 413     }
 414 
 415     /**
 416      * 替换字符串中满足条件的字符 例如: replaceAll("\com\hi\platform\base\\util",'\\','/'); 返回的结果为: /com/hi/platform/base/util
 417      * @param str 待替换的字符串
 418      * @param oldchar   待替换的字符
 419      * @param newchar 替换为的字符
 420      * @return 将str中的所有oldchar字符全部替换为newchar,并返回这个替换后的字符串
 421      */
 422     public static String replaceAll(String str, char oldchar, char newchar) {
 423         char[] chars = str.toCharArray();
 424         for (int i = 0; i < chars.length; i++) {
 425             if (chars[i] == oldchar) {
 426                 chars[i] = newchar;
 427             }
 428         }
 429         return new String(chars);
 430     }
 431 
 432     /**
 433      * 如果inStr字符串与没有给定length的长度，则用fill填充，在指定direction的方向 如果inStr字符串长度大于length就直截返回inStr，不做处理
 434      * 
 435      * @param inStr
 436      *            待处理的字符串
 437      * @param fill
 438      *            以该字符串作为填充字符串
 439      * @param length
 440      *            填充后要求的长度
 441      * @param direction
 442      *            填充方向，如果是AFTER填充在后面，否则填充在前面
 443      * @return 返回一个指定长度填充后的字符串
 444      */
 445     public static String fillStr(String inStr, String fill, int length, int direction) {
 446         if (inStr == null || inStr.length() > length || inStr.length() == 0) {
 447             return inStr;
 448         }
 449         StringBuffer tempStr = new StringBuffer("");
 450         for (int i = 0; i < length - inStr.length(); i++) {
 451             tempStr.append(fill);
 452         }
 453 
 454         if (direction == AFTER) {
 455             return new String(tempStr.toString() + inStr);
 456         } else {
 457             return new String(inStr + tempStr.toString());
 458         }
 459     }
 460 
 461     /**
 462      * 字符串替换
 463      * 
 464      * @param str
 465      *            源字符串
 466      * @param pattern
 467      *            待替换的字符串
 468      * @param replace
 469      *            替换为的字符串
 470      * @return
 471      */
 472     public static String replace(String str, String pattern, String replace) {
 473         int s = 0;
 474         int e = 0;
 475         StringBuffer result = new StringBuffer();
 476         while ( ( e = str.indexOf(pattern, s) ) >= 0) {
 477             result.append(str.substring(s, e));
 478             result.append(replace);
 479             s = e + pattern.length();
 480         }
 481         result.append(str.substring(s));
 482 
 483         return result.toString();
 484     }
 485 
 486     /**
 487      * 分隔字符串到一个集合
 488      * 
 489      * @param str
 490      * @param start
 491      * @param end
 492      * @return
 493      */
 494     public static List<String> dividToList(String str, String start, String end) {
 495         if (str == null || str.length() == 0) {
 496             return null;
 497         }
 498         int s = 0;
 499         int e = 0;
 500         List<String> result = new ArrayList<String>();
 501         if (isInclude(str, start) && isInclude(str, end)) {
 502             while ( ( e = str.indexOf(start, s) ) >= 0) {
 503                 result.add(str.substring(s, e));
 504                 s = str.indexOf(end, e) + end.length();
 505                 result.add(str.substring(e, s));
 506             }
 507             if (s < str.length()) {
 508                 result.add(str.substring(s));
 509             }
 510             if (s == 0) {
 511                 result.add(str);
 512             }
 513         } else {
 514             result.add(str);
 515         }
 516         return result;
 517     }
 518 
 519     /**
 520      * 首字母大写
 521      * 
 522      * @param string
 523      * @return
 524      */
 525     public static String upperFrist(String string) {
 526         if (string == null) {
 527             return null;
 528         }
 529         String upper = string.toUpperCase();
 530         return upper.substring(0, 1) + string.substring(1);
 531     }
 532 
 533     /**
 534      * 首字母小写
 535      * 
 536      * @param string
 537      * @return
 538      */
 539     public static String lowerFrist(String string) {
 540         if (string == null) {
 541             return null;
 542         }
 543         String lower = string.toLowerCase();
 544         return lower.substring(0, 1) + string.substring(1);
 545     }
 546 
 547     public static String URLEncode(String string, String encode) {
 548         try {
 549             return URLEncoder.encode(string, encode);
 550         } catch (UnsupportedEncodingException e) {
 551             e.printStackTrace();
 552             return null;
 553         }
 554     }
 555 
 556     /**
 557      * 将一个日期类型的对象，转换为指定格式的字符串
 558      * 
 559      * @param date
 560      *            待转换的日期
 561      * @param format
 562      *            转换为字符串的相应格式 例如：DateToStr(new Date() ,"yyyy.MM.dd G 'at' hh:mm:ss a zzz");
 563      * @return 一个字符串
 564      *         <p>
 565      * 
 566      *         <table border="0" cellspacing="3" cellpadding="0">
 567      *         <tr bgcolor="#ccccff">
 568      *         <th align="left">Letter
 569      *         <th align="left">Date or Time Component
 570      *         <th align="left">Presentation
 571      *         <th align="left">Examples
 572      *         <tr>
 573      *         <td><code>G</code>
 574      *         <td>Era designator
 575      *         <td><a href="#text">Text</a>
 576      *         <td><code>AD</code>
 577      *         <tr bgcolor="#eeeeff">
 578      *         <td>Year
 579      *         <td><a href="#year">Year</a>
 580      *         <td><code>1996</code>; <code>96</code>
 581      *         <tr>
 582      *         <td><code>M</code>
 583      *         <td>Month in year
 584      *         <td><a href="#month">Month</a>
 585      *         <td><code>July</code>; <code>Jul</code>; <code>07</code>
 586      *         <tr bgcolor="#eeeeff">
 587      *         <td><code>w</code>
 588      *         <td>Week in year
 589      *         <td><a href="#number">Number</a>
 590      *         <td><code>27</code>
 591      *         <tr>
 592      *         <td><code>W</code>
 593      *         <td>Week in month
 594      *         <td><a href="#number">Number</a>
 595      *         <td><code>2</code>
 596      *         <tr bgcolor="#eeeeff">
 597      *         <td><code>D</code>
 598      *         <td>Day in year
 599      *         <td><a href="#number">Number</a>
 600      *         <td><code>189</code>
 601      *         <tr>
 602      *         <td><code>d</code>
 603      *         <td>Day in month
 604      *         <td><a href="#number">Number</a>
 605      *         <td><code>10</code>
 606      *         <tr bgcolor="#eeeeff">
 607      *         <td><code>F</code>
 608      *         <td>Day of week in month
 609      *         <td><a href="#number">Number</a>
 610      *         <td><code>2</code>
 611      *         <tr>
 612      *         <td><code>E</code>
 613      *         <td>Day in week
 614      *         <td><a href="#text">Text</a>
 615      *         <td><code>Tuesday</code>; <code>Tue</code>
 616      *         <tr bgcolor="#eeeeff">
 617      *         <td><code>a</code>
 618      *         <td>Am/pm marker
 619      *         <td><a href="#text">Text</a>
 620      *         <td><code>PM</code>
 621      *         <tr>
 622      *         <td><code>H</code>
 623      *         <td>Hour in day (0-23)
 624      *         <td><a href="#number">Number</a>
 625      *         <td><code>0</code>
 626      *         <tr bgcolor="#eeeeff">
 627      *         <td><code>k</code>
 628      *         <td>Hour in day (1-24)
 629      *         <td><a href="#number">Number</a>
 630      *         <td><code>24</code>
 631      *         <tr>
 632      *         <td><code>K</code>
 633      *         <td>Hour in am/pm (0-11)
 634      *         <td><a href="#number">Number</a>
 635      *         <td><code>0</code>
 636      *         <tr bgcolor="#eeeeff">
 637      *         <td><code>h</code>
 638      *         <td>Hour in am/pm (1-12)
 639      *         <td><a href="#number">Number</a>
 640      *         <td><code>12</code>
 641      *         <tr>
 642      *         <td><code>m</code>
 643      *         <td>Minute in hour
 644      *         <td><a href="#number">Number</a>
 645      *         <td><code>30</code>
 646      *         <tr bgcolor="#eeeeff">
 647      *         <td><code>s</code>
 648      *         <td>Second in minute
 649      *         <td><a href="#number">Number</a>
 650      *         <td><code>55</code>
 651      *         <tr>
 652      *         <td><code>S</code>
 653      *         <td>Millisecond
 654      *         <td><a href="#number">Number</a>
 655      *         <td><code>978</code>
 656      *         <tr bgcolor="#eeeeff">
 657      *         <td><code>z</code>
 658      *         <td>Time zone
 659      *         <td><a href="#timezone">General time zone</a>
 660      *         <td><code>Pacific Standard Time</code>; <code>PST</code>; <code>GMT-08:00</code>
 661      *         <tr>
 662      *         <td><code>Z</code>
 663      *         <td>Time zone
 664      *         <td><a href="#rfc822timezone">RFC 822 time zone</a>
 665      *         <td><code>-0800</code>
 666      *         </table>
 667      */
 668     public static String DateToStr(Date date, String format) {
 669         SimpleDateFormat formatter = new SimpleDateFormat(format);
 670         return formatter.format(date);
 671     }
 672 
 673     /**
 674      * 对给定的字符串做html转义
 675      * 
 676      * @param string
 677      * @return
 678      */
 679     public static String escapeHtml(String string) {
 680         if (string == null || string.length() == 0) {
 681             return "";
 682         }
 683 
 684         char b;
 685         char c = 0;
 686         int i;
 687         int len = string.length();
 688         StringBuffer sb = new StringBuffer(len + 4);
 689         String t;
 690 
 691         for (i = 0; i < len; i += 1) {
 692             b = c;
 693             c = string.charAt(i);
 694             switch (c) {
 695             case '\\':
 696             case '"':
 697                 sb.append('\\');
 698                 sb.append(c);
 699                 break;
 700             case '/':
 701                 if (b == '<') {
 702                     sb.append('\\');
 703                 }
 704                 sb.append(c);
 705                 break;
 706             case '\b':
 707                 sb.append("\\b");
 708                 break;
 709             case '\t':
 710                 sb.append("\\t");
 711                 break;
 712             case '\n':
 713                 sb.append("\\n");
 714                 break;
 715             case '\f':
 716                 sb.append("\\f");
 717                 break;
 718             case '\r':
 719                 sb.append("\\r");
 720                 break;
 721             default:
 722                 if (c < ' ' || ( c >= '\u0080' && c < '\u00a0' ) || ( c >= '\u2000' && c < '\u2100' )) {
 723                     t = "000" + Integer.toHexString(c);
 724                     sb.append("\\u" + t.substring(t.length() - 4));
 725                 } else {
 726                     sb.append(c);
 727                 }
 728             }
 729         }
 730 
 731         return sb.toString();
 732     }
 733 
 734     /**
 735      * 生成一个指定长度的随机字符串
 736      * 
 737      * @param length
 738      *            返回的字符串长度
 739      * @return 返回一个随机
 740      */
 741     public static String randomString(int length) {
 742         if (length < 1) {
 743             return null;
 744         }
 745         Random randGen = new Random();
 746         char[] numbersAndLetters = ( "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ).toCharArray();
 747         char[] randBuffer = new char[length];
 748         for (int i = 0; i < randBuffer.length; i++) {
 749             randBuffer[i] = numbersAndLetters[randGen.nextInt(51)];
 750         }
 751         return new String(randBuffer);
 752     }
 753 
 754     public final static String trim(String target) {
 755         if (target == null)
 756             return null;
 757 
 758         target = target.trim();
 759 
 760         return "".equals(target) ? null : target;
 761     }
 762 
 763     /**
 764      * string to int
 765      * 
 766      * @param numStr
 767      * @return
 768      */
 769     public static int strToInt(String numStr) {
 770         try {
 771             if (isNullOrBlank(numStr)) {
 772                 return 0;
 773             }
 774             return Integer.valueOf(numStr);
 775         } catch (Exception e) {
 776             logger.error("str2int failed:", e);
 777         }
 778         return 0;
 779     }
 780 
 781     /**
 782      * 判断null 或 空字符串
 783      * 
 784      * @param str
 785      * @return
 786      */
 787     public static boolean isNullOrBlank(String str) {
 788         if (str == null) {
 789             return true;
 790         }
 791         str = str.trim();
 792         if (!str.equals("")) {
 793             return false;
 794         } else {
 795             return true;
 796         }
 797     }
 798 
 799     /**
 800      * 判断 空字符串
 801      * 
 802      * @param value
 803      * @return
 804      */
 805     public static boolean isBlank(String value) {
 806         boolean ret = false;
 807         if ( ( value != null ) && ( value.equals("") )) {
 808             ret = true;
 809         }
 810         return ret;
 811     }
 812 
 813     /**
 814      * 判断null
 815      */
 816     public static boolean isNull(Object value) {
 817         return ( value == null );
 818     }
 819 
 820     /**
 821      * Title : 获取随机数
 822      * 
 823      * @author : 聂水根
 824      * @param digits
 825      *            随机数取值范围 默认为0123456789
 826      * @param length
 827      *            随机数位数 默认为1位
 828      * @return
 829      */
 830     public static String getRandom(String digits, int length) {
 831         if (null == digits) {
 832             digits = "0123456789";
 833         }
 834         if (length <= 0) {
 835             length = 1;
 836         }
 837         char[] code = new char[length];
 838         String temp = "";
 839         for (int i = 0; i < length; i++) {
 840             code[i] = digits.charAt((int) ( Math.random() * digits.length() ));
 841             temp += "0";
 842         }
 843         String verifyCode = new String(code);
 844 
 845         if (verifyCode.equals(temp)) {
 846             verifyCode = getRandom(digits, length);
 847         }
 848         return verifyCode;
 849     }
 850 
 851     /**
 852      * Title : 获取范围在min到max间的随机数
 853      * 
 854      * @author : 聂水根
 855      * @param min
 856      * @param max
 857      * @return
 858      */
 859     public static int getRandom(int min, int max) {
 860         return (int) ( Math.random() * ( max - min ) + min );
 861     }
 862 
 863     /**
 864      * Title : 获取范围在min到max间的num个随机数
 865      * 
 866      * @author : 聂水根
 867      * @param min
 868      * @param max
 869      * @return
 870      */
 871     public static Integer[] getRandomNum(int min, int max, int num) {
 872         Integer[] result = new Integer[num];
 873         for (int i = 0; i < num; i++) {
 874             result[i] = getRandom(min, max);
 875         }
 876 
 877         for (int i = 0; i < num; i++) {
 878             for (int k = i + 1; k < num; k++) {
 879                 if (result[i] == result[k]) {
 880                     getRandomNum(min, max, num);
 881                 }
 882             }
 883         }
 884         return result;
 885     }
 886 
 887     public static String ifBlank(String... ss) {
 888         String ret = "";
 889         for (String s : ss) {
 890             if (org.apache.commons.lang3.StringUtils.isNotBlank(s)) {
 891                 ret = s;
 892                 break;
 893             }
 894         }
 895         return ret;
 896     }
 897 
 898     public static String getUrlParamters(String url, String prefix) {
 899         String _return = null;
 900         if (url.indexOf("?") >= 0) {
 901             url = url.substring(url.indexOf("?") + 1);
 902             String[] paramters = url.split("&");
 903             if (paramters != null) {
 904                 for (String s : paramters) {
 905                     if (s.startsWith(prefix)) {
 906                         String[] _temp = s.split("=");
 907                         if (_temp.length > 1) {
 908                             _return = _temp[1];
 909                         }
 910                     }
 911                 }
 912             }
 913         }
 914         return _return;
 915 
 916     }
 917 
 918     /**
 919      * 字符串转换成Long型数字
 920      * 
 921      * @param src
 922      * @return
 923      * 
 924      */
 925     public static long toLong(String src) {
 926         long dest = 0;
 927         if (src == null || src.trim().equals("")) {
 928             return 0;
 929         }
 930 
 931         try {
 932             dest = Long.parseLong(src.trim());
 933         } catch (Exception e) {
 934         }
 935         return dest;
 936     }
 937 
 938     /**
 939      * 创建*Info类型的字符串，一般用于信息查询类接口的返回。
 940      * 
 941      * 例如，调用buildInfoString("#",aaa,bbb,null,ddd); 得到字符串：aaa#bbb##ddd
 942      * 
 943      * @param delimiter
 944      * @param items
 945      * @return
 946      */
 947     public static String buildInfoString(String delimiter, Object... items) {
 948         StringBuffer buff = new StringBuffer();
 949         boolean firstItem = true;
 950         for (Object item : items) {
 951             if (firstItem) {
 952                 firstItem = false;
 953             } else {
 954                 buff.append(delimiter);
 955             }
 956 
 957             if (item == null) {
 958                 buff.append("");
 959             } else {
 960                 buff.append(item.toString());
 961             }
 962 
 963         }
 964 
 965         return buff.toString();
 966     }
 967 
 968     public static long yuan2Cent(String src) {
 969         if (src == null || src.trim().equals("")) {
 970             return 0;
 971         }
 972 
 973         long ret = 0;
 974         try {
 975             ret = (long) ( Math.round(Double.parseDouble(src) * 100) );
 976         } catch (Exception e) {
 977         }
 978 
 979         return ret;
 980     }
 981 
 982     /**
 983      * 把分转换为元
 984      * 
 985      * @param src
 986      * @param floor
 987      *            是否取整
 988      * @return
 989      */
 990     public static String cent2Yuan(String src, boolean floor) {
 991 
 992         long temp = 0;
 993         try {
 994             String tem = src.trim();
 995             temp = Long.parseLong(tem);
 996         } catch (Exception e) {
 997         }
 998         return cent2Yuan(temp, floor);
 999     }
1000 
1001     public static String cent2Yuan(long src, boolean floor) {
1002         DecimalFormat SDF_YUAN = new DecimalFormat("0.00");
1003         String yuan = "0.00";
1004         try {
1005             yuan = SDF_YUAN.format(src / 100.00);
1006         } catch (Exception e) {
1007         }
1008 
1009         if (floor) {
1010             int idxDot = yuan.indexOf(".");
1011             if (idxDot >= 0) {
1012                 yuan = yuan.substring(0, idxDot);
1013             }
1014         }
1015         return yuan;
1016 
1017     }
1018 
1019     public static String cent2Yuan(Double src, boolean floor) {
1020         DecimalFormat SDF_YUAN = new DecimalFormat("0.00");
1021         String yuan = "0.00";
1022         try {
1023             yuan = SDF_YUAN.format(src / 100.00);
1024         } catch (Exception e) {
1025         }
1026 
1027         if (floor) {
1028             int idxDot = yuan.indexOf(".");
1029             if (idxDot >= 0) {
1030                 yuan = yuan.substring(0, idxDot);
1031             }
1032         }
1033         return yuan;
1034 
1035     }
1036 
1037     /**
1038      * 
1039      * 将一个字符串按分隔符分成多个子串。 此方法用于代替Jdk的String.split()方法，不同的地方：<br>
1040      * (1)在此方法中，空字符串不管在哪个位置都视为一个有效字串。 <br>
1041      * (2)在此方法中，分隔符参数不是一个正则表达式。<br>
1042      * 
1043      * @param src
1044      *            源字符串
1045      * @param delimiter
1046      *            分隔符
1047      * @return 字符串数组。
1048      */
1049     public static String[] split(String src, String delimiter) {
1050         if (src == null || delimiter == null || src.trim().equals("") || delimiter.equals("")) {
1051             return new String[] { src };
1052         }
1053 
1054         ArrayList<String> list = new ArrayList<String>();
1055 
1056         int lengthOfDelimiter = delimiter.length();
1057         int pos = 0;
1058         while (true) {
1059             if (pos < src.length()) {
1060 
1061                 int indexOfDelimiter = src.indexOf(delimiter, pos);
1062                 if (indexOfDelimiter < 0) {
1063                     list.add(src.substring(pos));
1064                     break;
1065                 } else {
1066                     list.add(src.substring(pos, indexOfDelimiter));
1067                     pos = indexOfDelimiter + lengthOfDelimiter;
1068                 }
1069             } else if (pos == src.length()) {
1070                 list.add("");
1071                 break;
1072             } else {
1073                 break;
1074             }
1075         }
1076 
1077         String[] result = new String[list.size()];
1078         list.toArray(result);
1079         return result;
1080 
1081     }
1082 
1083     /**
1084      * 若原对象为Null则返回空字符串,否则先转为String类型，再剪去字符串两端的空格及控制字符
1085      * 
1086      * @param src
1087      * @return
1088      */
1089     public static String trim(Object src) {
1090         if (src == null) {
1091             return "";
1092         }
1093 
1094         String str = src.toString();
1095         return str.trim();
1096     }
1097 
1098     /**
1099      * 将一个形如key1=value1&key2=value2...的字符串转换成Map映射。
1100      * 
1101      * @param src
1102      * @return
1103      * 
1104      */
1105     public static Map<String, String> string2Map(String src) {
1106         return string2Map(src, String.class, String.class, "&", "=");
1107     }
1108 
1109     /**
1110      * 将一个形如key1=value1&key2=value2...的字符串转换成Map映射。 注意：key和value只支持类型为String,Long,Integer,Float,Double！
1111      * 
1112      * @param <K>
1113      * @param <V>
1114      * @param src
1115      *            源字符串
1116      * @param keyClass
1117      *            生成的Map的Key的类型，默认String
1118      * @param valueClass
1119      *            生成的Map的Value的类型，默认String
1120      * @param fieldDelimiter
1121      *            字段与字段之间的分隔符，默认&
1122      * @param keyValueDelimiter
1123      *            key和value之间的分隔符，默认=
1124      * @return
1125      * 
1126      */
1127     public static <K extends Object, V extends Object> Map<K, V> string2Map(String src, Class<K> keyClass, Class<V> valueClass,
1128             String fieldDelimiter, String keyValueDelimiter) {
1129         Map<K, V> result = new HashMap<K, V>();
1130 
1131         if (src == null || src.trim().equals("")) {
1132             return result;
1133         }
1134 
1135         String[] fields = StringHelper.split(src, fieldDelimiter);
1136         for (int i = 0; i < fields.length; i++) {
1137             String[] keyValue = StringHelper.split(fields[i], keyValueDelimiter);
1138             String key = keyValue[0];
1139             String value = keyValue[1];
1140 
1141             K objKey = null;
1142             V objValue = null;
1143 
1144             if (keyClass == String.class) {
1145                 objKey = (K) key;
1146             } else if (keyClass == Integer.class) {
1147                 objKey = (K) Integer.valueOf(key);
1148             } else if (keyClass == Long.class) {
1149                 objKey = (K) Long.valueOf(key);
1150             } else if (keyClass == Float.class) {
1151                 objKey = (K) Float.valueOf(key);
1152             } else if (keyClass == Double.class) {
1153                 objKey = (K) Double.valueOf(key);
1154             } else {
1155                 return null;
1156             }
1157 
1158             if (valueClass == String.class) {
1159                 objValue = (V) value;
1160             } else if (valueClass == Integer.class) {
1161                 objValue = (V) Integer.valueOf(value);
1162             } else if (valueClass == Long.class) {
1163                 objValue = (V) Long.valueOf(value);
1164             } else if (valueClass == Float.class) {
1165                 objValue = (V) Float.valueOf(value);
1166             } else if (valueClass == Double.class) {
1167                 objValue = (V) Double.valueOf(value);
1168             } else {
1169                 return null;
1170             }
1171 
1172             result.put(objKey, objValue);
1173 
1174         }
1175 
1176         return result;
1177     }
1178 
1179     /**
1180      * Map转换成字符串，主要用于打印调试信息
1181      * 
1182      * @param map
1183      * @return
1184      */
1185     public static String map2String(Map map) {
1186         return map2String(map, "", "", "", true, "=");
1187     }
1188 
1189     /**
1190      * Map转换成字符串，主要用于打印调试信息
1191      * 
1192      * @param map
1193      * @param head
1194      *            输出的头
1195      * @param entryPrefix
1196      *            每一项输出的前缀
1197      * @param foot
1198      *            输出的脚
1199      * @param isOneItemPl
1200      *            是否每行一项
1201      * @param kvSep
1202      *            Key和Value的分隔符
1203      * @return
1204      */
1205     public static String map2String(Map map, String head, String entryPrefix, String foot, boolean isOneItemPl, String kvSep) {
1206 
1207         if (map == null) {
1208             return null;
1209         }
1210         String lineSeparator = (String) System.getProperty("line.separator");
1211         StringBuffer buff = new StringBuffer();
1212         if (head != null && !head.equals("")) {
1213             buff.append(head);
1214 
1215             if (isOneItemPl) {
1216                 buff.append(lineSeparator);
1217             }
1218         }
1219         if (entryPrefix == null) {
1220             entryPrefix = "";
1221         }
1222         for (Iterator iterator = map.entrySet().iterator(); iterator.hasNext();) {
1223             Entry entry = (Entry) iterator.next();
1224             buff.append(entryPrefix).append(entry.getKey()).append(kvSep).append(StringHelper.ArrayToStr((Object[]) entry.getValue()));
1225 
1226             if (isOneItemPl) {
1227                 buff.append(lineSeparator);
1228             }
1229         }
1230 
1231         if (foot != null && !foot.equals("")) {
1232             buff.append(foot);
1233             if (isOneItemPl) {
1234                 buff.append(lineSeparator);
1235             }
1236         }
1237         return buff.toString();
1238     }
1239 
1240     /**
1241      * 填充数字0
1242      * 
1243      * @param src
1244      * @param targetLength
1245      * @return
1246      */
1247     public static String fill(long src, int targetLength) {
1248         return fill(String.valueOf(src), "0", targetLength, true);
1249     }
1250 
1251     /**
1252      * 填充字符串。如果原字符串比目标长度长，则截去多出的部分。如果onTheLeft等于true 截去左边部分，否则截去右边部分。 注意填充物一般为单个字符，如果是多个字符，可能导致最后的结果不可用。
1253      * 
1254      * @param src
1255      *            原字符串
1256      * @param padding
1257      *            填充物，一般是0、空格等
1258      * @param targetLength
1259      *            目标长度
1260      * @param onTheLeft
1261      *            是否左填充。
1262      * @return
1263      */
1264     public static String fill(String src, String padding, int targetLength, boolean onTheLeft) {
1265 
1266         if (src == null) {
1267             src = "";
1268         }
1269 
1270         while (src.length() < targetLength) {
1271             if (onTheLeft) {
1272                 src = padding + src;
1273             } else {
1274                 src = src + padding;
1275             }
1276         }
1277 
1278         if (src.length() > targetLength) {
1279             if (onTheLeft) {
1280                 src = src.substring(src.length() - targetLength);
1281             } else {
1282                 src = src.substring(0, targetLength);
1283             }
1284         }
1285 
1286         return src;
1287     }
1288 
1289     public static String changeListToString(List<String> source, String delimiter) {
1290         StringBuilder builder = new StringBuilder();
1291         if (source != null && source.size() > 0) {
1292             int len = source.size();
1293             for (int i = 0; i < len; i++) {
1294                 builder.append(source.get(i));
1295                 if (i < len - 1) {
1296                     builder.append(delimiter);
1297                 }
1298 
1299             }
1300         }
1301         return builder.toString();
1302     }
1303 
1304     public static String changeListToStringWithTag(List<String> source, String delimiter, String tag) {
1305         StringBuilder builder = new StringBuilder();
1306         if (source != null && source.size() > 0) {
1307             int len = source.size();
1308             for (int i = 0; i < len; i++) {
1309                 builder.append(tag + source.get(i) + tag);
1310                 if (i < len - 1) {
1311                     builder.append(delimiter);
1312                 }
1313 
1314             }
1315         }
1316         return builder.toString();
1317     }
1318 
1319     /**
1320      * 是否存在null、或者空字符串。任意一个参数满足条件，返回true；否则返回false。<br>
1321      * 先将参数对象转成字符串，修剪后进行判断。仅包含空格或ASCII控制字符也视为条件满足。<br>
1322      * 
1323      * Noe:Null Or Empty<br>
1324      * 
1325      * @param strings
1326      * @return
1327      */
1328     public static boolean existNoe(Object... someObj) {
1329         if (someObj == null || someObj.length == 0) {
1330             throw new RuntimeException("参数不能为空,必须有至少一个对象");
1331         }
1332 
1333         for (int i = 0; i < someObj.length; i++) {
1334             Object obj = someObj[i];
1335             if (obj == null || obj.toString().trim().equals("")) {
1336                 return true;
1337             }
1338         }
1339 
1340         return false;
1341 
1342     }
1343 
1344     /**
1345      * 若原字符串为Null则返回空字符串。
1346      * 
1347      * @param src
1348      * @return
1349      */
1350     public static String null2Empty(String src) {
1351         if (src == null) {
1352             return "";
1353         }
1354         return src;
1355     }
1356 
1357     /**
1358      * 若原字符串为Null则返回空字符串。
1359      * 
1360      * @param src
1361      * @return
1362      */
1363     public static boolean isEmpty(String src) {
1364         String value = null2Empty(src);
1365         if ("".equals(value)) {
1366             return true;
1367         } else {
1368             return false;
1369         }
1370     }
1371 
1372     /**
1373      * 是否全部非空
1374      * 
1375      * @param src
1376      * @return
1377      */
1378     public static boolean isAllNotEmpty(String... src) {
1379         for (int i = 0; i < src.length; i++) {
1380             String value = src[i];
1381             if (value == null || value.equals("")) {
1382                 return false;
1383             }
1384         }
1385 
1386         return true;
1387     }
1388 
1389     /**
1390      * 是否全部为空
1391      * 
1392      * @param src
1393      * @return
1394      */
1395     public static boolean isAllEmpty(String... src) {
1396         for (int i = 0; i < src.length; i++) {
1397             String value = src[i];
1398             if (value != null && !value.equals("")) {
1399                 return false;
1400             }
1401         }
1402 
1403         return true;
1404     }
1405 
1406     /**
1407      * 是否全为字母或数字
1408      * 
1409      * @param src
1410      * @return
1411      */
1412     public static boolean isLetterOrNumber(String src) {
1413         if (src == null) {
1414             return false;
1415         }
1416 
1417         try {
1418             byte[] bytesOfSrc = src.getBytes("utf-8");
1419 
1420             for (int i = 0; i < bytesOfSrc.length; i++) {
1421                 byte one = bytesOfSrc[i];
1422                 if (one < '0' || ( one > '9' && one < 'A' ) || ( one > 'Z' && one < 'a' ) || one > 'z') {
1423                     return false;
1424                 }
1425             }
1426 
1427         } catch (Exception e) {
1428             return false;
1429         }
1430 
1431         return true;
1432     }
1433 
1434     public static String privacyInfo(String currString) {
1435 
1436         String targetString = "";
1437         if (!StringHelper.isBlank(currString)) {
1438             if (currString.length() <= 3) {
1439                 targetString = currString.replace(org.apache.commons.lang3.StringUtils.substring(currString, 0, 1), "*");
1440             } else if (currString.length() > 3) {
1441                 targetString = currString.replace(org.apache.commons.lang3.StringUtils.substring(currString, 0, 2), "*");
1442             }
1443         }
1444 
1445         return targetString;
1446     }
1447 
1448     /**
1449      * 比较两个字符串是否相等
1450      * 
1451      * @param one
1452      * @param another
1453      * @return
1454      */
1455     public static boolean equals(String one, String another) {
1456         if (one == null) {
1457             if (another == null) {
1458                 return true;
1459             } else {
1460                 return false;
1461             }
1462         } else {
1463             if (another == null) {
1464                 return false;
1465             } else {
1466                 return one.equals(another);
1467             }
1468         }
1469     }
1470     
1471     /**
1472      * 获取字符串
1473      * @param value 字符串
1474      * @param maxLen 最大字符串长度
1475      * @return
1476      */
1477     public static String getSubStr(String value,int maxLen){
1478         if (value.length() > maxLen) {
1479             value = value.substring(0, maxLen);
1480         }
1481         return value;
1482     }
1483     
1484 }
posted @ 2018-06-14 20:28 安以北往南阅读(1472) 评论(0) 编辑收藏举报
会员力量，点亮园子希望
刷新页面返回顶部
OneIsAll

You are what you want to be.

StringHelper

公告
