paramutil.java

转载 基于struts+hibernate 框架的权限管理系统

     * @param strVal
     * @param ch
     * @return
     */
    public static String trimChar(String strVal, char ch) {
        if(strVal.length()==1){
            return null;
        }
        if (strVal.charAt(0) == ch) {
            strVal = strVal.substring(1);
        }
        if (strVal.charAt(strVal.length() - 1) == ch) {
            strVal = strVal.substring(0,strVal.length() - 1);
        }
        return strVal;
    }

    /**
     * 去掉右面的char
     * @param strNum
     * @param c
     * @return
     */
    public static String delRightChar(String strNum,char c){
        int i = 0;
        if (strNum.length() > 1) {
            for (i = (strNum.length()-1); i >= 0; i--) {
                if (strNum.charAt(i) != c) {
                    strNum = strNum.substring(0, (i+1));
                    break;
                }
            }
        }
        return strNum;
    }
    
    /**
     * 取左面固定长度(中文长度)的提示串
     * @param inputstr
     * @param strLen 中文长度
     * @return
     */
    public static String leftAlertStr(String inputstr, int strLen) {
        String retStr="";
        int inputstrLen=inputstr.length();
        if(inputstrLen<=strLen){
            retStr=inputstr;
        }else{
            retStr=leftGBStr(inputstr,strLen);
            retStr="<div title=\""+inputstr+"\">"+retStr+"</div>";
        }
        return retStr;
    }
    
    /**
     * 取左面固定长度(中文长度)的字符串
     * @param inputstr
     * @param strLen 中文长度
     * @return
     */
    public static String leftGBStr(String inputstr, int strLen) {
        String retStr="";
        int i=0;
        int tmp=0;
        int reallen=0;
        int encharNum=0;
        int inputstrLen=inputstr.length();
        if(inputstrLen<strLen){
            retStr=inputstr;
        }else{
            try{
                for (i = 0; i < strLen; i++) {
                    if (i >= inputstrLen) {
                        break;
                    }
                    if (inputstr.charAt(i) < 255) {
                        tmp++;
                        encharNum++;
                    }
                    if ((tmp % 2) == 0 && tmp != 0) {
                        strLen++;
                        tmp = 0;
                    }
                    reallen = strLen;
                }
                if ((encharNum % 2) != 0) {
                    reallen++;
                }
                retStr = inputstr.substring(0, reallen);
            }catch(Exception e){
                retStr = inputstr;
            }
        }
        return retStr;
    }

    /**
     * 字符串长度(中文长度)
     * @param inputstr
     * @return
     */
    public static int strGBlen(String inputstr) {
        if(inputstr==null || inputstr.equals("")){
            return 0;
        }
        int strlen=0;
        int strGBlen=0;
        int i=0;
        strlen=inputstr.length();
        for(i=0;i<strlen;i++){
            if(inputstr.charAt(i)>255){
                strGBlen+=2;
            }else{
                strGBlen++;
            }
        }
        strGBlen=strGBlen/2;
        return strGBlen;
    }
    
    /**
     * 格式化double为固定长度
     * @param pDouble
     * @param bitnum
     * @return
     */
    public static double formatNumber(double pDouble,int bitnum){
		BigDecimal  bd=new  BigDecimal(pDouble);
		BigDecimal  bd1=bd.setScale(bitnum,BigDecimal.ROUND_HALF_UP);
		pDouble=bd1.doubleValue();
		return pDouble;
    }
    
    /**
     * 格式化Double对象为固定长度
     * @param pDouble
     * @param bitnum
     * @return
     */
    public static double formatNumber(Double pDouble,int bitnum){
        double Ret=Double.parseDouble(""+pDouble);
        Ret=formatNumber(Ret,bitnum);
        return Ret;
    }

    /**
     * 反转字符串
     * @param str
     * @return
     */
    public static String ReverseStr(String str){
        String retStr="";
        char tmpArr[]=str.toCharArray();
        for(int i=0;i<tmpArr.length;i++){
            retStr=tmpArr[i]+retStr;
        }
        return retStr;
    }

    /**
     * 判断字符串是否符合double格式
     * @param inStr
     * @return
     */
    public static boolean isDoubleFormat(String inStr){
        boolean ret=false;
        try{
            Double.parseDouble(inStr);
            ret=true;
        }catch(Exception e){
        }
        return ret;
    }

    /**
     * 判断字符串是否符合int格式
     * @param inStr
     * @return
     */
    public static boolean isInt(String inStr){
        boolean ret=false;
        try{
            Integer.parseInt(inStr);
            ret=true;
        }catch(Exception e){
        }
        return ret;
    }

    /**
     * 数组排序
     * @param inputArr 输入二维数组
     * @param keyNum 以哪一维排序
     * @param sortType "desc"为降序，"asc"为升序
     * @return 返回二维数组
     */
    public static String[][] sortArr(String inputArr[][],int keyNum,String sortType){
        int inputArr_lineLen=0;
        int inputArr_ColLen=0;
        String[][] outputArr=null;
        if(inputArr!=null){
           inputArr_lineLen=inputArr.length;
           inputArr_ColLen=inputArr[0].length;
           outputArr=new String[inputArr_lineLen][inputArr_ColLen];
           int i=0,j=0,k=0;
           String filteridStr=",";
           for(i=0;i<inputArr_lineLen;i++){
               k=sorArrMaxID(inputArr,keyNum,sortType,filteridStr);
               if(k==-1){
                   outputArr[0][0]="数据出错";
                   break;
               }
               filteridStr=filteridStr+k+",";
               for(j=0;j<inputArr_ColLen;j++){
                   outputArr[i][j]=inputArr[k][j]; //构建新数组
               }
           }
        }
        inputArr=null;
        return outputArr;
    }
    
    /**
     * 得到数组排序最大序号
     * @param inputArr 输入二维数组
     * @param keyNum 按照第几列排序
     * @param sortType  “asc”升序,“desc”降序
     * @param filteridStr 间隔字串
     * @return 返回序号
     */
    private static int sorArrMaxID(String inputArr[][],int keyNum,String sortType,String filteridStr){
        int retVal=-1;
        int i=0;
        double tempDb=0,tempDouble=0;
        boolean programrun=false;
        if(inputArr!=null && inputArr.length>0){
            if(sortType.equalsIgnoreCase("desc")){
                for (i = 0; i < inputArr.length; i++) {
                    if (filteridStr.indexOf("," + i + ",") >= 0) {
                        continue;
                    }
                    tempDb = Double.parseDouble(inputArr[i][keyNum]);
                    if (tempDb > tempDouble || programrun == false) {
                        tempDouble = tempDb;
                        retVal = i;
                        programrun = true;
                    }
                }
            }else{
                for (i = 0; i < inputArr.length; i++) {
                    if (filteridStr.indexOf("," + i + ",") >= 0) {
                        continue;
                    }
                    tempDb = Double.parseDouble(inputArr[i][keyNum]);
                    if (tempDb < tempDouble || programrun == false) {
                        tempDouble = tempDb;
                        retVal = i;
                        programrun = true;
                    }
                }
            }
        }
        inputArr=null;
        return retVal;
    }

    /**
     * 得到时间间隔天数
     * @param g1 GregorianCalendar
     * @param g2 GregorianCalendar
     * @return int
     */
    public static int getDays(GregorianCalendar g1, GregorianCalendar g2) {
       int elapsed = 0;
       GregorianCalendar gc1, gc2;

       if (g2.after(g1)) {
          gc2 = (GregorianCalendar) g2.clone();
          gc1 = (GregorianCalendar) g1.clone();
       }
       else   {
          gc2 = (GregorianCalendar) g1.clone();
          gc1 = (GregorianCalendar) g2.clone();
       }

       gc1.clear(Calendar.MILLISECOND);
       gc1.clear(Calendar.SECOND);
       gc1.clear(Calendar.MINUTE);
       gc1.clear(Calendar.HOUR_OF_DAY);

       gc2.clear(Calendar.MILLISECOND);
       gc2.clear(Calendar.SECOND);
       gc2.clear(Calendar.MINUTE);
       gc2.clear(Calendar.HOUR_OF_DAY);

       while ( gc1.before(gc2) ) {
          gc1.add(Calendar.DATE, 1);
          elapsed++;
       }
       return elapsed;
    }
    
    /**
     * 得到时间间隔天数
     * @param dt1
     * @param dt2
     * @return
     */
    public static int getDays(String dt1, String dt2) {
       return getDays(parseDate(dt1), parseDate(dt2));
    }
    
    /**
     * 日期转换
     * @param date
     * @return
     */
    private static GregorianCalendar DateToCal(Date date){
        return (new GregorianCalendar(Integer.parseInt(getDate(date,"yyyy")),(Integer.parseInt(getDate(date,"MM"))-1),Integer.parseInt(getDate(date,"dd")),Integer.parseInt(getDate(date,"HH")),Integer.parseInt(getDate(date,"mm")),Integer.parseInt(getDate(date,"ss"))));
    }
    
    /**
     * 得到两日期之间的间隔天数
     * @param date1
     * @param date2
     * @return
     */
    public static int getDays(Date date1, Date date2) {
       return getDays(DateToCal(date1), DateToCal(date2));
    }
    
    /**
     * 得到添加时间的日期串
     * @param dt1
     * @param days_add
     * @return
     */
    public static String getAddDays(String dt1, int days_add) {
        Date date1=parseDate(dt1);
        GregorianCalendar gc=DateToCal(date1);
        gc.add(GregorianCalendar.DATE,days_add);
        return getDate(gc.getTime(),"yyyy-MM-dd HH:mm:ss");
    }
    
    /**
     * 字符串转为时间
     * @param dt
     * @return
     */
    public static Date parseDate(String dt){
        DateFormat df=DateFormat.getDateTimeInstance();
        Date date=null;
        try {
           date = df.parse(dt);
        } catch (ParseException ex) {
           System.out.println("日期格式转换错误");
           date=new Date(); //用当前时间替换
        }
        return date;
    }

    /**
     * 二维数组转为一维数组（String）
     * @param dataArr String[][]
     * @param ColIndex int
     * @return String[]
     */
    public static String[] Convert2Dto1D(String dataArr[][],int ColIndex){
        String[] retArr=null;
        if(dataArr!=null){
          int LineLen = dataArr.length; //行
          if(LineLen>0){
            int ColLen = dataArr[0].length; //列
            if(ColIndex<ColLen){
               retArr=new String[LineLen];
               for(int i=0;i<LineLen;i++){
                  retArr[i]=dataArr[i][ColIndex];
               }
            }
          }
          dataArr=null;
        }
        return retArr;
    }
    
    /**
     * Base64Encode
     * @param s
     * @return
     */
    public static String Base64Encode(String s){
        return (new sun.misc.BASE64Encoder()).encode(s.getBytes());
    }
    
    /**
     * Base64Decode
     * @param s
     * @return
     */
	public static String Base64Decode(String s){
	    try{
	      byte[] temp = (new sun.misc.BASE64Decoder()).decodeBuffer(s);
	      return new String(temp);
	    }catch(Exception ioe){
	       return null;
	    }
	}
    
    public static void main(String[] args) {
      String teststr=Base64Encode("中文456信?息&测试=123");
      System.out.println(teststr);
      teststr=Base64Decode(teststr);
      System.out.println(teststr);
//    	for(int i=0;i<100;i++){
//           System.out.println(RandNum(10));
//    	}
    }

}