`

此类中封装一些常用的字符串操作(和业务无关)。

 
阅读更多
  1. 来自:http://xuliduo.javaeye.com/blog/196937
  2. packagecom.wootion.idp.util;
  3. importjava.io.IOException;
  4. importjava.io.OutputStream;
  5. importjava.security.Security;
  6. importjava.text.SimpleDateFormat;
  7. importjava.text.StringCharacterIterator;
  8. importjava.util.Calendar;
  9. importjava.util.Date;
  10. importjava.util.HashMap;
  11. importjava.util.StringTokenizer;
  12. importjavax.crypto.Cipher;
  13. importjavax.crypto.KeyGenerator;
  14. importjavax.crypto.SecretKey;
  15. /**
  16. *<p>文件名称:StringUtil.java</p>
  17. *<p>文件描述:此类中封装一些常用的字符串操作(和业务无关)。/p>
  18. *<p>版权所有:版权所有(C)2001-2006</p>
  19. *<p>公司:</p>
  20. *<p>内容摘要:</p>
  21. *<p>其他说明:</p>
  22. *<p>完成日期:Apr1,2007</p>
  23. *<p>修改记录0:无</p>
  24. *@version1.0
  25. *@author许力多
  26. */
  27. publicclassStringUtil
  28. {
  29. //定义加密算法,可用DES,DESede,Blowfish
  30. publicstaticStringDES="DES";
  31. publicstaticStringDESEDE="DESede";
  32. publicstaticStringBLOWFISH="Blowfish";
  33. //dateSize中的日期参数
  34. /*
  35. *近一日
  36. */
  37. publicstaticcharDATE_SIZE_DAY='d';
  38. /*
  39. *近一周
  40. */
  41. publicstaticcharDATE_SIZE_WEEK='w';
  42. /*
  43. *近一月
  44. */
  45. publicstaticcharDATE_SIZE_MONTH='m';
  46. /*
  47. *近一年
  48. */
  49. publicstaticcharDATE_SIZE_YEAR='y';
  50. /*
  51. *明天
  52. */
  53. publicstaticcharDATE_SIZE_TOMORROW='a';
  54. /**
  55. *私有构造方法,防止类的实例化,因为工具类不需要实例化。
  56. */
  57. privateStringUtil()
  58. {
  59. }
  60. publicstaticStringrandomName()throwsException
  61. {
  62. StringstrName=null;
  63. //产生10位随机传
  64. RandomStrgrst=newRandomStrg();
  65. rst.setCharset("a-zA-Z0-9");
  66. rst.setLength("17");
  67. rst.generateRandomObject();
  68. strName=rst.getRandom()+System.currentTimeMillis();
  69. returnstrName;
  70. }
  71. /**
  72. *取得时间
  73. *@paramstr日期格式,可以为空(非null)
  74. *@paramdates时间/如果为空那么取得当前时间
  75. *@return
  76. */
  77. publicstaticStringnow(Stringstr,java.sql.Datedates)
  78. {
  79. if("".equals(str))
  80. str="yyyy-MM-dd";
  81. java.util.Datedate=dates;
  82. returnnow(str,date);
  83. }
  84. publicstaticStringrandomNum()
  85. {
  86. StringstrName=null;
  87. //产生10位随机传
  88. RandomStrgrst=newRandomStrg();
  89. rst.setCharset("0-9");
  90. rst.setLength("6");
  91. try
  92. {
  93. rst.generateRandomObject();
  94. }
  95. catch(Exceptione)
  96. {
  97. e.printStackTrace();
  98. }
  99. strName=StringUtil.now("yyyyMMdd",null)+rst.getRandom();
  100. returnstrName;
  101. }
  102. /**
  103. *取得时间
  104. *@paramstr日期格式,可以为空(非null)
  105. *@paramdates时间/如果为空那么取得当前时间
  106. *@return
  107. */
  108. publicstaticStringnow(Stringstr,java.util.Datedates)
  109. {
  110. if("".equals(str))
  111. str="yyyy-MM-dd";
  112. java.text.SimpleDateFormatdate=newjava.text.SimpleDateFormat(str);
  113. StringcurrentDate=date.format(dates!=null?dates:thisTime());
  114. returncurrentDate;
  115. }
  116. /**
  117. *取得当前时间
  118. *@returnuitl.Data对象
  119. */
  120. publicstaticjava.util.DatethisTime()
  121. {
  122. returnnewDate(System.currentTimeMillis());
  123. }
  124. /**
  125. *此方法将给出的字符串source使用delim划分为单词数组。
  126. *@paramsource需要进行划分的原字符串
  127. *@paramdelim单词的分隔字符串
  128. *@return划分以后的数组,如果source为null的时候返回以source为唯一元素的数组,
  129. *如果delim为null则使用逗号作为分隔字符串。
  130. *@since0.1
  131. */
  132. publicstaticString[]split(Stringsource,Stringdelim)
  133. {
  134. String[]wordLists;
  135. if(source==null)
  136. {
  137. wordLists=newString[1];
  138. wordLists[0]=source;
  139. returnwordLists;
  140. }
  141. if(delim==null)
  142. {
  143. delim=",";
  144. }
  145. StringTokenizerst=newStringTokenizer(source,delim);
  146. inttotal=st.countTokens();
  147. wordLists=newString[total];
  148. for(inti=0;i<total;i++)
  149. {
  150. wordLists[i]=st.nextToken();
  151. }
  152. returnwordLists;
  153. }
  154. /**
  155. *此方法将给出的字符串source使用delim划分为单词数组。
  156. *@paramsource需要进行划分的原字符串
  157. *@paramdelim单词的分隔字符
  158. *@return划分以后的数组,如果source为null的时候返回以source为唯一元素的数组。
  159. *@since0.2
  160. */
  161. publicstaticString[]split(Stringsource,chardelim)
  162. {
  163. returnsplit(source,String.valueOf(delim));
  164. }
  165. /**
  166. *此方法将给出的字符串source使用逗号划分为单词数组。
  167. *@paramsource需要进行划分的原字符串
  168. *@return划分以后的数组,如果source为null的时候返回以source为唯一元素的数组。
  169. *@since0.1
  170. */
  171. publicstaticString[]split(Stringsource)
  172. {
  173. returnsplit(source,",");
  174. }
  175. /**
  176. *循环打印字符串数组。
  177. *字符串数组的各元素间以指定字符分隔,如果字符串中已经包含指定字符则在字符串的两端加上双引号。
  178. *@paramstrings字符串数组
  179. *@paramdelim分隔符
  180. *@paramout打印到的输出流
  181. *@since0.4
  182. */
  183. publicstaticvoidprintStrings(String[]strings,Stringdelim,
  184. OutputStreamout)
  185. {
  186. try
  187. {
  188. if(strings!=null)
  189. {
  190. intlength=strings.length-1;
  191. for(inti=0;i<length;i++)
  192. {
  193. if(strings[i]!=null)
  194. {
  195. if(strings[i].indexOf(delim)>-1)
  196. {
  197. out.write(("/""+strings[i]+"/""+delim)
  198. .getBytes());
  199. }
  200. else
  201. {
  202. out.write((strings[i]+delim).getBytes());
  203. }
  204. }
  205. else
  206. {
  207. out.write("null".getBytes());
  208. }
  209. }
  210. if(strings[length]!=null)
  211. {
  212. if(strings[length].indexOf(delim)>-1)
  213. {
  214. out.write(("/""+strings[length]+"/"").getBytes());
  215. }
  216. else
  217. {
  218. out.write(strings[length].getBytes());
  219. }
  220. }
  221. else
  222. {
  223. out.write("null".getBytes());
  224. }
  225. }
  226. else
  227. {
  228. out.write("null".getBytes());
  229. }
  230. out.write(java.lang.Character.LINE_SEPARATOR);
  231. }
  232. catch(IOExceptione)
  233. {
  234. }
  235. }
  236. /**
  237. *循环打印字符串数组到标准输出。
  238. *字符串数组的各元素间以指定字符分隔,如果字符串中已经包含指定字符则在字符串的两端加上双引号。
  239. *@paramstrings字符串数组
  240. *@paramdelim分隔符
  241. *@since0.4
  242. */
  243. publicstaticvoidprintStrings(String[]strings,Stringdelim)
  244. {
  245. printStrings(strings,delim,System.out);
  246. }
  247. /**
  248. *循环打印字符串数组。
  249. *字符串数组的各元素间以逗号分隔,如果字符串中已经包含逗号则在字符串的两端加上双引号。
  250. *@paramstrings字符串数组
  251. *@paramout打印到的输出流
  252. *@since0.2
  253. */
  254. publicstaticvoidprintStrings(String[]strings,OutputStreamout)
  255. {
  256. printStrings(strings,",",out);
  257. }
  258. /**
  259. *循环打印字符串数组到系统标准输出流System.out。
  260. *字符串数组的各元素间以逗号分隔,如果字符串中已经包含逗号则在字符串的两端加上双引号。
  261. *@paramstrings字符串数组
  262. *@since0.2
  263. */
  264. publicstaticvoidprintStrings(String[]strings)
  265. {
  266. printStrings(strings,",",System.out);
  267. }
  268. /**
  269. *将字符串中的变量使用values数组中的内容进行替换。
  270. *替换的过程是不进行嵌套的,即如果替换的内容中包含变量表达式时不会替换。
  271. *@paramprefix变量前缀字符串
  272. *@paramsource带参数的原字符串
  273. *@paramvalues替换用的字符串数组
  274. *@return替换后的字符串。
  275. *如果前缀为null则使用“%”作为前缀;
  276. *如果source或者values为null或者values的长度为0则返回source;
  277. *如果values的长度大于参数的个数,多余的值将被忽略;
  278. *如果values的长度小于参数的个数,则后面的所有参数都使用最后一个值进行替换。
  279. *@since0.2
  280. */
  281. publicstaticStringgetReplaceString(Stringprefix,Stringsource,
  282. String[]values)
  283. {
  284. Stringresult=source;
  285. if(source==null||values==null||values.length<1)
  286. {
  287. returnsource;
  288. }
  289. if(prefix==null)
  290. {
  291. prefix="%";
  292. }
  293. for(inti=0;i<values.length;i++)
  294. {
  295. Stringargument=prefix+Integer.toString(i+1);
  296. intindex=result.indexOf(argument);
  297. if(index!=-1)
  298. {
  299. Stringtemp=result.substring(0,index);
  300. if(i<values.length)
  301. {
  302. temp+=values[i];
  303. }
  304. else
  305. {
  306. temp+=values[values.length-1];
  307. }
  308. temp+=result.substring(index+2);
  309. result=temp;
  310. }
  311. }
  312. returnresult;
  313. }
  314. /**
  315. *将字符串中的变量(以“%”为前导后接数字)使用values数组中的内容进行替换。
  316. *替换的过程是不进行嵌套的,即如果替换的内容中包含变量表达式时不会替换。
  317. *@paramsource带参数的原字符串
  318. *@paramvalues替换用的字符串数组
  319. *@return替换后的字符串
  320. *@since0.1
  321. */
  322. publicstaticStringgetReplaceString(Stringsource,String[]values)
  323. {
  324. returngetReplaceString("%",source,values);
  325. }
  326. /**
  327. *字符串数组中是否包含指定的字符串。
  328. *@paramstrings字符串数组
  329. *@paramstring字符串
  330. *@paramcaseSensitive是否大小写敏感
  331. *@return包含时返回true,否则返回false
  332. *@since0.4
  333. */
  334. publicstaticbooleancontains(String[]strings,Stringstring,
  335. booleancaseSensitive)
  336. {
  337. for(inti=0;i<strings.length;i++)
  338. {
  339. if(caseSensitive==true)
  340. {
  341. if(strings[i].equals(string))
  342. {
  343. returntrue;
  344. }
  345. }
  346. else
  347. {
  348. if(strings[i].equalsIgnoreCase(string))
  349. {
  350. returntrue;
  351. }
  352. }
  353. }
  354. returnfalse;
  355. }
  356. /**
  357. *字符串数组中是否包含指定的字符串。大小写敏感。
  358. *@paramstrings字符串数组
  359. *@paramstring字符串
  360. *@return包含时返回true,否则返回false
  361. *@since0.4
  362. */
  363. publicstaticbooleancontains(String[]strings,Stringstring)
  364. {
  365. returncontains(strings,string,true);
  366. }
  367. /**
  368. *不区分大小写判定字符串数组中是否包含指定的字符串。
  369. *@paramstrings字符串数组
  370. *@paramstring字符串
  371. *@return包含时返回true,否则返回false
  372. *@since0.4
  373. */
  374. publicstaticbooleancontainsIgnoreCase(String[]strings,Stringstring)
  375. {
  376. returncontains(strings,string,false);
  377. }
  378. /**
  379. *将字符串数组使用指定的分隔符合并成一个字符串。
  380. *@paramarray字符串数组
  381. *@paramdelim分隔符,为null的时候使用""作为分隔符(即没有分隔符)
  382. *@return合并后的字符串
  383. *@since0.4
  384. */
  385. publicstaticStringcombineStringArray(String[]array,Stringdelim)
  386. {
  387. intlength=array.length-1;
  388. if(delim==null)
  389. {
  390. delim="";
  391. }
  392. StringBufferresult=newStringBuffer(length*8);
  393. for(inti=0;i<length;i++)
  394. {
  395. result.append(array[i]);
  396. result.append(delim);
  397. }
  398. result.append(array[length]);
  399. returnresult.toString();
  400. }
  401. /**
  402. *以指定的字符和长度生成一个该字符的指定长度的字符串。
  403. *@paramc指定的字符
  404. *@paramlength指定的长度
  405. *@return最终生成的字符串
  406. *@since0.6
  407. */
  408. publicstaticStringfillString(charc,intlength)
  409. {
  410. Stringret="";
  411. for(inti=0;i<length;i++)
  412. {
  413. ret+=c;
  414. }
  415. returnret;
  416. }
  417. /**
  418. *去除左边多余的空格。
  419. *@paramvalue待去左边空格的字符串
  420. *@return去掉左边空格后的字符串
  421. *@since0.6
  422. */
  423. publicstaticStringtrimLeft(Stringvalue)
  424. {
  425. Stringresult=value;
  426. if(result==null)
  427. returnresult;
  428. charch[]=result.toCharArray();
  429. intindex=-1;
  430. for(inti=0;i<ch.length;i++)
  431. {
  432. if(Character.isWhitespace(ch[i]))
  433. {
  434. index=i;
  435. }
  436. else
  437. {
  438. break;
  439. }
  440. }
  441. if(index!=-1)
  442. {
  443. result=result.substring(index+1);
  444. }
  445. returnresult;
  446. }
  447. /**
  448. *去除右边多余的空格。
  449. *@paramvalue待去右边空格的字符串
  450. *@return去掉右边空格后的字符串
  451. *@since0.6
  452. */
  453. publicstaticStringtrimRight(Stringvalue)
  454. {
  455. Stringresult=value;
  456. if(result==null)
  457. returnresult;
  458. charch[]=result.toCharArray();
  459. intendIndex=-1;
  460. for(inti=ch.length-1;i>-1;i--)
  461. {
  462. if(Character.isWhitespace(ch[i]))
  463. {
  464. endIndex=i;
  465. }
  466. else
  467. {
  468. break;
  469. }
  470. }
  471. if(endIndex!=-1)
  472. {
  473. result=result.substring(0,endIndex);
  474. }
  475. returnresult;
  476. }
  477. /**
  478. *根据转义列表对字符串进行转义。
  479. *@paramsource待转义的字符串
  480. *@paramescapeCharMap转义列表
  481. *@return转义后的字符串
  482. *@since0.6
  483. */
  484. publicstaticStringescapeCharacter(Stringsource,HashMapescapeCharMap)
  485. {
  486. if(source==null||source.length()==0)
  487. returnsource;
  488. if(escapeCharMap.size()==0)
  489. returnsource;
  490. StringBuffersb=newStringBuffer();
  491. StringCharacterIteratorsci=newStringCharacterIterator(source);
  492. for(charc=sci.first();c!=StringCharacterIterator.DONE;c=sci
  493. .next())
  494. {
  495. Stringcharacter=String.valueOf(c);
  496. if(escapeCharMap.containsKey(character))
  497. character=(String)escapeCharMap.get(character);
  498. sb.append(character);
  499. }
  500. returnsb.toString();
  501. }
  502. /**
  503. *得到字符串的字节长度。
  504. *@paramsource字符串
  505. *@return字符串的字节长度
  506. *@since0.6
  507. */
  508. publicstaticintgetByteLength(Stringsource)
  509. {
  510. intlen=0;
  511. for(inti=0;i<source.length();i++)
  512. {
  513. charc=source.charAt(i);
  514. inthighByte=c>>>8;
  515. len+=highByte==0?1:2;
  516. }
  517. returnlen;
  518. }
  519. /**
  520. *得到字符串中的子串的个数。
  521. *@paramsource字符串
  522. *@paramsub子串
  523. *@return字符串中的子串的个数
  524. *@since0.6
  525. */
  526. publicstaticintgetSubtringCount(Stringsource,Stringsub)
  527. {
  528. if(source==null||source.length()==0)
  529. {
  530. return0;
  531. }
  532. intcount=0;
  533. intindex=source.indexOf(sub);
  534. while(index>=0)
  535. {
  536. count++;
  537. index=source.indexOf(sub,index+1);
  538. }
  539. returncount;
  540. }
  541. /**
  542. *判断是否为null如果是返回"",不然返回原串
  543. *@paramsource
  544. *@return
  545. */
  546. publicstaticStringcheckNull(Stringsource)
  547. {
  548. return(source=(source==null?"":source));
  549. }
  550. /**
  551. *仿javascript的escape方法
  552. *@paramsrc
  553. *@return
  554. */
  555. publicstaticStringescape(Stringsrc)
  556. {
  557. inti;
  558. charj;
  559. StringBuffertmp=newStringBuffer();
  560. tmp.ensureCapacity(src.length()*6);
  561. for(i=0;i<src.length();i++)
  562. {
  563. j=src.charAt(i);
  564. if(Character.isDigit(j)||Character.isLowerCase(j)
  565. ||Character.isUpperCase(j))
  566. {
  567. tmp.append(j);
  568. }
  569. elseif(j<256)
  570. {
  571. tmp.append("%");
  572. if(j<16)
  573. {
  574. tmp.append("0");
  575. }
  576. tmp.append(Integer.toString(j,16));
  577. }
  578. else
  579. {
  580. tmp.append("%u");
  581. tmp.append(Integer.toString(j,16));
  582. }
  583. }
  584. returntmp.toString();
  585. }
  586. /**
  587. *仿javascript的unescape方法
  588. *@paramsrc
  589. *@return
  590. */
  591. publicstaticStringunescape(Stringsrc)
  592. {
  593. StringBuffertmp=newStringBuffer();
  594. tmp.ensureCapacity(src.length());
  595. intlastPos=0,pos=0;
  596. charch;
  597. while(lastPos<src.length())
  598. {
  599. pos=src.indexOf("%",lastPos);
  600. if(pos==lastPos)
  601. {
  602. if(src.charAt(pos+1)=='u')
  603. {
  604. ch=(char)Integer.parseInt(src
  605. .substring(pos+2,pos+6),16);
  606. tmp.append(ch);
  607. lastPos=pos+6;
  608. }
  609. else
  610. {
  611. ch=(char)Integer.parseInt(src
  612. .substring(pos+1,pos+3),16);
  613. tmp.append(ch);
  614. lastPos=pos+3;
  615. }
  616. }
  617. else
  618. {
  619. if(pos==-1)
  620. {
  621. tmp.append(src.substring(lastPos));
  622. lastPos=src.length();
  623. }
  624. else
  625. {
  626. tmp.append(src.substring(lastPos,pos));
  627. lastPos=pos;
  628. }
  629. }
  630. }
  631. returntmp.toString();
  632. }
  633. /**
  634. *在html里面显示加密过的中文
  635. *@paramstr
  636. *@return
  637. */
  638. publicstaticStringgetHtmlEscape(Stringstr)
  639. {
  640. return"<script>document.write(unescape('"+escape(str)
  641. +"'));</script>";
  642. }
  643. /**
  644. *获得2个关键字之间的内容
  645. *@params
  646. *@paramstr1
  647. *@paramstr2
  648. *@return
  649. */
  650. publicstaticStringgetBettown(Strings,Stringstr1,Stringstr2)
  651. {
  652. returns.substring(s.indexOf(str1)+1,s.indexOf(str2));
  653. }
  654. /**flq
  655. *字符串转换成时间
  656. *@paramstr时间字符串
  657. *@return
  658. */
  659. publicstaticDatestrToDate(Stringstr)
  660. {
  661. Datedate=null;
  662. try
  663. {
  664. SimpleDateFormatformatters=newSimpleDateFormat("yyyy-MM-dd");
  665. date=formatters.parse(str);
  666. }
  667. catch(Exceptione)
  668. {
  669. e.printStackTrace();
  670. }
  671. returndate;
  672. }
  673. /**
  674. *自定义格式串转换date
  675. *since西藏移动支撑系统
  676. *@paramstr
  677. *@paramdateformat
  678. *@return
  679. */
  680. publicstaticDatestrToDate(Stringstr,Stringdateformat)
  681. {
  682. Datedate=null;
  683. try
  684. {
  685. SimpleDateFormatformatters=newSimpleDateFormat(dateformat);
  686. date=formatters.parse(str);
  687. }
  688. catch(Exceptione)
  689. {
  690. e.printStackTrace();
  691. }
  692. returndate;
  693. }
  694. /**
  695. *flq转换成时间字符串
  696. *
  697. *@paramtime
  698. *时间
  699. *@return
  700. */
  701. publicstaticStringdateToStr(Datetime,Stringdateformat)
  702. {
  703. StringstrDate="";
  704. try
  705. {
  706. SimpleDateFormatformatters=newSimpleDateFormat(dateformat);
  707. strDate=formatters.format(time);
  708. }
  709. catch(Exceptione)
  710. {
  711. e.printStackTrace();
  712. }
  713. returnstrDate;
  714. }
  715. /**flq
  716. *取得日期范围
  717. *@paramtd:近一日w:近一周m:近一月y:近一年a:下一天
  718. *@returnDate
  719. */
  720. publicstaticDatedateSize(chart)
  721. {
  722. Datedate=thisTime();
  723. Calendarcalendar=Calendar.getInstance();
  724. calendar.setTime(date);
  725. switch(t)
  726. {
  727. case'd':
  728. //calendar.roll(calendar.DATE,false);
  729. break;
  730. case'w':
  731. calendar.roll(calendar.WEEK_OF_YEAR,false);
  732. break;
  733. case'm':
  734. calendar.roll(calendar.MONTH,false);
  735. break;
  736. case'y':
  737. calendar.roll(calendar.YEAR,false);
  738. break;
  739. case'a':
  740. calendar.roll(calendar.DATE,true);
  741. break;
  742. default:
  743. System.out.println("dateSize函数参数错误");
  744. }
  745. date=calendar.getTime();
  746. returndate;
  747. }
  748. /**
  749. *根据数组返回str1,str2,str3,...strn的串
  750. *@paramstr
  751. *@return
  752. *@throwsNullPointerException
  753. */
  754. publicstaticStringgetStringFromArray(Stringstr[])
  755. throwsNullPointerException
  756. {
  757. if(str==null)
  758. thrownewNullPointerException("请输入需要转换的数组");
  759. Stringstrs="";
  760. for(Strings:str)
  761. {
  762. strs+=s+",";
  763. }
  764. if(strs.length()>0)
  765. strs=strs.substring(0,strs.length()-1);
  766. returnstrs;
  767. }
  768. /**
  769. *根据入口的String,返回截取后的String,其中,2个数字算一个中文
  770. *@paramsource
  771. *@return截取后的新串10个中文,后面是...
  772. */
  773. publicstaticStringinterceptString(Stringsource)
  774. {
  775. returninterceptString(source,"...",10);
  776. }
  777. /**
  778. *根据入口的String,返回截取后的String,其中,2个数字算一个中文
  779. *@paramsource需要变更的String
  780. *@paramstr在String后面加的符号,默认为“...”
  781. *@paramnumber剩余的中文个数
  782. *@return截取后的新串
  783. */
  784. publicstaticStringinterceptString(Stringsource,Stringstr,intnumber)
  785. {
  786. source=checkNull(source);
  787. str=str==null?"...":str;
  788. intlen=strlen(source);//获得含有汉字的长度
  789. if(len<=number*2)//2个汉字为一个字符
  790. returnsource;
  791. intk=0;
  792. for(inti=source.length()-1;i>=0;i--)
  793. {
  794. charc=source.charAt(i);
  795. if((c>='0'&&c<='9')||(c>='a'&&c<='z')
  796. ||(c>='A'&&c<='Z'))//数字
  797. {
  798. k=+2;
  799. }
  800. else
  801. {
  802. if(Character.isLetter(c))
  803. {//中文
  804. continue;
  805. }
  806. else
  807. {//符号或控制字符
  808. //k++;
  809. continue;
  810. }
  811. }
  812. if(k==3)
  813. {
  814. number++;
  815. k=0;
  816. }
  817. }
  818. if(k==1)
  819. number++;
  820. returnsource.substring(0,number-1)+str;
  821. }
  822. /**
  823. *计算字符串长度.一个汉字的长度按2计算.如果给定的字符串为null,返回0.
  824. *@paramstr
  825. *@return
  826. */
  827. publicstaticintstrlen(Stringstr)
  828. {
  829. if(str==null||str.length()<=0)
  830. {
  831. return0;
  832. }
  833. intlen=0;
  834. charc;
  835. for(inti=str.length()-1;i>=0;i--)
  836. {
  837. c=str.charAt(i);
  838. if((c>='0'&&c<='9')||(c>='a'&&c<='z')
  839. ||(c>='A'&&c<='Z'))
  840. {
  841. //字母,数字
  842. len++;
  843. }
  844. else
  845. {
  846. if(Character.isLetter(c))
  847. {//中文
  848. len+=2;
  849. }
  850. else
  851. {//符号或控制字符
  852. len++;
  853. }
  854. }
  855. }
  856. returnlen;
  857. }
  858. /**
  859. *加密用,初始化JCE
  860. */
  861. static
  862. {
  863. Security.addProvider(newcom.sun.crypto.provider.SunJCE());
  864. }
  865. /**
  866. *字节码转换成16进制字符串
  867. *@paramb需要转换的字节流
  868. *@return以“:”分割的字符串
  869. */
  870. publicstaticStringbyte2hex(byte[]b)
  871. {
  872. Stringhs="";
  873. Stringstmp="";
  874. for(intn=0;n<b.length;n++)
  875. {
  876. stmp=(java.lang.Integer.toHexString(b[n]&0XFF));
  877. if(stmp.length()==1)
  878. hs=hs+"0"+stmp;
  879. else
  880. hs=hs+stmp;
  881. if(n<b.length-1)
  882. hs=hs+":";
  883. }
  884. returnhs.toUpperCase();
  885. }
  886. /**
  887. *16进制字符串转换字节码
  888. *@paramstr需要转换的字符串,以“:”分割
  889. *@return转换后的字节流
  890. */
  891. publicstaticbyte[]hex2byte(Stringstr)
  892. {
  893. Stringstmp[]=str.split(":");
  894. byte[]btmp=newbyte[stmp.length];
  895. for(intn=0;n<stmp.length;n++)
  896. {
  897. inti=Integer.valueOf(stmp[n],16);
  898. btmp[n]=(byte)(i&0XFF);
  899. }
  900. returnbtmp;
  901. }
  902. /**
  903. *生成密生成密钥,此方法比较慢
  904. *@paramalgorithm使用那个算法
  905. *@returnbyte[]密钥
  906. *@throwsException
  907. */
  908. publicstaticbyte[]getKey(Stringalgorithm)throwsException
  909. {
  910. KeyGeneratorkeygen=KeyGenerator.getInstance(algorithm);
  911. SecretKeydeskey=keygen.generateKey();
  912. returndeskey.getEncoded();
  913. }
  914. /**
  915. *加密算法
  916. *@paraminputbyte[]需要加密的byte流
  917. *@paramkeybyte[]密钥
  918. *@paramalgorithm使用那个算法
  919. *@return加密后的byte流
  920. *@throwsException
  921. */
  922. publicstaticbyte[]encode(byte[]input,byte[]key,Stringalgorithm)
  923. throwsException
  924. {
  925. SecretKeydeskey=newjavax.crypto.spec.SecretKeySpec(key,algorithm);
  926. Cipherc1=Cipher.getInstance(algorithm);
  927. c1.init(Cipher.ENCRYPT_MODE,deskey);
  928. byte[]cipherByte=c1.doFinal(input);//加密
  929. returncipherByte;
  930. }
  931. /**
  932. *封装好的加密算法
  933. *@paraminputString需要加密的串
  934. *@paramkeyString密钥
  935. *@paramalgorithm使用那个算法
  936. *@return加密后的String
  937. *@throwsException
  938. */
  939. publicstaticStringencode(Stringinput,Stringkey,Stringalgorithm)
  940. throwsException
  941. {
  942. returnbyte2hex(encode(input.getBytes(),key.getBytes(),algorithm));
  943. }
  944. /**
  945. *解密算法
  946. *@paraminputbyte[]需要解密的byte流
  947. *@paramkeybyte[]密钥
  948. *@paramalgorithm使用那个算法
  949. *@return解密后的byte流
  950. *@throwsException
  951. */
  952. publicstaticbyte[]decode(byte[]input,byte[]key,Stringalgorithm)
  953. throwsException
  954. {
  955. SecretKeydeskey=newjavax.crypto.spec.SecretKeySpec(key,algorithm);
  956. Cipherc1=Cipher.getInstance(algorithm);
  957. c1.init(Cipher.DECRYPT_MODE,deskey);
  958. byte[]clearByte=c1.doFinal(input);
  959. returnclearByte;
  960. }
  961. /**
  962. *封装好的解密算法
  963. *@paraminputString需要解密的字符串
  964. *@paramkeyString密钥
  965. *@paramalgorithm使用那个算法
  966. *@return解密后的字符串
  967. *@throwsException
  968. */
  969. publicstaticStringdecode(Stringinput,Stringkey,Stringalgorithm)
  970. throwsException
  971. {
  972. returnnewString(decode(hex2byte(input),key.getBytes(),algorithm));
  973. }
  974. /**
  975. *MD5摘要,不可逆
  976. *@paraminputbyte[]需要加密的byte流
  977. *@return加密后的byte流
  978. *@throwsException
  979. */
  980. publicstaticbyte[]md5(byte[]input)throwsException
  981. {
  982. java.security.MessageDigestalg=java.security.MessageDigest
  983. .getInstance("MD5");//or"SHA-1"
  984. alg.update(input);
  985. byte[]digest=alg.digest();
  986. returndigest;
  987. }
  988. /**
  989. *数字转换成人民币
  990. *@paramdouble需要转换的人民币金额
  991. *@returnString
  992. *@throwsException
  993. */
  994. publicstaticStringchangeToBig(doublevalue)
  995. {
  996. char[]hunit={'拾','佰','仟'};//段内位置表示
  997. char[]vunit={'万','亿'};//段名表示
  998. char[]digit={'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};//数字表示
  999. longmidVal=(long)(value*100);//转化成整形
  1000. StringvalStr=String.valueOf(midVal);//转化成字符串
  1001. Stringhead=valStr.substring(0,valStr.length()-2);//取整数部分
  1002. Stringrail=valStr.substring(valStr.length()-2);//取小数部分
  1003. Stringprefix="";//整数部分转化的结果
  1004. Stringsuffix="";//小数部分转化的结果
  1005. //处理小数点后面的数
  1006. if(rail.equals("00"))
  1007. {//如果小数部分为0
  1008. suffix="整";
  1009. }
  1010. else
  1011. {
  1012. suffix=digit[rail.charAt(0)-'0']+"角"
  1013. +digit[rail.charAt(1)-'0']+"分";//否则把角分转化出来
  1014. }
  1015. //处理小数点前面的数
  1016. char[]chDig=head.toCharArray();//把整数部分转化成字符数组
  1017. charzero='0';//标志'0'表示出现过0
  1018. bytezeroSerNum=0;//连续出现0的次数
  1019. for(inti=0;i<chDig.length;i++)
  1020. {//循环处理每个数字
  1021. intidx=(chDig.length-i-1)%4;//取段内位置
  1022. intvidx=(chDig.length-i-1)/4;//取段位置
  1023. if(chDig[i]=='0')
  1024. {//如果当前字符是0
  1025. zeroSerNum++;//连续0次数递增
  1026. if(zero=='0')
  1027. {//标志
  1028. zero=digit[0];
  1029. }
  1030. elseif(idx==0&&vidx>0&&zeroSerNum<4)
  1031. {
  1032. prefix+=vunit[vidx-1];
  1033. zero='0';
  1034. }
  1035. continue;
  1036. }
  1037. zeroSerNum=0;//连续0次数清零
  1038. if(zero!='0')
  1039. {//如果标志不为0,则加上,例如万,亿什么的
  1040. prefix+=zero;
  1041. zero='0';
  1042. }
  1043. prefix+=digit[chDig[i]-'0'];//转化该数字表示
  1044. if(idx>0)
  1045. prefix+=hunit[idx-1];
  1046. if(idx==0&&vidx>0)
  1047. {
  1048. prefix+=vunit[vidx-1];//段结束位置应该加上段名如万,亿
  1049. }
  1050. }
  1051. if(prefix.length()>0)
  1052. prefix+='圆';//如果整数部分存在,则有圆的字样
  1053. //System.out.println(value+"====>"+prefix+suffix);
  1054. returnprefix+suffix;//返回正确表示
  1055. }
  1056. /**
  1057. *将文件名中的汉字转为UTF8编码的串,以便下载时能正确显示另存的文件名.
  1058. *@params原文件名
  1059. *@return重新编码后的文件名
  1060. */
  1061. publicstaticStringtoUtf8String(Strings)
  1062. {
  1063. StringBuffersb=newStringBuffer();
  1064. for(inti=0;i<s.length();i++)
  1065. {
  1066. charc=s.charAt(i);
  1067. if(c>=0&&c<=255)
  1068. {
  1069. sb.append(c);
  1070. }
  1071. else
  1072. {
  1073. byte[]b;
  1074. try
  1075. {
  1076. b=Character.toString(c).getBytes("utf-8");
  1077. }
  1078. catch(Exceptionex)
  1079. {
  1080. System.out.println(ex);
  1081. b=newbyte[0];
  1082. }
  1083. for(intj=0;j<b.length;j++)
  1084. {
  1085. intk=b[j];
  1086. if(k<0)
  1087. k+=256;
  1088. sb.append("%"+Integer.toHexString(k).toUpperCase());
  1089. }
  1090. }
  1091. }
  1092. returnsb.toString();
  1093. }
  1094. /**
  1095. *返回num个空格
  1096. *@paramnum
  1097. *@return
  1098. */
  1099. publicstaticStringgetSpaces(intnum)
  1100. {
  1101. StringBuffersbr=newStringBuffer();
  1102. for(inti=0;i<num;i++)
  1103. {
  1104. sbr.append("");
  1105. }
  1106. returnsbr.toString();
  1107. }
  1108. }
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics