开发中日常操作转化工具类

Java代码

packagecom.util;

importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.io.Writer;
importjava.lang.reflect.Method;
importjava.net.InetAddress;
importjava.net.NetworkInterface;
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.ArrayList;
importjava.util.Calendar;
importjava.util.Date;
importjava.util.Enumeration;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Locale;
importjava.util.Map;
importjava.util.regex.Matcher;
importjava.util.regex.Pattern;

importjavax.servlet.http.HttpServletResponse;
importorg.apache.commons.logging.Log;
importorg.apache.commons.logging.LogFactory;

publicclassUtil
{
/**
*ERRORTYPE
*/
publicstaticfinalStringERRORTYPE="TYPE";

/**
*ERRORTYPE_ERROR
*/
publicstaticfinalStringERRORTYPE_ERROR="ERROR";

/**
*ERRORCODE
*/
publicstaticfinalStringERRORCODE="ERRORCODE";

/**
*ERRORINFO
*/
publicstaticfinalStringERRORINFO="ERRORINFO";

/**
*GOPAGE
*/
publicstaticfinalStringGOPAGE="GOPAGE";

/**
*有效小数
*/
publicstaticfinalintEFFECTIVE=2;

protectedstaticfinalLogLOG=LogFactory.getLog(Util.class);

/**
*移除重复
*
*@paramarr
*要处理的字符串数
*@return处理后的字符串数
*/
publicstaticString[]removeRepeat(String[]arr)
{
if(arr==null)
{
returnnewString[0];
}
else
{

Map<String,String>map=newHashMap<String,String>();
for(Stringstr:arr)
{
Stringstrt=map.get(str);
if(strt==null)
{
map.put(str,str);
}
}

List<String>list=newArrayList<String>();
for(Map.Entry<String,String>entry:map.entrySet())
{
list.add(entry.getKey());
}

String[]strArr=newString[list.size()];

returnlist.toArray(strArr);
}
}

/**
*移除重复
*
*/
publicstaticStringremoveRepeat(Stringstr)
{
if(str==null)
{
return"";
}
else
{
str=str.replaceAll("^,+","");
str=str.replaceAll(",+$","");
str=str.replaceAll(",+",",");
StringBufferbuf=newStringBuffer();
for(Stringstrt:removeRepeat(str.split(",")))
{
buf.append(strt).append(',');
}

str=removeEnd(buf.toString());
returnstr;
}
}

/**
*移除开头的逗号
*
*/
publicstaticStringremoveBegin(Stringstr)
{
if(str==null)
{
return"";
}
else
{
Matchermatcher=Pattern.compile("^,+").matcher(str);
str=matcher.replaceAll("");
returnstr;
}
}

/**
*移除结尾的逗号
*
*/
publicstaticStringremoveEnd(Stringstr)
{
if(str==null)
{
return"";
}
else
{
Matchermatcher=Pattern.compile(",+$").matcher(str);
str=matcher.replaceAll("");
returnstr;
}
}

/**
*格式化日期
*@paramdate日期
*@parampattern格式
*@returnStringString
*/
publicstaticStringformatDate(Datedate,Stringpattern)
{
SimpleDateFormatformat=newSimpleDateFormat(pattern);

returnformat.format(date);
}

/**
*〈计算两个日期相差的天数〉
*〈功能详细描述〉
*@parambegin开始日期
*@paramend结束日期
*@returnlong
*/
publicstaticlongcalDays(Datebegin,Dateend)
{
longtime=end.getTime()-begin.getTime();
longdays=time/24/60/60/1000;
returndays;
}

/**
*获取未来第几天的时间yyyy-MM-dd
*@paramdayNum
*@return
*/
publicstaticStringgetNextDay(intdayNum){
Calendarcal=Calendar.getInstance();
Datedate=newDate();
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-dd");
StringreturnDate="";
try
{
cal.setTime(date);
cal.add(Calendar.DATE,dayNum);
returnDate=sdf.format(cal.getTime());
}
catch(Exceptione)
{
e.printStackTrace();
}
returnreturnDate;
}

/**
*格式化日期
*@paramstr日期字符串
*@parampattern格式
*@returnDateDate
*/
publicstaticDateformatDate(Stringstr,Stringpattern)
{
Datedate=null;

try
{
SimpleDateFormatformat=newSimpleDateFormat(pattern);

date=format.parse(str);
}
catch(ParseExceptione)
{
date=newDate();
}

returndate;
}

/**
*解析字符
*
*@paramkey
*key
*@paramstr
*str
*@returnvalue
*/
publicstaticStringgetValue(Stringkey,Stringstr)
{
if(key==null||str==null)
{
return"";
}
String[]strArr=str.split(",");

for(StringtempStr:strArr)
{
if(key.equals(tempStr.split(":")[0]))
{
returntempStr.split(":")[1];
}
}

return"";
}

/**
*解析字符
*
*@paramkey
*key
*@paramstr
*str
*@returnvalue
*/
publicstaticintgetIntValue(Stringkey,Stringstr)
{
intresult=0;
if(str==null)
{
returnresult;
}
String[]strArr=str.split(",");

Stringvalue="0";
for(StringtempStr:strArr)
{
if(key.equals(tempStr.split(":")[0]))
{
value=tempStr.split(":")[1];
}
}
try
{
result=Integer.parseInt(value);
}
catch(Exceptione)
{
result=0;
}

returnresult;
}

/**
*解析字符
*/
publicstaticString[]getValue(Stringstr)
{
if(str==null)
{
returnnewString[0];
}
returnstr.split(",");
}

/**
*直接向用户返回指定信息
*
*@paramresponse
*response
*@parammsg
*void
*/
publicstaticvoidreturnMsg(HttpServletResponseresponse,Stringmsg)
{
Writerout=null;
try
{
out=response.getWriter();
out.write(msg);
out.close();
}
catch(IOExceptione)
{
LOG.error(e);
}
}

/**
*
*@paramstrstr
*@paramregreg
*@paramnewValuenewValue
*@returnString
*/
publicstaticStringreplace(Stringstr,Stringreg,StringnewValue)
{
if(!isEmpty(str))
{
Matchermatcher=Pattern.compile(reg,Pattern.CASE_INSENSITIVE).matcher(str);

str=matcher.replaceAll(newValue);
}
returnstr;
}

/**
*
*@paramstrstr
*@paramregreg
*@paramnewValuenewValue
*@paramparamparam
*@returnString
*/
publicstaticStringreplace(Stringstr,Stringreg,StringnewValue,intparam)
{
if(!isEmpty(str))
{
Matchermatcher=Pattern.compile(reg,param).matcher(str);

str=matcher.replaceAll(newValue);
}
returnstr;
}

/**
*〈移除字符串中的js代码
*
*@paramstr
*str
*@returnString
*/
publicstaticStringremoveScript(Stringstr)
{
if(str==null||"".equals(str))
{
return"";
}

intparam=Pattern.CASE_INSENSITIVE|Pattern.MULTILINE|Pattern.DOTALL;
Matchermatcher=Pattern.compile("<script>.*</script>",param).matcher(str);
str=matcher.replaceAll("");
returnstr;
}

/**
*字符串转成整数
*
*@paramstr
*字符
*@return数字
*/
publicstaticintparseInt(Stringstr)
{
intresult=0;
try
{
result=Integer.parseInt(str);
}
catch(Exceptione)
{
result=0;
}
returnresult;
}

/**
*〈文件重命名〉
*
*@paramrealPath
*文件绝对路径
*@paramnewName
*新文件名
*@returnString
*/
publicstaticStringrename(StringrealPath,StringnewName)
{
Filefile=newFile(realPath);

//包含后缀的文件名
StringfileName=file.getName();

//不包含后的文件名
Stringname=fileName.substring(0,fileName.lastIndexOf('.'));

//带后的新文件名称
newName=fileName.replace(name,newName);

realPath=realPath.replace(fileName,newName);

if(file.exists())
{
try
{
if(!file.renameTo(newFile(realPath)))
{
thrownewException();
}

}
catch(Exceptione)
{
e.printStackTrace();
}
}

returnnewName;
}

/**
*把数组转换成字符串,并以逗号分隔
*
*@paramarr
*arr
*@return转换结果
*/
publicstaticStringarrayToString(String[]arr)
{

if(arr==null)
{
return"";
}
StringBufferbuf=newStringBuffer();
for(Stringstr:arr)
{
if(str!=null&&!"".equals(str))
{
buf.append(str).append(',');
}
}
Stringresult=buf.toString();
result=result.replaceAll(",$","");
returnresult;
}

/**
*写Excel
*
*@paramresponse
*response
*@paramfile
*file
*/
publicstaticvoidwriteExcel(HttpServletResponseresponse,Filefile)
{
if(file!=null&&file.exists())
{


response.reset();
response.setContentType("application/vnd.ms-excel");
response.addHeader("Content-Disposition","attachment;filename=\""+file.getName()+"\"");
InputStreaminStream=null;
try
{
inStream=newFileInputStream(file);
intlen=inStream.read();
while(len!=-1)
{
response.getWriter().write(len);
len=inStream.read();
}
}
catch(Exceptione)
{

e.printStackTrace();
}
finally
{
Util.close(inStream);
}
}
}




/**
*
*@paramreg
*reg
*@paramstr
*str
*@returnboolean
*/
publicstaticbooleantest(Stringreg,Stringstr)
{
Matchermatcher=Pattern.compile(reg).matcher(str);
returnmatcher.find();
}


/**
*关闭流
*@paraminsvoid
*/
publicstaticvoidclose(InputStreamins)
{
if(ins!=null)
{
try
{
ins.close();
}
catch(IOExceptione)
{
e.printStackTrace();
}
}
}

/**
*关闭流
*@paramousvoid
*/
publicstaticvoidclose(OutputStreamous)
{
if(ous!=null)
{
try
{
ous.close();
}
catch(IOExceptione)
{
e.printStackTrace();
}
}
}

/**
*
*〈重新组装查询条件〉
*〈如果查询条件包含"_"就在"_"之前加上转义字符"/"〉
*@paramqueryCondition查询条件
*@returnString
*/
publicstaticStringresetCondition(StringqueryCondition)
{
char[]temps=queryCondition.toCharArray();

//查询条件
StringBuffercondition=newStringBuffer();

//重新组装查询条件的字符串，如果包"_"就在"_"之前加上转义字符"/"
for(chartemp:temps)
{
if('_'==temp)
{
condition.append('/').append(temp);
}
else
{
condition.append(temp);
}
}

returncondition.toString();
}

/**
*〈验证字符串是否为空〉
*@paramstrstr
*@returnboolean
*/
publicstaticbooleanisEmpty(Stringstr)
{
returnstr==null||"".equals(str);
}

/**
*〈验证字符串是否不为空〉
*@paramstrstr
*@returnboolean
*/
publicstaticbooleannotEmpty(Stringstr)
{
return!isEmpty(str);
}

/**
*〈验证字符串是否为空〉
*@paramstrstr
*@returnboolean
*/
publicstaticbooleanisEmpty(Objectstr)
{
returnstr==null;
}

/**
*〈〈验证字符串是否为空〉
*@paramlistlist
*@returnboolean
*/
publicstaticbooleanisEmpty(List<?>list)
{
returnlist==null||list.isEmpty();
}

/**
*〈〈验证字符串是否不为空〉
*@paramlistlist
*@returnboolean
*/
publicstaticbooleannotEmpty(List<?>list)
{
return!isEmpty(list);
}

/**
*〈验证字符串是否为空〉
*@parammap待处理的集合
*@returnboolean
*/
publicstaticbooleanisEmpty(Map<?,?>map)
{
returnmap==null||map.isEmpty();
}

/**
*〈验证字符串是否不为空〉
*@parammap待处理的集合
*@returnboolean
*/
publicstaticbooleannotEmpty(Map<?,?>map)
{
return!isEmpty(map);
}

/**
*〈转换为小写
*@paramstrstr
*@returnString
*/
publicstaticStringlowerCase(Stringstr)
{

if(str!=null)
{
str=str.toLowerCase(Locale.CHINESE);
}

returnstr;
}

/**
*〈转换为大写〉
*@paramstrstr
*@returnString
*/
publicstaticStringupperCase(Stringstr)
{

if(str!=null)
{
str=str.toUpperCase(Locale.CHINESE);
}

returnstr;
}

/**
*〈一句话功能描述〉
*@paramclscls
*@parammethodNamemethodName
*@paramclassArrclassArr
*@returnMethod
*/
@SuppressWarnings("unchecked")
publicstaticMethodgetMethod(Class<?>cls,StringmethodName,Class[]classArr)
{
Methodmtd=null;
try
{
mtd=cls.getDeclaredMethod(methodName,classArr);
}
catch(SecurityExceptione)
{
LOG.error(e);
}
catch(NoSuchMethodExceptione)
{
LOG.error(e);
}

returnmtd;
}

/**
*获取当前服务器ip
*@returnString
*/
publicstaticStringgetLocalSiteIP()
{
StringsiteString="";
try
{
Enumeration<NetworkInterface>netInterfaces=NetworkInterface.getNetworkInterfaces();
NetworkInterfacenetworkInterface=null;
InetAddressipAddress=null;
while(netInterfaces.hasMoreElements())
{
networkInterface=(NetworkInterface)netInterfaces.nextElement();
ipAddress=(InetAddress)networkInterface.getInetAddresses().nextElement();
if(ipAddress.isSiteLocalAddress()&&!ipAddress.isLoopbackAddress()
&&ipAddress.getHostAddress().indexOf(":")==-1)
{
siteString=ipAddress.getHostAddress();
}
}
}
catch(Exceptione)
{
e.toString();
}
returnsiteString;
}

/**
*〈trim公共方法
*〈功能详细描述
*@paramstrstr
*@returnString
*/
publicstaticStringtrim(Stringstr)
{
if(str!=null)
{
str=str.trim();
}

returnstr;
}

/**
*检查算法表达式合法性
*@paramcalculateScript计算脚本
*@return返回true表达式合?,false表达式不合法
*/
publicstaticbooleancheckCalculateScript(StringcalculateScript)
{
returntrue;
}

/**
*获取系统时间
*@return当前系统时间
*/
publicstaticDategetSysDate()
{
SimpleDateFormatft=null;
Calendarcal=Calendar.getInstance();

//格式可以自己根据要求修改
ft=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
StringdateTime=ft.format(cal.getTime());
DatenowDate=null;
try
{
nowDate=ft.parse(dateTime);
}
catch(ParseExceptione)
{
LOG.error(e);
//e.printStackTrace();
}

returnnowDate;
}

/**
*〈根据系统当前时间获取下一个月日期对象〉
*〈功能详细描述〉
*@returnDate
*/
publicstaticDategetNextMonth()
{
Calendarcal=Calendar.getInstance();
cal.add(Calendar.MONTH,1);
returncal.getTime();
}


/**
*设置文件输出流的文件名
*@paramfailName文件名
*@paramresponsevoid
*/
publicstaticvoidresponseSetHeader(StringfailName,HttpServletResponseresponse)
{
response.setHeader("Content-disposition","attachment;filename="+failName);
response.setContentType("application/msexcel");
}

/**
*〈为空验证〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanempty(Stringstr,Stringprop)
{
if(str==null)
{
returnfalse;
}

if("".equals(str.trim()))
{
returnfalse;
}

returntrue;
}

/*
*〈按字节验证字符串长度〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
/*publicstaticbooleanbyteLength(Stringstr,Stringprop)
{
intlength=20;

if(Util.isEmpty(str))
{
returntrue;
}

char[]chars=str.toCharArray();
intlen=0;
for(inti=0;i<chars.length;i++)
{
len++;

//判断是否非字母
if(chars[i]/0x80==0)
{
len++;
}
}

returnlen<=length;
}*/

/**
*〈非法字符〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanlawless(Stringstr)
{
booleanresult=false;

if(Util.isEmpty(str))
{
result=true;
}

result=!Util.test("^[-~!@#$%^&*()_+|=\\;':\",./<>?]+$",str);

returnresult;
}

/**
*〈验证只能为汉字〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanchinese(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^[\u4E00-\u9FA5]+$",str);
}

/**
*〈验证只能为字母〉
*@paramstr待验证字符串
*@returnboolean
*/
protectedstaticbooleanletter(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^[a-zA-Z]+$",str);
}

/**
*〈验证数字是否在指定范围〉
*@paramstrstr
*@parampropprop
*@returnboolean
*/
protectedstaticbooleannumber(Stringstr)
{

returntrue;
}

/**
*〈验证手机号码〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanmobile(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^1\\d{10}$",str);
}

/**
*〈验证IP〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleancheckIP(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

Stringpattern="^(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])(\\.(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])){3}$";
returnUtil.test(pattern,str);
}

/**
*〈验证日期〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleandate(Stringstr)
{
Stringpattern="";

if(Util.isEmpty(str))
{
returntrue;
}

SimpleDateFormatformat=newSimpleDateFormat(pattern);
try
{
format.parse(str);
}
catch(ParseExceptione)
{
returnfalse;
}

returntrue;
}

/**
*〈验证邮编〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanpostalCode(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

//暂未实现

returntrue;
}

/**
*〈验证EMAIL〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanemail(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^[a-zA-Z0-9_.]+@\\w+\\-?\\w+(\\.\\w+)$",str);
}

/*
*〈验证身份证〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
/*publicstaticbooleancheckID(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

if(Util.test("^\\d{17}[xX\\d]$",str))
{
returncheckID18(str);
}
elseif(Util.test("^\\d{15}$",str))
{
returncheckID15(str);
}
else
{
returnfalse;
}
}*/

/*privatestaticbooleancheckID18(Stringstr)
{
Stringyear=str.substring(6,2);
Stringmonth=str.substring(8,2);
Stringday=str.substring(10,2);
if(!Util.test("^\\d\\d$",year))
{
returnfalse;
}
if(!isMonth(month))
{
returnfalse;
}
if(!isDay(day))
{
returnfalse;
}
if(Util.parseInt(month)==2&&Util.parseInt(day)>FEB_DAYES)
{
returnfalse;
}
returntrue;
}

privatestaticbooleancheckID15(Stringstr)
{
Stringyear=str.substring(ID15_YEAR,4);
Stringmonth=str.substring(ID15_MONTH,2);
Stringday=str.substring(ID15_DAY,2);

if(!isYear(year))
{
returnfalse;
}

if(!isMonth(month))
{
returnfalse;
}

if(!isDay(day))
{
returnfalse;
}

if(Util.parseInt(month)==2&&Util.parseInt(day)>FEB_DAYES)
{
returnfalse;
}

returntrue;
}*/

/**
*〈验证必须为数字〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanmustNum(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^\\d+$",str);
}

/**
*〈体重验证〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanavoirdupois(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^([3-9]\\d|1\\d\\d)(\\.\\d{0,2})?$",str);
}

/**
*〈验证身高〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanstature(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^([89]\\d|[12]\\d\\d)(\\.\\d{0,2})?$",str);
}

/**
*〈验证年龄〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanage(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^([1-9]|[1-9]\\d?)$",str);
}

/**
*〈验证鞋码〉
*@paramstr待验证字符串
*@parampropprop
*@returnboolean
*/
protectedstaticbooleanshoeSize(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("(^[34]\\d$)|(^50$)",str);
}

/**
*判断是否为数字，包含浮点型
*@paramstr
*@return
*/
publicstaticbooleancheckNum(Stringstr)
{
if(Util.isEmpty(str))
{
returntrue;
}

returnUtil.test("^\\d+(\\.\\d+){0,1}$",str);
}

publicstaticvoidmain(String[]args){
System.out.println(checkNum("12"));
}

}