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

最新推荐文章于 2021-11-18 21:42:15 发布

最新推荐文章于 2021-11-18 21:42:15 发布 · 151 阅读

文章标签：

#java #javascript #ViewUI

本文介绍了一个实用的字符串工具类，其中包括随机字符串生成、日期格式化、字符串分割、替换等功能，并提供了加密解密方法和常见字符串操作的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

来自:http://xuliduo.javaeye.com/blog/196937
packagecom.wootion.idp.util;
importjava.io.IOException;
importjava.io.OutputStream;
importjava.security.Security;
importjava.text.SimpleDateFormat;
importjava.text.StringCharacterIterator;
importjava.util.Calendar;
importjava.util.Date;
importjava.util.HashMap;
importjava.util.StringTokenizer;
importjavax.crypto.Cipher;
importjavax.crypto.KeyGenerator;
importjavax.crypto.SecretKey;
/**
*文件名称:StringUtil.java
*文件描述:此类中封装一些常用的字符串操作（和业务无关）。/p>
*公司:
*内容摘要:
*其他说明:
*完成日期：Apr1,2007
*修改记录0：无
*@version1.0
*@author许力多
*/
publicclassStringUtil
{
//定义加密算法,可用DES,DESede,Blowfish
publicstaticStringDES="DES";
publicstaticStringDESEDE="DESede";
publicstaticStringBLOWFISH="Blowfish";
//dateSize中的日期参数
/*
*近一日
*/
publicstaticcharDATE_SIZE_DAY='d';
/*
*近一周
*/
publicstaticcharDATE_SIZE_WEEK='w';
/*
*近一月
*/
publicstaticcharDATE_SIZE_MONTH='m';
/*
*近一年
*/
publicstaticcharDATE_SIZE_YEAR='y';
/*
*明天
*/
publicstaticcharDATE_SIZE_TOMORROW='a';
/**
*私有构造方法，防止类的实例化，因为工具类不需要实例化。
*/
privateStringUtil()
{
}
publicstaticStringrandomName()throwsException
{
StringstrName=null;
//产生10位随机传
RandomStrgrst=newRandomStrg();
rst.setCharset("a-zA-Z0-9");
rst.setLength("17");
rst.generateRandomObject();
strName=rst.getRandom()+System.currentTimeMillis();
returnstrName;
}
/**
*取得时间
*@paramstr日期格式，可以为空（非null）
*@paramdates时间/如果为空那么取得当前时间
*@return
*/
publicstaticStringnow(Stringstr,java.sql.Datedates)
{
if("".equals(str))
str="yyyy-MM-dd";
java.util.Datedate=dates;
returnnow(str,date);
}
publicstaticStringrandomNum()
{
StringstrName=null;
//产生10位随机传
RandomStrgrst=newRandomStrg();
rst.setCharset("0-9");
rst.setLength("6");
try
{
rst.generateRandomObject();
}
catch(Exceptione)
{
e.printStackTrace();
}
strName=StringUtil.now("yyyyMMdd",null)+rst.getRandom();
returnstrName;
}
/**
*取得时间
*@paramstr日期格式，可以为空（非null）
*@paramdates时间/如果为空那么取得当前时间
*@return
*/
publicstaticStringnow(Stringstr,java.util.Datedates)
{
if("".equals(str))
str="yyyy-MM-dd";
java.text.SimpleDateFormatdate=newjava.text.SimpleDateFormat(str);
StringcurrentDate=date.format(dates!=null?dates:thisTime());
returncurrentDate;
}
/**
*取得当前时间
*@returnuitl.Data对象
*/
publicstaticjava.util.DatethisTime()
{
returnnewDate(System.currentTimeMillis());
}
/**
*此方法将给出的字符串source使用delim划分为单词数组。
*@paramsource需要进行划分的原字符串
*@paramdelim单词的分隔字符串
*@return划分以后的数组，如果source为null的时候返回以source为唯一元素的数组，
*如果delim为null则使用逗号作为分隔字符串。
*@since0.1
*/
publicstaticString[]split(Stringsource,Stringdelim)
{
String[]wordLists;
if(source==null)
{
wordLists=newString[1];
wordLists[0]=source;
returnwordLists;
}
if(delim==null)
{
delim=",";
}
StringTokenizerst=newStringTokenizer(source,delim);
inttotal=st.countTokens();
wordLists=newString[total];
for(inti=0;i<total;i++)
{
wordLists[i]=st.nextToken();
}
returnwordLists;
}
/**
*此方法将给出的字符串source使用delim划分为单词数组。
*@paramsource需要进行划分的原字符串
*@paramdelim单词的分隔字符
*@return划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
*@since0.2
*/
publicstaticString[]split(Stringsource,chardelim)
{
returnsplit(source,String.valueOf(delim));
}
/**
*此方法将给出的字符串source使用逗号划分为单词数组。
*@paramsource需要进行划分的原字符串
*@return划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
*@since0.1
*/
publicstaticString[]split(Stringsource)
{
returnsplit(source,",");
}
/**
*循环打印字符串数组。
*字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
*@paramstrings字符串数组
*@paramdelim分隔符
*@paramout打印到的输出流
*@since0.4
*/
publicstaticvoidprintStrings(String[]strings,Stringdelim,
OutputStreamout)
{
try
{
if(strings!=null)
{
intlength=strings.length-1;
for(inti=0;i<length;i++)
{
if(strings[i]!=null)
{
if(strings[i].indexOf(delim)>-1)
{
out.write(("/""+strings[i]+"/""+delim)
.getBytes());
}
else
{
out.write((strings[i]+delim).getBytes());
}
}
else
{
out.write("null".getBytes());
}
}
if(strings[length]!=null)
{
if(strings[length].indexOf(delim)>-1)
{
out.write(("/""+strings[length]+"/"").getBytes());
}
else
{
out.write(strings[length].getBytes());
}
}
else
{
out.write("null".getBytes());
}
}
else
{
out.write("null".getBytes());
}
out.write(java.lang.Character.LINE_SEPARATOR);
}
catch(IOExceptione)
{
}
}
/**
*循环打印字符串数组到标准输出。
*字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
*@paramstrings字符串数组
*@paramdelim分隔符
*@since0.4
*/
publicstaticvoidprintStrings(String[]strings,Stringdelim)
{
printStrings(strings,delim,System.out);
}
/**
*循环打印字符串数组。
*字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
*@paramstrings字符串数组
*@paramout打印到的输出流
*@since0.2
*/
publicstaticvoidprintStrings(String[]strings,OutputStreamout)
{
printStrings(strings,",",out);
}
/**
*循环打印字符串数组到系统标准输出流System.out。
*字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
*@paramstrings字符串数组
*@since0.2
*/
publicstaticvoidprintStrings(String[]strings)
{
printStrings(strings,",",System.out);
}
/**
*将字符串中的变量使用values数组中的内容进行替换。
*替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
*@paramprefix变量前缀字符串
*@paramsource带参数的原字符串
*@paramvalues替换用的字符串数组
*@return替换后的字符串。
*如果前缀为null则使用“%”作为前缀；
*如果source或者values为null或者values的长度为0则返回source；
*如果values的长度大于参数的个数，多余的值将被忽略；
*如果values的长度小于参数的个数，则后面的所有参数都使用最后一个值进行替换。
*@since0.2
*/
publicstaticStringgetReplaceString(Stringprefix,Stringsource,
String[]values)
{
Stringresult=source;
if(source==null||values==null||values.length<1)
{
returnsource;
}
if(prefix==null)
{
prefix="%";
}
for(inti=0;i<values.length;i++)
{
Stringargument=prefix+Integer.toString(i+1);
intindex=result.indexOf(argument);
if(index!=-1)
{
Stringtemp=result.substring(0,index);
if(i<values.length)
{
temp+=values[i];
}
else
{
temp+=values[values.length-1];
}
temp+=result.substring(index+2);
result=temp;
}
}
returnresult;
}
/**
*将字符串中的变量（以“%”为前导后接数字）使用values数组中的内容进行替换。
*替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
*@paramsource带参数的原字符串
*@paramvalues替换用的字符串数组
*@return替换后的字符串
*@since0.1
*/
publicstaticStringgetReplaceString(Stringsource,String[]values)
{
returngetReplaceString("%",source,values);
}
/**
*字符串数组中是否包含指定的字符串。
*@paramstrings字符串数组
*@paramstring字符串
*@paramcaseSensitive是否大小写敏感
*@return包含时返回true，否则返回false
*@since0.4
*/
publicstaticbooleancontains(String[]strings,Stringstring,
booleancaseSensitive)
{
for(inti=0;i<strings.length;i++)
{
if(caseSensitive==true)
{
if(strings[i].equals(string))
{
returntrue;
}
}
else
{
if(strings[i].equalsIgnoreCase(string))
{
returntrue;
}
}
}
returnfalse;
}
/**
*字符串数组中是否包含指定的字符串。大小写敏感。
*@paramstrings字符串数组
*@paramstring字符串
*@return包含时返回true，否则返回false
*@since0.4
*/
publicstaticbooleancontains(String[]strings,Stringstring)
{
returncontains(strings,string,true);
}
/**
*不区分大小写判定字符串数组中是否包含指定的字符串。
*@paramstrings字符串数组
*@paramstring字符串
*@return包含时返回true，否则返回false
*@since0.4
*/
publicstaticbooleancontainsIgnoreCase(String[]strings,Stringstring)
{
returncontains(strings,string,false);
}
/**
*将字符串数组使用指定的分隔符合并成一个字符串。
*@paramarray字符串数组
*@paramdelim分隔符，为null的时候使用""作为分隔符（即没有分隔符）
*@return合并后的字符串
*@since0.4
*/
publicstaticStringcombineStringArray(String[]array,Stringdelim)
{
intlength=array.length-1;
if(delim==null)
{
delim="";
}
StringBufferresult=newStringBuffer(length*8);
for(inti=0;i<length;i++)
{
result.append(array[i]);
result.append(delim);
}
result.append(array[length]);
returnresult.toString();
}
/**
*以指定的字符和长度生成一个该字符的指定长度的字符串。
*@paramc指定的字符
*@paramlength指定的长度
*@return最终生成的字符串
*@since0.6
*/
publicstaticStringfillString(charc,intlength)
{
Stringret="";
for(inti=0;i<length;i++)
{
ret+=c;
}
returnret;
}
/**
*去除左边多余的空格。
*@paramvalue待去左边空格的字符串
*@return去掉左边空格后的字符串
*@since0.6
*/
publicstaticStringtrimLeft(Stringvalue)
{
Stringresult=value;
if(result==null)
returnresult;
charch[]=result.toCharArray();
intindex=-1;
for(inti=0;i<ch.length;i++)
{
if(Character.isWhitespace(ch[i]))
{
index=i;
}
else
{
break;
}
}
if(index!=-1)
{
result=result.substring(index+1);
}
returnresult;
}
/**
*去除右边多余的空格。
*@paramvalue待去右边空格的字符串
*@return去掉右边空格后的字符串
*@since0.6
*/
publicstaticStringtrimRight(Stringvalue)
{
Stringresult=value;
if(result==null)
returnresult;
charch[]=result.toCharArray();
intendIndex=-1;
for(inti=ch.length-1;i>-1;i--)
{
if(Character.isWhitespace(ch[i]))
{
endIndex=i;
}
else
{
break;
}
}
if(endIndex!=-1)
{
result=result.substring(0,endIndex);
}
returnresult;
}
/**
*根据转义列表对字符串进行转义。
*@paramsource待转义的字符串
*@paramescapeCharMap转义列表
*@return转义后的字符串
*@since0.6
*/
publicstaticStringescapeCharacter(Stringsource,HashMapescapeCharMap)
{
if(source==null||source.length()==0)
returnsource;
if(escapeCharMap.size()==0)
returnsource;
StringBuffersb=newStringBuffer();
StringCharacterIteratorsci=newStringCharacterIterator(source);
for(charc=sci.first();c!=StringCharacterIterator.DONE;c=sci
.next())
{
Stringcharacter=String.valueOf(c);
if(escapeCharMap.containsKey(character))
character=(String)escapeCharMap.get(character);
sb.append(character);
}
returnsb.toString();
}
/**
*得到字符串的字节长度。
*@paramsource字符串
*@return字符串的字节长度
*@since0.6
*/
publicstaticintgetByteLength(Stringsource)
{
intlen=0;
for(inti=0;i<source.length();i++)
{
charc=source.charAt(i);
inthighByte=c>>>8;
len+=highByte==0?1:2;
}
returnlen;
}
/**
*得到字符串中的子串的个数。
*@paramsource字符串
*@paramsub子串
*@return字符串中的子串的个数
*@since0.6
*/
publicstaticintgetSubtringCount(Stringsource,Stringsub)
{
if(source==null||source.length()==0)
{
return0;
}
intcount=0;
intindex=source.indexOf(sub);
while(index>=0)
{
count++;
index=source.indexOf(sub,index+1);
}
returncount;
}
/**
*判断是否为null如果是返回""，不然返回原串
*@paramsource
*@return
*/
publicstaticStringcheckNull(Stringsource)
{
return(source=(source==null?"":source));
}
/**
*仿javascript的escape方法
*@paramsrc
*@return
*/
publicstaticStringescape(Stringsrc)
{
inti;
charj;
StringBuffertmp=newStringBuffer();
tmp.ensureCapacity(src.length()*6);
for(i=0;i<src.length();i++)
{
j=src.charAt(i);
if(Character.isDigit(j)||Character.isLowerCase(j)
||Character.isUpperCase(j))
{
tmp.append(j);
}
elseif(j<256)
{
tmp.append("%");
if(j<16)
{
tmp.append("0");
}
tmp.append(Integer.toString(j,16));
}
else
{
tmp.append("%u");
tmp.append(Integer.toString(j,16));
}
}
returntmp.toString();
}
/**
*仿javascript的unescape方法
*@paramsrc
*@return
*/
publicstaticStringunescape(Stringsrc)
{
StringBuffertmp=newStringBuffer();
tmp.ensureCapacity(src.length());
intlastPos=0,pos=0;
charch;
while(lastPos<src.length())
{
pos=src.indexOf("%",lastPos);
if(pos==lastPos)
{
if(src.charAt(pos+1)=='u')
{
ch=(char)Integer.parseInt(src
.substring(pos+2,pos+6),16);
tmp.append(ch);
lastPos=pos+6;
}
else
{
ch=(char)Integer.parseInt(src
.substring(pos+1,pos+3),16);
tmp.append(ch);
lastPos=pos+3;
}
}
else
{
if(pos==-1)
{
tmp.append(src.substring(lastPos));
lastPos=src.length();
}
else
{
tmp.append(src.substring(lastPos,pos));
lastPos=pos;
}
}
}
returntmp.toString();
}
/**
*在html里面显示加密过的中文
*@paramstr
*@return
*/
publicstaticStringgetHtmlEscape(Stringstr)
{
return"<script>document.write(unescape('"+escape(str)
+"'));</script>";
}
/**
*获得2个关键字之间的内容
*@params
*@paramstr1
*@paramstr2
*@return
*/
publicstaticStringgetBettown(Strings,Stringstr1,Stringstr2)
{
returns.substring(s.indexOf(str1)+1,s.indexOf(str2));
}
/**flq
*字符串转换成时间
*@paramstr时间字符串
*@return
*/
publicstaticDatestrToDate(Stringstr)
{
Datedate=null;
try
{
SimpleDateFormatformatters=newSimpleDateFormat("yyyy-MM-dd");
date=formatters.parse(str);
}
catch(Exceptione)
{
e.printStackTrace();
}
returndate;
}
/**
*自定义格式串转换date
*since西藏移动支撑系统
*@paramstr
*@paramdateformat
*@return
*/
publicstaticDatestrToDate(Stringstr,Stringdateformat)
{
Datedate=null;
try
{
SimpleDateFormatformatters=newSimpleDateFormat(dateformat);
date=formatters.parse(str);
}
catch(Exceptione)
{
e.printStackTrace();
}
returndate;
}
/**
*flq转换成时间字符串
*
*@paramtime
*时间
*@return
*/
publicstaticStringdateToStr(Datetime,Stringdateformat)
{
StringstrDate="";
try
{
SimpleDateFormatformatters=newSimpleDateFormat(dateformat);
strDate=formatters.format(time);
}
catch(Exceptione)
{
e.printStackTrace();
}
returnstrDate;
}
/**flq
*取得日期范围
*@paramtd:近一日w:近一周m:近一月y:近一年a:下一天
*@returnDate
*/
publicstaticDatedateSize(chart)
{
Datedate=thisTime();
Calendarcalendar=Calendar.getInstance();
calendar.setTime(date);
switch(t)
{
case'd':
//calendar.roll(calendar.DATE,false);
break;
case'w':
calendar.roll(calendar.WEEK_OF_YEAR,false);
break;
case'm':
calendar.roll(calendar.MONTH,false);
break;
case'y':
calendar.roll(calendar.YEAR,false);
break;
case'a':
calendar.roll(calendar.DATE,true);
break;
default:
System.out.println("dateSize函数参数错误");
}
date=calendar.getTime();
returndate;
}
/**
*根据数组返回str1,str2,str3,...strn的串
*@paramstr
*@return
*@throwsNullPointerException
*/
publicstaticStringgetStringFromArray(Stringstr[])
throwsNullPointerException
{
if(str==null)
thrownewNullPointerException("请输入需要转换的数组");
Stringstrs="";
for(Strings:str)
{
strs+=s+",";
}
if(strs.length()>0)
strs=strs.substring(0,strs.length()-1);
returnstrs;
}
/**
*根据入口的String，返回截取后的String，其中，2个数字算一个中文
*@paramsource
*@return截取后的新串10个中文，后面是...
*/
publicstaticStringinterceptString(Stringsource)
{
returninterceptString(source,"...",10);
}
/**
*根据入口的String，返回截取后的String，其中，2个数字算一个中文
*@paramsource需要变更的String
*@paramstr在String后面加的符号，默认为“...”
*@paramnumber剩余的中文个数
*@return截取后的新串
*/
publicstaticStringinterceptString(Stringsource,Stringstr,intnumber)
{
source=checkNull(source);
str=str==null?"...":str;
intlen=strlen(source);//获得含有汉字的长度
if(len<=number*2)//2个汉字为一个字符
returnsource;
intk=0;
for(inti=source.length()-1;i>=0;i--)
{
charc=source.charAt(i);
if((c>='0'&&c<='9')||(c>='a'&&c<='z')
||(c>='A'&&c<='Z'))//数字
{
k=+2;
}
else
{
if(Character.isLetter(c))
{//中文
continue;
}
else
{//符号或控制字符
//k++;
continue;
}
}
if(k==3)
{
number++;
k=0;
}
}
if(k==1)
number++;
returnsource.substring(0,number-1)+str;
}
/**
*计算字符串长度.一个汉字的长度按2计算.如果给定的字符串为null,返回0.
*@paramstr
*@return
*/
publicstaticintstrlen(Stringstr)
{
if(str==null||str.length()<=0)
{
return0;
}
intlen=0;
charc;
for(inti=str.length()-1;i>=0;i--)
{
c=str.charAt(i);
if((c>='0'&&c<='9')||(c>='a'&&c<='z')
||(c>='A'&&c<='Z'))
{
//字母,数字
len++;
}
else
{
if(Character.isLetter(c))
{//中文
len+=2;
}
else
{//符号或控制字符
len++;
}
}
}
returnlen;
}
/**
*加密用，初始化JCE
*/
static
{
Security.addProvider(newcom.sun.crypto.provider.SunJCE());
}
/**
*字节码转换成16进制字符串
*@paramb需要转换的字节流
*@return以“:”分割的字符串
*/
publicstaticStringbyte2hex(byte[]b)
{
Stringhs="";
Stringstmp="";
for(intn=0;n<b.length;n++)
{
stmp=(java.lang.Integer.toHexString(b[n]&0XFF));
if(stmp.length()==1)
hs=hs+"0"+stmp;
else
hs=hs+stmp;
if(n<b.length-1)
hs=hs+":";
}
returnhs.toUpperCase();
}
/**
*16进制字符串转换字节码
*@paramstr需要转换的字符串，以“:”分割
*@return转换后的字节流
*/
publicstaticbyte[]hex2byte(Stringstr)
{
Stringstmp[]=str.split(":");
byte[]btmp=newbyte[stmp.length];
for(intn=0;n<stmp.length;n++)
{
inti=Integer.valueOf(stmp[n],16);
btmp[n]=(byte)(i&0XFF);
}
returnbtmp;
}
/**
*生成密生成密钥，此方法比较慢
*@paramalgorithm使用那个算法
*@returnbyte[]密钥
*@throwsException
*/
publicstaticbyte[]getKey(Stringalgorithm)throwsException
{
KeyGeneratorkeygen=KeyGenerator.getInstance(algorithm);
SecretKeydeskey=keygen.generateKey();
returndeskey.getEncoded();
}
/**
*加密算法
*@paraminputbyte[]需要加密的byte流
*@paramkeybyte[]密钥
*@paramalgorithm使用那个算法
*@return加密后的byte流
*@throwsException
*/
publicstaticbyte[]encode(byte[]input,byte[]key,Stringalgorithm)
throwsException
{
SecretKeydeskey=newjavax.crypto.spec.SecretKeySpec(key,algorithm);
Cipherc1=Cipher.getInstance(algorithm);
c1.init(Cipher.ENCRYPT_MODE,deskey);
byte[]cipherByte=c1.doFinal(input);//加密
returncipherByte;
}
/**
*封装好的加密算法
*@paraminputString需要加密的串
*@paramkeyString密钥
*@paramalgorithm使用那个算法
*@return加密后的String
*@throwsException
*/
publicstaticStringencode(Stringinput,Stringkey,Stringalgorithm)
throwsException
{
returnbyte2hex(encode(input.getBytes(),key.getBytes(),algorithm));
}
/**
*解密算法
*@paraminputbyte[]需要解密的byte流
*@paramkeybyte[]密钥
*@paramalgorithm使用那个算法
*@return解密后的byte流
*@throwsException
*/
publicstaticbyte[]decode(byte[]input,byte[]key,Stringalgorithm)
throwsException
{
SecretKeydeskey=newjavax.crypto.spec.SecretKeySpec(key,algorithm);
Cipherc1=Cipher.getInstance(algorithm);
c1.init(Cipher.DECRYPT_MODE,deskey);
byte[]clearByte=c1.doFinal(input);
returnclearByte;
}
/**
*封装好的解密算法
*@paraminputString需要解密的字符串
*@paramkeyString密钥
*@paramalgorithm使用那个算法
*@return解密后的字符串
*@throwsException
*/
publicstaticStringdecode(Stringinput,Stringkey,Stringalgorithm)
throwsException
{
returnnewString(decode(hex2byte(input),key.getBytes(),algorithm));
}
/**
*MD5摘要，不可逆
*@paraminputbyte[]需要加密的byte流
*@return加密后的byte流
*@throwsException
*/
publicstaticbyte[]md5(byte[]input)throwsException
{
java.security.MessageDigestalg=java.security.MessageDigest
.getInstance("MD5");//or"SHA-1"
alg.update(input);
byte[]digest=alg.digest();
returndigest;
}
/**
*数字转换成人民币
*@paramdouble需要转换的人民币金额
*@returnString
*@throwsException
*/
publicstaticStringchangeToBig(doublevalue)
{
char[]hunit={'拾','佰','仟'};//段内位置表示
char[]vunit={'万','亿'};//段名表示
char[]digit={'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};//数字表示
longmidVal=(long)(value*100);//转化成整形
StringvalStr=String.valueOf(midVal);//转化成字符串
Stringhead=valStr.substring(0,valStr.length()-2);//取整数部分
Stringrail=valStr.substring(valStr.length()-2);//取小数部分
Stringprefix="";//整数部分转化的结果
Stringsuffix="";//小数部分转化的结果
//处理小数点后面的数
if(rail.equals("00"))
{//如果小数部分为0
suffix="整";
}
else
{
suffix=digit[rail.charAt(0)-'0']+"角"
+digit[rail.charAt(1)-'0']+"分";//否则把角分转化出来
}
//处理小数点前面的数
char[]chDig=head.toCharArray();//把整数部分转化成字符数组
charzero='0';//标志'0'表示出现过0
bytezeroSerNum=0;//连续出现0的次数
for(inti=0;i<chDig.length;i++)
{//循环处理每个数字
intidx=(chDig.length-i-1)%4;//取段内位置
intvidx=(chDig.length-i-1)/4;//取段位置
if(chDig[i]=='0')
{//如果当前字符是0
zeroSerNum++;//连续0次数递增
if(zero=='0')
{//标志
zero=digit[0];
}
elseif(idx==0&&vidx>0&&zeroSerNum<4)
{
prefix+=vunit[vidx-1];
zero='0';
}
continue;
}
zeroSerNum=0;//连续0次数清零
if(zero!='0')
{//如果标志不为0,则加上,例如万,亿什么的
prefix+=zero;
zero='0';
}
prefix+=digit[chDig[i]-'0'];//转化该数字表示
if(idx>0)
prefix+=hunit[idx-1];
if(idx==0&&vidx>0)
{
prefix+=vunit[vidx-1];//段结束位置应该加上段名如万,亿
}
}
if(prefix.length()>0)
prefix+='圆';//如果整数部分存在,则有圆的字样
//System.out.println(value+"====>"+prefix+suffix);
returnprefix+suffix;//返回正确表示
}
/**
*将文件名中的汉字转为UTF8编码的串,以便下载时能正确显示另存的文件名.
*@params原文件名
*@return重新编码后的文件名
*/
publicstaticStringtoUtf8String(Strings)
{
StringBuffersb=newStringBuffer();
for(inti=0;i<s.length();i++)
{
charc=s.charAt(i);
if(c>=0&&c<=255)
{
sb.append(c);
}
else
{
byte[]b;
try
{
b=Character.toString(c).getBytes("utf-8");
}
catch(Exceptionex)
{
System.out.println(ex);
b=newbyte[0];
}
for(intj=0;j<b.length;j++)
{
intk=b[j];
if(k<0)
k+=256;
sb.append("%"+Integer.toHexString(k).toUpperCase());
}
}
}
returnsb.toString();
}
/**
*返回num个空格
*@paramnum
*@return
*/
publicstaticStringgetSpaces(intnum)
{
StringBuffersbr=newStringBuffer();
for(inti=0;i<num;i++)
{
sbr.append("");
}
returnsbr.toString();
}
}