[펌] 각종 제어

http://blog.naver.com/galad/140037028567

블로그 > 맛깔나는 인생
http://blog.naver.com/dltjdals8110/50003851272

 /**
  * コード類をフォーマット
  *
  * 与えられたサイズに足りない場合は空白を入れてフォーマットする
  * @param cd
  * @param size
  * @return
  */
 public static String cdFormat(String cd, int size) {
  String formatStr;
 
  if(cd == null || Constant.EMPTY_STR.equals(cd)){
   formatStr = cd;
  } else {
   for(int i = 0; i < size; i++){
    cd = cd + Constant.SPACE;
   }
   
   formatStr = cd.substring(0, size);
  }
 
  return formatStr;
 }
 
 /**
  *  文字列の後ろの半角スペースを削除する
  * 문자열의 뒤의 반각 스페이스를 삭제한다
  * @param str：文字列
  * @return 後ろの半角スペースを削除した文字列
  */
 public static String rTrim(String str) throws Exception{

  if(str != null && !Constant.EMPTY_STR.equals(str)){

   if(Constant.EMPTY_STR.equals(str.trim())){
    str = str.trim();
   } else {
    int len = str.length()-1;
   
    int i;
    for(i=0;;i++){
     if(str.charAt(len-i) != ' ') break;
    }
    str = str.substring(0,len-i+1);
   }
  }
 
 
  return str;
 }
 
 /**
  * nullチェック
  * @param str
  * @return bookean true:可 false:null
  * @throws Exception
  */
 public static boolean chkNull(String str) throws Exception{
 
  if(str == null || str.trim().equals(Constant.EMPTY_STR)){
   return false;
  }
 
  return true;
 }
 
 /**
  * 半角英数字チェック

  *반각영숫자 체크
  * @param myStr
  * @return boolean true:半角英数字あるいはnull false：半角英数字以外
  */
 public static boolean chkHanAlNum(String myStr) throws Exception{

     if(!chkNull(myStr)){
         return true;
     }
     myStr = myStr.trim();
  for (int i = 0; i < myStr.length(); i++) {

   char charData = myStr.charAt(i);
   if (((charData < 'A') || (charData > 'Z'))
     && ((charData < 'a') || (charData > 'z'))
     && ((charData < '0') || (charData > '9'))) {
    return false;
   }
  }
  return true;
 }
 
 
 /**
  * 半角チェック
  * @param str
  * @return boolean true:半角 false:全角
  * @throws Exception
  */
 public static boolean chkHankaku(String str) throws Exception{
    
     // nullだったら正常修了
     if(!chkNull(str)){
         return true;
     }
    
     byte[] bytes = str.getBytes();
        int beams = str.length();
        if (beams == bytes.length) {
            return true;
        } else {
            return false;
        }
 }
 
 /**
  * 半角カナを含ませない半角チェック

  *반각 가나를 포함하게하지 않는 반각 체크
  * @param str
  * @return boolean true:半角 false:全角あり、半角カナあり
  * @throws Exception
  */
 public static boolean chkHankakuNotHankana(String str) throws Exception{
    
     // nullだったら正常修了
     if(!chkNull(str)){
         return true;
     }
    
     // 半角カナが含まれていたら不可
     if(!chkHanKana(str)){
         return false;
     }
    
     // 半角チェック
     if(!chkHankaku(str)){
         return false;
     }
    
     return true;
 }
 
 
 
 /**
  * 入力数値のサイズチェック
  * 입력 수치의 사이즈 체크
  * 整数部と小数部のサイズが指定したとおりであるかチェックする
  * @param numInString
  * @param leftSize
  * @param rightSize
  * @return
  * @throws Exception
  */
 public static boolean chkNumSize(String numInString, int leftSize, int rightSize) throws Exception {
    
     if(numInString == null || Constant.EMPTY_STR.equals(numInString)){
         return true;
     }
    
     //数値解釈可能か？

    //수치 해석 가능한가
     try{
         Double.parseDouble(numInString);
     }catch(NumberFormatException e){
         return false;
     }
    
     //整数部、小数部の桁数は指定通りか？

    //정수부, 소수부의 자리수는 지정 대로인가?
     if(numInString.charAt(0) == '-'){
         numInString = numInString.substring(1);
     }
     String[] splited = numInString.split("\\.");
     if(splited[0].length() > leftSize){ //整数部
         return false;
     }
     // 小数部がなければ終了

    //소수부가 없으면 종료
     if(splited.length <= 1){
         return true;
     }
     if(splited[1].length() > rightSize){ //小数部
         return false;
     }
    
     return true;
 }

 /**
  * 半角数字チェック

  *반각 숫자 체크
  * @param strInString
  * @return 半角数字でなければfalseを返す
  */
    public static boolean chkNum(String strInString) throws Exception{
    
        if(!chkNull(strInString)){
         return true;
     }
        strInString = strInString.trim();
        //文字列の長さ分繰り返し
        int intChk;
        intChk = 0;
        for (int i = 0; i < strInString.length(); i++) {
            char c = strInString.charAt(i);

            if ((c < '0' && c != '.') || (c > '9' && c != '.') ) {
                return false;
            }
        }
       
       
        if (intChk == 0) {
            return true;
        } else {
            return false;
        }
    }
   
    /**
     * <PRE>
     * 半角数字(小数を含む)チェック

    *반각 숫자(소수를 포함한다) 체크
     * 空白文字を許容しない
     * @param decStr:半角数字(小数を含む)
     * @return 半角数字(小数を含む):true　半角数字以外:false
     * @throws Exception
     * </PRE>
     */
    public static boolean chkDecimal(String decStr) throws Exception{
 
        if(!chkNull(decStr)){
         return false;
     }
        for (int i = 0; i < decStr.length(); i++) {
            char c = decStr.charAt(i);

            if ((c < '0' && c != '.') || (c > '9' && c != '.') ) {
                return false;
            }
        }
       
        return true;

    }

 /**
  * <PRE>
  * 半角正の整数チェック

  * 반각정의 정수 체크
  * 空白文字を許容しない

  * 공백 문자를 허용 하지 않는다
  * @param intStr:半角正の整数
  * @return true:半角正の整数 false:半角正の整数
     * @throws Exception
     * </PRE>
  */
    public static boolean chkPositiveInt(String intStr) throws Exception{
    
        if(!chkNull(intStr)){
         return false;
     }
        for (int i = 0; i < intStr.length(); i++) {
            char c = intStr.charAt(i);

            if ((c < '0' ) || (c > '9') ) {
                return false;
            }
        }
       
        return true;
    }

    /**
  * 半角正の整数チェック

  *반각정의 정수 체크
  * @param strInString
  * @return 半角正の整数でなければfalseを返す
  */
    public static boolean chkPositiveInteger (String strInString) throws Exception{
    
        if(!chkNull(strInString)){
         return true;
     }
        strInString = strInString.trim();
        //文字列の長さ分繰り返し
        int intChk;
        intChk = 0;
        for (int i = 0; i < strInString.length(); i++) {
            char c = strInString.charAt(i);

            if ((c < '0' ) || (c > '9') ) {
                return false;
            }
        }
       
        if (intChk == 0) {
            return true;
        } else {
            return false;
        }
    }
   
    /**
     * 文字列からカンマ削除

     *문자열로부터 콤마 삭제
     * @param strNum
     * @return
     */
    public static String deleteComma(String strNum) throws Exception{

        //トークン格納用  토큰 격납용
        String strNextToken = Constant.EMPTY_STR;

        //戻り値格納用(編集後数値)  반환값 격납용(편집 후 수치)
        String strNewNum = Constant.EMPTY_STR;

        StringTokenizer tokenizer = new StringTokenizer(strNum, Constant.COMMA);

        //トークンが存在する間ループし変数にトークンを格納

       //토큰이 존재하는 동안 루프 해 변수에 토큰을 격납
        while (tokenizer.hasMoreTokens()) {
            strNextToken = tokenizer.nextToken();
            strNewNum += strNextToken;
        }

        return strNewNum;

    }

    /**
     * カンマをつける

     *콤마를 붙인다
     * @param strNum
     * @return
     */
    public static String numFormat(String strNum) throws Exception{

        //戻り値格納用(編集後数値)  반환값 격납용(편집 후 수치)
        String strNewNum = Constant.EMPTY_STR;

        //マイナスフラグ(-(マイナス)記号存在有無)

       //마이너스 플래그(-(마이너스) 기호 존재 유무)
        boolean blnMinus = false;

        // 文字列がnullだったら修了  문자열이 null라면 수료
        if (strNum == null || strNum.length() == 0) {
            strNewNum = null;
        } else {
            strNum = strNum.trim();
           
            if (strNum.substring(0, 1).equals(Constant.MINUS)) {
                strNum = strNum.substring(1, strNum.length());
                blnMinus = true;
            }

            //４桁目、７桁目、１０桁目にカンマを挿入する

           //4자리수째, 7자리수째, 10 자리수째에 콤마를 삽입한다
            // int型なので10桁までを考えればよい

           //int형이므로 10 자리수까지를 생각하면 좋다
            for (int i = 0; i < strNum.length(); i++) {
                // ほかでは使用しないため例外的にマジックナンバー可

               //외에서는 사용하지 않기 때문에 예외적으로 magic number-가능
                if (((strNum.length() - i) == 4)
                        || ((strNum.length() - i) == 7)
                        || ((strNum.length() - i) == 10)) {
                    strNewNum += strNum.substring(i, i + 1) + Constant.COMMA;
                } else {
                    strNewNum += strNum.substring(i, i + 1);
                }
            }
        }

        //マイナス判定 마이너스 판정
        if (blnMinus == true) {
            return Constant.MINUS + strNewNum;
        } else {
            return strNewNum;
        }
    }
   
    /**
     * 文字列のバイト数チェック
     *
     * 指定したサイズより長ければfalse

     *지정한 사이즈보다 길면 false
     * @param str
     * @param byteSize バイト数
     * @return
     */
    public static boolean chkLength(String str, int byteSize) throws Exception{
       
        // 文字列がnullもしくは空文字の場合は正常終了

       //문자열이 null 혹은 공문자의 경우는 정상 종료
        if(str == null || Constant.EMPTY_STR.equals(str)){
            return true;
        }
       
        // 文字列のバイト数取得  문자열의 아르바이트수취득
        int len = str.getBytes("Windows-31J").length;
       
        // 文字列がサイズより長いかチェック  문자열이 사이즈보다 긴가 체크
        if(len > byteSize){
            return false;
        }
        return true;
    }
   
    /**
     * From,Toの相関チュック
     * From,To의 상관 체크
     * FromよりToのほうが大きな数値であればfalse

     *From보다 To 쪽이 큰 수치이면 false

     * @param from
     * @param to
     * @return
     */
    public static boolean chkFromTo(String from, String to) throws Exception{
       
        // 数値チェック  수치 체크
        if(!chkNum(from) || !chkNum(to)){
            // どちらかが数値でない  어느 쪽인지가 수치가 아니다
            return false;
        }
       
        // FROMとTOを数値に変換  FROM와 TO를 수치에 변환
        int nFrom = Integer.parseInt(from);
        int nTo = Integer.parseInt(to);
       
        // FromよりToが大きいのはfalse
        if(nFrom < nTo){
            return false;
        }
       
        return true;
    }

    /**
     * 半角カナチェック
     * 반각 가나 체크
     * 文字列に半角カナが含まれていればfalse

     *문자열에 반각 가나가 포함되어 있으면 false
     * @param str
     * @return
     */
    public static boolean chkHanKana(String str) throws Exception{
       
        if (str == null || str.length() == 0)
            return true;

        StringBuffer wkStr = new StringBuffer(str); // 変換バッファ
        for (int i = 0; i < wkStr.length(); i++) {

            // 半角カナ範囲(Unicode 0xFF61 ～ 0xFF9F)確認
            if (wkStr.charAt(i) >= 0xFF61 && wkStr.charAt(i) <= 0xFF9F) {
                return false;
            }
        }
        return true;
    }

   
    /**
     * コードテーブルからキーで該当するコードのリストを取得する

     *코드 테이블에서 키로 해당하는 코드의 리스트를 취득한다
     * @param key
     * @return
     * @throws Exception
     */
    public static List getCdBeans(String key) throws Exception {
        return _utilLogic.getCdBeans(key, false);
    }
   
    /**
     * コードテーブルからキーで該当するコードのリストを取得し、

     *코드 테이블에서 키로 해당하는 코드의 리스트를 취득해
     * その中から必要なコードのものだけのリストを取得する
     * 그 중에서 필요한 코드의 것만의 리스트를 취득한다
     * @param key
     * @param selectList
     * @return List
     * @throws Exception
     */
    public static List getCdBeansSelection(String key, List selectList) throws Exception {
       
        List resList = new ArrayList();
       
        // キーでコードのリスト取得   키로 코드의 리스트 취득
        List cdList = getCdBeans(key);
       
        for(int cdCnt = 0; cdCnt < cdList.size(); cdCnt++){
           
            CdBean bean = (CdBean)cdList.get(cdCnt);
           
            // リストの1番目(空白)は無条件に追加

           //리스트의 1번째 (공백)는 무조건 추가
            if(cdCnt == 0){
                resList.add(bean);
            }

            for(int selectCnt = 0; selectCnt < selectList.size(); selectCnt++){
               
                String selectCd = (String)selectList.get(selectCnt);
               
               
               
                // 選択したコードとテーブルから取得したコードが等しければリストに追加

               //선택한 코드와 테이블에서 취득한 코드가 동일하면 리스트에 추가
                if(bean.getValue().equals(selectCd)){
                   
                    resList.add(bean);
                }
               
            }
        }
       
        return resList;
    }
   
    /**
     * コードテーブルからキーで該当するコードのリストを取得する(not null 項目用)

     *코드 테이블에서 키로 해당하는 코드의 리스트를 취득한다(not null 항목용)
     * @param key
     * @return
     * @throws Exception
     */
    public static List getCdBeansNotNull(String key) throws Exception {
        return _utilLogic.getCdBeans(key, true);
    }
   
    /**
     * コードテーブルからキーで該当するコードのリストを取得し、

     *코드 테이블에서 키로 해당하는 코드의 리스트를 취득해,
     * その中から必要なコードのものだけのリストを取得する(not null 項目用)

     *그 중에서 필요한 코드의 것만의 리스트를 취득한다(not null 항목용)
     *
     * @param key
     * @param selectList
     * @return List
     * @throws Exception
     */
    public static List getCdBeansSelectionNotNull(String key, List selectList) throws Exception {
       
        List resList = new ArrayList();
       
        // キーでコードのリスト取得
        List cdList = getCdBeansNotNull(key);
       
        for(int cdCnt = 0; cdCnt < cdList.size(); cdCnt++){
           
            CdBean bean = (CdBean)cdList.get(cdCnt);

            for(int selectCnt = 0; selectCnt < selectList.size(); selectCnt++){
               
                String selectCd = (String)selectList.get(selectCnt);

                // 選択したコードとテーブルから取得したコードが等しければリストに追加

               //선택한 코드와 테이블에서 취득한 코드가 동일하면 리스트에 추가
                if(bean.getValue().equals(selectCd)){
                   
                    resList.add(bean);
                }
               
            }
        }
       
        return resList;
    }
   
    /**
     * 名称テーブルからキーで該当する名称のリストを取得する

     *명칭 테이블에서 키로 해당하는 명칭의 리스트를 취득한다
     * @param key
     * @return
     * @throws Exception
     */
    public static List getMeishoBeans(String key) throws Exception {
        return _utilLogic.getMeishoBeans(key, false);
    }
   
    /**
     * 名称テーブルからキーで該当する名称のリストを取得し、

     *명칭 테이블에서 키로 해당하는 명칭의 리스트를 취득해
     * その中から必要な名称のものだけのリストを取得する
     * 그 중에서 필요한 명칭의 것만의 리스트를 취득한다
     * @param key
     * @param selectList
     * @return List
     * @throws Exception
     */
    public static List getMeishoBeansSelection(String key, List selectList) throws Exception {
       
        List resList = new ArrayList();
       
        // キーで名称のリスト取得  키로 명칭의 리스트 취득
        List meiList = getMeishoBeans(key);
       
        for(int meiCnt = 0; meiCnt < meiList.size(); meiCnt++){
           
            CdBean bean = (CdBean)meiList.get(meiCnt);
           
            // リストの1番目(空白)は無条件に追加

           // 리스트의 1번째 (공백)는 무조건 추가
            if(meiCnt == 0){
                resList.add(bean);
            }

            for(int selectCnt = 0; selectCnt < selectList.size(); selectCnt++){
               
                String selectCd = (String)selectList.get(selectCnt);

                // 選択した名称とテーブルから取得した名称が等しければリストに追加

               //선택한 명칭과 테이블에서 취득한 명칭이 동일하면 리스트에 추가
                if(bean.getValue().equals(selectCd)){
                   
                    resList.add(bean);
                }
               
            }
        }
       
        return resList;
    }
   
    /**
     * 名称テーブルからキーで該当する名称のリストを取得する(not null 項目用)

     *명칭 테이블에서 키로 해당하는 명칭의 리스트를 취득한다(not null 항목용)
     * @param key
     * @return
     * @throws Exception
     */
    public static List getMeishoBeansNotNull(String key) throws Exception {
        return _utilLogic.getMeishoBeans(key, true);
    }
   
    /**
     * 名称テーブルからキーで該当する名称のリストを取得し、

     *명칭 테이블에서 키로 해당하는 명칭의 리스트를 취득해,
     * その中から必要な名称のものだけのリストを取得する(not null 項目用)
     * 그 중에서 필요한 명칭의 것만의 리스트를 취득한다(not null 항목용)
     * @param key
     * @param selectList
     * @return List
     * @throws Exception
     */
    public static List getMeishoBeansSelectionNotNull(String key, List selectList) throws Exception {
       
        List resList = new ArrayList();
       
        // キーで名称のリスト取得
        List meiList = getMeishoBeansNotNull(key);
       
        for(int meiCnt = 0; meiCnt < meiList.size(); meiCnt++){
           
            CdBean bean = (CdBean)meiList.get(meiCnt);
           

            for(int selectCnt = 0; selectCnt < selectList.size(); selectCnt++){
               
                String selectCd = (String)selectList.get(selectCnt);

                // 選択した名称とテーブルから取得した名称が等しければリストに追加

               //선택한 명칭과 테이블에서 취득한 명칭이 동일하면 리스트에 추가
                if(bean.getValue().equals(selectCd)){
                   
                    resList.add(bean);
                }
               
            }
        }
       
        return resList;
    }
   
    /**
     * SYSINFOテーブルから1レコード取得する

     *SYSINFO 테이블에서 1 레코드 취득한다
     * @return
     * @throws Exception
     */
    public static Sysinfo getSysinfo() throws Exception {
        return _utilLogic.getSysinfo();
    }

    /**
     * @param logic _utilLogic を設定。
     */
    public static void set_utilLogic(UtilLogic logic) {
        _utilLogic = logic;
    }
   

 /**
  * YYMMDDの文字列を受け取りCalendarを返す
  * YYMMDD의 문자열을 받아 Calendar를 돌려준다
  * @param myDate
  * @return
  * @throws Exception
  */
 private static Calendar getCalendar(String myDate) throws Exception{
    
        int intYear;
        int intMonth;
        int intDay;

        if (myDate.length() > 3) {
            intYear = java.lang.Integer.parseInt(myDate.substring(0, 4));
        } else {
            intYear = 0;
        }
        if (myDate.length() > 5) {
            intMonth = java.lang.Integer.parseInt(myDate.substring(4, 6));
        } else {
            intMonth = 0;
        }
        if (myDate.length() == 8) {
            intDay = java.lang.Integer.parseInt(myDate.substring(6, 8));
        } else {
            intDay = 0;
        }

        Calendar cal = new GregorianCalendar();
        cal.setLenient(false);
        cal.set(intYear, intMonth - 1, intDay);
       
        return cal;
 }
 
 
 /**
  * 日付妥当性チェック  일자 타당성 체크
  * @param myDate
  * @return
  */
 public static boolean chkDateFormat(String myDate) throws Exception{

     if(myDate == null || Constant.EMPTY_STR.equals(myDate)){
         return true;
     }
    
     // 文字列にスラッシュが入っていた場合消す

    // 문자열에 slash가 들어가 있었을 경우 지운다
     myDate = deleteSlash(myDate);
    
        //入力文字列が８桁以外の場合エラ-

       // 입력 문자열이 8자리수 이외의 경우 에러
     
        if (myDate.length() != 8) {
            return false;
        }

        for (int i = 0; i < myDate.length(); i++) {
            char charData = myDate.charAt(i);
            if ((charData < '0') || (charData > '9')) {
                return false;
            }
        }
 
        Calendar cal = new GregorianCalendar();
       
        cal = getCalendar(myDate);

        try {
            java.util.Date ud = cal.getTime();
        } catch (IllegalArgumentException iae) {
            return false;
        }

        return true;

    }
 
 /**
  * 日付の大小チェック
  * @param from
  * @param to
  * @return toがfromより大きければtrue そうでなければfalse
  * @throws Exception
  */
 public static boolean chkDateFromTo(String from, String to) throws Exception{
    
     // 文字列にスラッシュが入っていた場合消す

    //문자열에 slash가 들어가 있었을 경우 지운다
     from = deleteSlash(from);
     to = deleteSlash(to);
    
     // 日付のフォーマットが正しくなければ終了

    //일자의 포맷이 올바르지 않으면 종료
     if(!chkDateFormat(from) || !chkDateFormat(to)){
         return true;
     }
    
     // どちらかがnull なら終了
     if(from == null || Constant.EMPTY_STR.equals(from.trim())
             || to == null || Constant.EMPTY_STR.equals(to.trim())){
         return true;
     }
    
        Calendar calFrom = new GregorianCalendar();
        Calendar calTo = new GregorianCalendar();
       
        calFrom = getCalendar(from);
        calTo = getCalendar(to);
    
        // 比較
        return !calFrom.after(calTo);
 }
 
    /**
     * スラッシュをつける

     *slash를 붙인다
     * @param strNum
     * @return
     */
    public static String dateFormat(String strYmd) throws Exception{

        //戻り値格納用  반환값 격납용
        String strNewYmd = Constant.EMPTY_STR;

        // 文字列がnullだったら修了
        if (strYmd == null || strYmd.length() == 0) {
            strNewYmd = null;
        // 日付のフォーマットでなければnullを返して終了

       //일자의 포맷이 아니면 null를 돌려주어 종료
        } else if(!chkDateFormat(strYmd)){
            strNewYmd = null;
        } else {

            //3桁目、6桁目にスラッシュを挿入する
            strNewYmd =  strYmd.substring(0, 4) + Constant.SLASH + strYmd.substring(4, 6) +
                        Constant.SLASH + strYmd.substring(6, 8);

        }
        return strNewYmd;

    }

    /**
     * 文字列からスラッシュ削除  문자열로부터 slash 삭제
     * @param strNum
     * @return
     */
    public static String deleteSlash(String strDate) throws Exception{

        if(strDate == null){
            return null;
        }
       
        //トークン格納用  토큰 격납용
        String strNextToken = Constant.EMPTY_STR;

        //戻り値格納用  반환값 격납용
        String strNewNum = Constant.EMPTY_STR;

        StringTokenizer tokenizer = new StringTokenizer(strDate, Constant.SLASH);

        //トークンが存在する間ループし変数にトークンを格納

       //토큰이 존재하는 동안 루프 해 변수에 토큰을 격납
        while (tokenizer.hasMoreTokens()) {
            strNextToken = tokenizer.nextToken();
            strNewNum += strNextToken;
        }

        return strNewNum;

    }
   
    /**
     * 消費税を計算する

    *소비세를 계산한다
     * @param num
     * @return
     * @throws Exception
     */
    public static String taxCalc(String num) throws Exception{
       
        double tax;  // 消費税  소비세
        double amount; // 税込価格 세금 포함 가격
       
        if(num == null || Constant.EMPTY_STR.equals(num)){
            return null;
        }
       
        num = deleteComma(num);
       
        // 文字列が半角数字であるかチェック

       //문자렬이 반각 숫자일까 체크
        if(!chkNum(num)){
            return null;
        }

        // 消費税取得  소비세 취득
        Sysinfo sysinfo = _utilLogic.getSysinfo();
        tax = sysinfo.getTaxRate().doubleValue() / 100;
       
        amount = Integer.parseInt(num) * tax + Integer.parseInt(num);
       
        int i = (int)amount;
        return String.valueOf(i);
      
    }
   
   
   
    /**
     * 消費税計算をして表示用文言にフォーマットする

     *소비세 계산을 해 표시용 문언에 포맷 한다
     * @param num
     * @return
     * @throws Exception
     */
    public static String setTax(BigDecimal num) throws Exception{
     // 消費税計算  소비세 계산
        String taxStr = null;
       
        // 消費税計算とカンマづけを行う。소비세 계산과 콤마 지어를 실시한다.
        taxStr = Common.numFormat(Common.taxCalc(bigDecimalToStr(num)));
       
     // 結果nullでなければヘッダフッタを付加

    //결과 null가 아니면 헤더 footer를 부가
        if(taxStr != null){
            taxStr = Constant.TAX_HEADER + taxStr + Constant.TAX_FOOTER;
        }

     return taxStr;
       
    }

    /**
     * 消費税計算をして表示用文言にフォーマットする(引数String用)

     *소비세 계산을 해 표시용 문언에 포맷 한다(인수 String용)
     * @param num
     * @return
     * @throws Exception
     */
    public static String setTaxStr(String num) throws Exception{
     // 消費税計算
        String taxStr = null;
       
        // 消費税計算とカンマづけを行う。소비세 계산과 콤마 지어를 실시한다.
        taxStr = Common.numFormat(Common.taxCalc(num));
       
     // 結果nullでなければヘッダフッタを付加

     //결과 null가 아니면 헤더 footer를 부가
        if(chkNull(taxStr)){
            taxStr = Constant.TAX_HEADER + taxStr + Constant.TAX_FOOTER;
        } else {
            taxStr = Constant.EMPTY_STR;
        }

     return taxStr;
       
    }
   
    /**
     * BigDecimalをStringに変換する  (으)로 변환한다
     * @param num
     * @return
     */
    public static String bigDecimalToStr(BigDecimal num) throws Exception{
     
     if(num == null){
      return null;
     } else {
      return num.toString();
     }     
    }
   
 /**
  * 文字列型をBigdecimalに変換する 문자열형을 Bigdecimal로 변환한다
  * @param str
  * @return BigDecimal
  */
 public static BigDecimal strToBigDec(String str) throws Exception{
 
  if(str == null || Constant.EMPTY_STR.equals(str.trim()) ||
          !Common.chkNum(str)){
   return null;
  } else {
   
   return new BigDecimal(str);
  }
 
 }
 
 /**
  * StringをBigDecimal型に変換する
  * String를 BigDecimal형으로 변환한다
  * null, "", 数値以外の場合は0を返す
  * null, "", 수치 이외의 경우는 0을 돌려준다
  * @param str
  * @return
  * @throws Exception
  */
 public static BigDecimal strToBigDecNotNull(String str) throws Exception{
  if(str == null || Constant.EMPTY_STR.equals(str.trim()) ||
          !Common.chkNum(str)){
   return new BigDecimal(0);
  } else {
   
   return new BigDecimal(str);
  }
    
 }
 
 /**
  * 空文字だったらnullを返す  공문자라면 null를 돌려준다
  * @param String
  * @return String
  */
 public static String getEmptyOrStr(String str) throws Exception{
 
  if(str == null || Constant.EMPTY_STR.equals(str)){
   return null;
  } else{
   return str;
  }
 }
 
 /**
  * 空文字だったらnullを返す  공문자라면 null를 돌려준다
  * @param bigdecimal
  * @return String
  */
 public static BigDecimal getEmptyOrNumber(BigDecimal num) throws Exception{
 
  if(num == null || Constant.EMPTY_STR.equals(num)){
   return null;
  } else{
   return num;
  }
 }
 
 /**
  * 改行コードを＜BR>に変換する

  *개행 코드를＜BR>로 변환한다
  * @param str
  * @return
  */
 public static String replaceLF(String str){
    
     if(str == null || str.trim().equals(Constant.EMPTY_STR)){
         return null;
     }
    
     return str.replaceAll("\n", "<BR>");
 }
 
 /**
  * コード名を取得する
  * @param cdKey
  * @param cd
  * @return
  * @throws Exception
  */
 public static String getCdNm(String cdKey, String cd) throws Exception{
    
     CdTbl cdTbl = _utilLogic.getCdTbl(cdKey, cd);
    
     if(cdTbl == null){
         return null;
     } else {
         return cdTbl.getCdNm();
     }
 }
 
 /**
  * 名称名を取得する  명칭명을 취득한다
  * @param nmKbn
  * @param nmCd
  * @return
  * @throws Exception
  */
 public static String getMeishoNm(String nmKbn, String nmCd) throws Exception{
    
     Meisho meisho = _utilLogic.getMeisho(nmKbn, nmCd);
    
     if(meisho == null){
         return null;
     } else {
         return meisho.getName();
     }
 }
 
 /**
  * 全角チェック  전각 체크
  * 全角以外が入っていたらfalse 全部全角ならtrue

  *전각 이외가 들어가 있으면 false 전부 전각이라면 true
  * @param inStr
  * @return
  */
    public static boolean chkZenkaku(String inStr){
       
        if (inStr == null || inStr.length() == 0) {
            return true;
        }

        byte[] bytData;
        String strChar;
        boolean flgSingle = false;
        int intX;
        for (int i = 0; i < inStr.length(); i++) {
            try {
                strChar = inStr.substring(i, i + 1);
                bytData = strChar.getBytes("Windows-31J");
                for (int j = 0; j < bytData.length; j++) {
                    if (bytData[j] < 0) {
                        intX = 256 + bytData[j];

                    } else {
                        intX = bytData[j];
                    }
                }
                if (bytData.length == 2) {

                } else {
                    flgSingle = true;
                }
            } catch (Exception e) {
                flgSingle = false;
            }
        }

        if (flgSingle)
            return false;
        else
            return true;
    }

   
    /**
     * 検索上限チェック
     * 검색 상한 체크
     * システム限界数以上に設定していたらfalseを返す

     *시스템 한계수이상으로 설정해 있으면 false를 돌려준다
     * @param maxSize
     * @return true:システム上限内, null, 半角整数以外
     *    false:システム上限オーバー
     * @throws Exception
     */
    public static boolean chkMaxSearchNum(String maxSize) throws Exception{
      
       int maxNum;
       int sysMaxNum;
      
       if(!chkNull(maxSize)){
          
           return true;
       }
      
       // 半角数値チェック  반각 수치 체크
       if(!chkPositiveInteger(maxSize)){
          
           return true;
       }
      
       // システム的な最大件数  시스템적인 최대 건수
       sysMaxNum = Constant.SYS_MAS_SEARCH_NUMBER;
       // 入力された最大件数  입력된 최대 건수
       maxNum = Integer.parseInt(maxSize);
       // システム限界数より大きければfalse

      //시스템 한계수보다 크면 false
       if(maxNum > sysMaxNum){
           return false;
       }
       return true;
      
   }

    /**
     * 和暦チェック
     * 일본이 달력 체크
     * @param nengo 1:明治,2:大正,3:昭和,4:平成

     *1:메이지,2:타이쇼,3:쇼와,4:헤세이
     * @param date
     * @return
     * @throws Exception
     */
    public static boolean chkWaDate(String nengo, String date) throws Exception{
       
        boolean result = true;
       
        String nen;  // 年
        String tsuki;   // 月
        String niti;    // 日
        int intNen;
        int intTsuki;
        int intNiti;
        String seireki;  // 西暦
       
       
        // 桁数チェック(6バイトYYMMDD) 자리수 체크(6바이트 YYMMDD)
        if(date.length() != 6){
           
            return false;
        }
        // 数値チェック  수치 체크
        if(!chkPositiveInteger(date)){
           
            return false;
        }
        // 年、月、日を取得
        nen = date.substring(0, 2);
        tsuki = date.substring(2, 4);
        niti = date.substring(4, 6);
       
        // それぞれをintに変換 각각을 int에 변환
        intNen = Integer.parseInt(nen);
        intTsuki = Integer.parseInt(tsuki);
        intNiti = Integer.parseInt(niti);

        // 日付フォーマット通りの場合は各年号ごとに年月日をチェック

       //일자 포맷 그대로의 경우는 매년호 마다 연월일을 체크
        // 明治  메이지
        if(Constant.NENGO_MEIJI.equals(nengo)){
           
            // 45年を超える場合はありえない

           //45년을 넘는 경우는 있을 수 없다
            if(intNen > 45){
               
                return false;

            // 45年の場合は7月30日まで
            } else if(intNen == 45){
               
                if(intTsuki > 7){
                   
                    return false;
                } else if(intTsuki == 7){
                   
                    if(intNiti > 30){
                       
                        return false;
                    }
                   
                }
            // 1年の場合は9月8日から
            } else if(intNen == 1){
               
                if(intTsuki < 9){
                   
                    return false;
                } else if(intTsuki == 9){
                   
                    if(intNiti < 8){
                       
                        return false;
                    }
                }
            }
           
            // 西暦に変換
            seireki = String.valueOf(intNen + WAREKI_SA_MEIJI);
            seireki = seireki + tsuki + niti;
           
            if(!chkDateFormat(seireki)){
               
                return false;
            }
           
           
        // 大正
        } else if(Constant.NENGO_TAISHO.equals(nengo)){
           
            // 15年を超える場合はありえない
            if(intNen > 15){
               
                return false;
            // 15年の場合は12月25日まで
            } else if(intNen == 15){
               
                if(intTsuki > 12){
                   
                    return false;
                } else if(intTsuki == 12){
                   
                    if(intNiti > 25){
                        return false;
                    }
                }
            }
            // 1年の場合は7月30日から
            else if(intNen == 1){
               
                if(intTsuki < 7){
                    return false;
                } else if(intTsuki == 7){
                   
                    if(intNiti < 30){
                       
                        return false;
                    }
                }
            }
           
            // 西暦に変換
            seireki = String.valueOf(intNen + WAREKI_SA_TAISHO);
            seireki = seireki + tsuki + niti;
           
            if(!chkDateFormat(seireki)){
               
                return false;
            }
           
        // 昭和
        } else if(Constant.NENGO_SHOWA.equals(nengo)){
        
            // 64年の1月7日まで
            if(intNen > 67){
               
                return false;
            } else if(intNen == 64){
               
                if(intTsuki > 1){
                    return false;
                } else if(intTsuki == 1){
                   
                    if(intNiti > 7){
                        return false;
                    }
                }
            }
            // 1年は12月25日から
            if(intNen == 1){
               
                if(intTsuki < 12){
                   
                    return false;
                } else if(intTsuki == 12){
                   
                    if(intNiti < 25){
                        return false;
                    }
                }
            }
           
            // 西暦に変換
            seireki = String.valueOf(intNen + WAREKI_SA_SHOWA);
            seireki = seireki + tsuki + niti;
           
            if(!chkDateFormat(seireki)){
               
                return false;
            }
       
        // 平成
        } else if(Constant.NENGO_HEISEI.equals(nengo)){
           
            // 1年は1月8日から
            if(intNen == 1){
               
                if(intTsuki == 1){
                   
                    if(intNiti < 8){
                        return false;
                    }
                }
            }
           
            // 西暦に変換
            seireki = String.valueOf(intNen + WAREKI_SA_HEISEI);
            seireki = seireki + tsuki + niti;
           
            if(!chkDateFormat(seireki)){
               
                return false;
            }
        // それ以外の年号
        } else {
            return false;
        }
       
        // 現在日付よりも未来であればエラー
        if(!chkComparisonDate(seireki)){
            return false;
        }
       
       
        return result;
    }
   

   
    /**
     * 現在日付との比較
     * 현재 일자라는 비교
     * 現在日付よりも未来の日付であればfalseを返す

     *현재 일자보다 미래의 일자이면 false를 돌려준다
     * @param date
     * @return
     * @throws Exception
     */
    public static boolean chkComparisonDate(String date) throws Exception{
       
        String sysDateStr;
       
        // 日付妥当性チェック  일자 타당성 체크
        if(!chkDateFormat(date)){
           
            return false;
        }
       
        // 現在年月日取得
        Date sysDate = DateUtil.getSysdate();
     
        // SimpleDateFormatオブジェクトを生成

       //SimpleDateFormat 오브젝트를 생성
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
        sysDateStr = formatter.format(sysDate);
       
        // 日付の相関チェック呼び出し  일자의 상관 체크 호출
        if(!chkDateFromTo(date, sysDateStr)){
            return false;
        }
       
        return true;
    }

 /**
  * 日付妥当性チェック(YYYYMMの場合)

   *일자 타당성 체크(YYYYMM의 경우)
  * @param myDate
  * @return
  */
 public static boolean chkDateFormatYYYYMM(String myDate) throws Exception{

     String nen;
     String tuki;
     int intNen;
     int intTuki;
    
    
     if(myDate == null || Constant.EMPTY_STR.equals(myDate)){
         return true;
     }
    
     // 文字列にスラッシュが入っていた場合消す

     //문자열에 slash가 들어가 있었을 경우 지운다
     myDate = deleteSlash(myDate);
    
        //入力文字列が6桁以外の場合エラ-

       //입력 문자열이 6자리수 이외의 경우 에러
        if (myDate.length() != 6) {
            return false;
        }

        // 数字のみで構成されているかチェック

       //숫자만으로 구성되어 있을까 체크
        for (int i = 0; i < myDate.length(); i++) {
            char charData = myDate.charAt(i);
            if ((charData < '0') || (charData > '9')) {
                return false;
            }
        }
 
        // 年、月部分を取り出し  해, 달부분을 꺼내
        nen = myDate.substring(0,4);
        tuki = myDate.substring(4, 6);
       
        // 月部分をintに変換し、1から12の間であるかチェック

        //달부분을 int로 변환해, 1에서 12의 사이일까 체크
        intTuki = Integer.parseInt(tuki);
        if(intTuki < 1 || intTuki > 12){
           
            return false;
        }

        return true;

    }
 
 /**
  * 日付の大小チェック(YYYYMMの場合) 일자의 대소 체크(YYYYMM의 경우)
  * @param from
  * @param to
  * @return toがfromより大きければtrue そうでなければfalse 同じ場合はtrue
  * @throws Exception
  */
 public static boolean chkDateFromToYYYYMM(String from, String to) throws Exception{
    
     int intFrom;
     int intTo;
    
     // 文字列にスラッシュが入っていた場合消す

    //문자열에 slash가 들어가 있었을 경우 지운다
     from = deleteSlash(from);
     to = deleteSlash(to);
    
     // 日付のフォーマットが正しくなければ終了

    //일자의 포맷이 올바르지 않으면 종료
     if(!chkDateFormatYYYYMM(from) || !chkDateFormatYYYYMM(to)){
         return true;
     }
    
     // どちらかがnull なら終了
     if(!chkNull(from) || !chkNull(to)){
         return true;
     }
    
    
        // 年、月部分を取り出し  해, 달부분을 꺼내
     intFrom = Integer.parseInt(from);
     intTo = Integer.parseInt(to);
       
     // toよりfromのほうが先であればfalse

    //to보다 from 쪽이 앞이면 false
     if(intFrom > intTo){
         return false;
     }
       
     return true;
 }
 
    /**
     * スラッシュをつけるYYYYMM  slash를 붙이는 YYYYMM
     * @param strNum
     * @return
     */
    public static String dateFormatYYYYMM(String strYmd) throws Exception{

        //戻り値格納用  반환값 격납용
        String strNewYmd = Constant.EMPTY_STR;

        // 文字列がnullだったら終了
        if (strYmd == null || strYmd.length() == 0) {
            strNewYmd = null;
        // 日付のフォーマットでなければnullを返して終了

       //일자의 포맷이 아니면 null를 돌려주어 종료
        } else if(!chkDateFormatYYYYMM(strYmd)){
            strNewYmd = null;
        } else {

            //3桁目、6桁目にスラッシュを挿入する
            strNewYmd =  strYmd.substring(0, 4) + Constant.SLASH + strYmd.substring(4, 6);
//            //3桁目、6桁目にスラッシュを挿入する
//            strNewYmd =  strYmd.substring(0, 4) + Constant.SLASH + strYmd.substring(4, 6) +
//                        Constant.SLASH + strYmd.substring(6, 8);

        }
        return strNewYmd;

    }
   
   
    /**
     * application.propertiesのメッセージをキーにより取得する

     *application.properties의 메세지를 키에 의해 취득한다
     * @param key メッセージのキー
     * @return String メッセージ
     * @throws Exception
     */
    public static String getMessage(String key) throws Exception {
       
        ResourceBundle bundle = ResourceBundle.getBundle(Constant.MESSAGE_FILE_NAME);
        return bundle.getString(key);
    }
   
    /**
     * 文字列From,Toを比較する  문자열 From,To를 비교한다
     *
     * 辞書順で比較し、FromがToより大きければfalse

     *사전순서로 비교해, From가 To보다 크면 false
     * 同じ、もしくはFrom < To ならばtrue
     * @param from
     * @param to
     * @return
     * @throws Exception
     */
 public static boolean chkCdFromTo(String from, String to) throws Exception{
    
     // どちらかがnullだったらtrueで強制終了

    //어느 쪽인지가 null라면 true로 강제 종료
     if(!Common.chkNull(from) || !Common.chkNull(to)){
         return true;
     }
    
     // from > toだったらfalse
     if(0 < from.trim().compareTo(to.trim())) {
         return false;
     }
     return true;
    
 }
 
 
 
 /**
  * 整数チェック  정수 체크
  * @param iStr
  * @return　true：正の整数,負の整数　false:整数以外

  *정의 정수, 부의 정수　false:정수 이외
  * @throws Exception
  */
 public static boolean chkInt(String iStr) throws Exception{
 
  if(!Common.chkNull(iStr)){
         return false;
     }

  if(iStr.indexOf(Constant.MINUS) != 0) return Common.chkPositiveInt(iStr.substring(0));
 
  return Common.chkPositiveInt(iStr.substring(1));
 
 
 }