/**
  * コード類をフォーマット
  *
  * 与えられたサイズに足りない場合は空白を入れてフォーマットする
  * @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));
 
 
 }

 //全角チェック
 public static boolean isFullWord(String i_strContents)
 {
  boolean value = true; 
  byte[] byteArray = null;
         byteArray = i_strContents.getBytes();
         for(int i = 0; i < byteArray.length; i++)
         {
             if((byteArray[i] >= (byte)0x81 && byteArray[i] <= (byte)0x9f) ||
                 (byteArray[i] >= (byte)0xe0 && byteArray[i] <= (byte)0xef))
             {
                 if((byteArray[i+1] >= (byte)0x40 && byteArray[i+1] <= (byte)0x7e) ||
                     (byteArray[i+1] >= (byte)0x80 && byteArray[i+1] <= (byte)0xfc))
                 {
                     i++;
                 }
                 else
                 {
                     value = false;
                 }
             }
             else
             {
                 value = false;
             }
         }
         return value;

 }
 //半角チェック
 public static boolean isHalfWord(String i_strContents)
 {
  boolean value = true;
  byte[] byteArray = null;
        byteArray = i_strContents.getBytes();
        for(int i = 0; i < byteArray.length; i++){
            if((byteArray[i] >= (byte)0x81 && byteArray[i] <= (byte)0x9f) ||
                (byteArray[i] >= (byte)0xe0 && byteArray[i] <= (byte)0xef)) {
                if((byteArray[i+1] >= (byte)0x40 && byteArray[i+1] <= (byte)0x7e) ||
                    (byteArray[i+1] >= (byte)0x80 && byteArray[i+1] <= (byte)0xfc)) {
                    value = true;
                }
            }
        }
        return value;

 }

  //名前の全角を検査します。
 public static boolean checkNameFormat(String i_strContents)
 {
  boolean bResult = (!i_strContents.equals("")&&Validation.isFullWord(i_strContents));
  return bResult;
 }

 //点数と人数の半角を検査します
 public static boolean checkPointFormat(String i_strContents)
 {
  boolean bResult = true;
  int iContents;

  //半角の時
  if(!i_strContents.equals("")&&!Validation.isFullWord(i_strContents))
  {
   iContents = Integer.parseInt(i_strContents);
   //0点から100点以内
   if((iContents < 0) || (iContents > 100))
   {
    bResult = false;
   }
  }
  else
  {
   bResult = false;
  }
  return bResult;
 
 }
Validation 체크시 전각을하던 반각을 하던 위의 하나의 메소드를 이용하여 true이면 false로 구분하여
사용하면 한개의 메소드로도 충분히 구현이 가능함

##다른방법으로 전각을 체크하는거

 //全角チェック
 public static boolean isFullWord2(String i_strContents)
 {
  boolean value = true;
  //入力もらた文字の長さ
  for (int i = 0; i < i_strContents.length(); ++i)
  {
         //文字を一つ一つチェックします
   int c = i_strContents.charAt(i);       
   //全角の条件
   if (c < 256 || (c >= 0xff61 && c <= 0xff9f))
         {
           value = false;
         }
      }
      return value;
 }

Bubble Sort Algorithm

Click on the applet below to see the algorithm run.

/*
 * @(#)BubbleSortAlgorithm.java	1.6f 95/01/31 James Gosling
 *
 * Copyright (c) 1994-1996 Sun Microsystems, Inc. All Rights Reserved.
 *
 * See additional copyright information below.
 *
 *
 * A bubble sort demonstration algorithm based on
 * SortAlgorithm.java and
 * SortItem.java.
 *
 * @author James Gosling
 * modified by Alyce Brady
 * @version 	1.6f, 31 Jan 1995
 */

class BubbleSortAlgorithm extends SortAlgorithm {
    void sort(int a[]) throws Exception
    {
	// Loop through the array, comparing adjacent items.  If they
	// are in the wrong order with respect to each other, they are
	// swapped.  In each pass, the next smallest item "bubbles" all
	// the way to the top.
	for (int i = 0; i < a.length; i++)
	    for (int j = a.length-1; j > i; j--)
	    {	if (stopRequested)
		    return;
		if (a[j-1] > a[j])
		{   int T = a[j-1];
		    a[j-1] = a[j];
		    a[j] = T;
		}
		pause(i,j);
	    }
	
    }
}

/*
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
 * without fee is hereby granted. 
 * Please refer to the file http://java.sun.com/copy_trademarks.html
 * for further important copyright and trademark information and to
 * http://java.sun.com/licensing.html for further important licensing
 * information for the Java (tm) Technology.
 * 
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 * 
 * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
 * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
 * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
 * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
 * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
 * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
 * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  SUN
 * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
 * HIGH RISK ACTIVITIES.
 */

죽음이야(돼는 일이 하나도 없을때..)
-しんでる

참견하지마
-くちを ださないで

봐줬다.
-おおめに みて やった．

당했어...
-やられた

죽여버릴꺼야!!
-ぶっころす

당장꺼져!!
-とっと うせろ!

됐어!!(뭔가를 해내었을때)
-やった!

쪽팔려
-はずかしい

* ほんと最惡． / ついてないわね． 재수없어 정말!

*本末轉倒(ほんまつてんとう)ですね． 배보다 배꼽.

*大目(おおめ)に見て下さい． 잘 봐주세요.

*いったい何樣(なにさま)のつもり．잘났어 정말!

*この身の程(ほど)しらずが． 주제를 알아야지.

*ケバイだ． 야시꾸리하다.

*いけてる-!． 킹카다.

*あきれる． 황당하다.

*いったい何樣(なにさま)だ．개판오분전.

*あきれてものも言えない．기가 차서 말이 안나온다.

*スネないで機　(きげん)直してよ．꽁하지 말고 기분풀어.

*大きなお世話，余計(よけい)なお世話． 너나 잘해!

*インフルエンザが猛威(もうい)を振(ふ)るんですって． 독감이 극성이래요.

귀찮아
-めんどくさい

~쟁이
- ~ばっかり (例えば : うそばっかり)

아이구 고소해라.
-いい きみだ

비틀대고 있잖아(술을 많이 먹은 사람에게)
-フラフラじゃ ないよ

―감탄의 표현

1 멋지군요 すばらしいですね →(독음) 스바라시데스네
2 멋져! すてき →(독음) 스테키
3 맛있다! おいしい →(독음) 오이시이
4 잘했어 よくやった →(독음) 요쿠얏타
5 정말멋있어 なんとすばらしい →(독음) 난토스바라시
6 정말예쁘죠 なんてきれいなんでしょう →(독음) 난테키레이난데쇼우
7 너무멋있어! とってもすてき →(독음) 톧테모스테키
8 재미있군요! おもしろいですね →(독음) 오모시로이데스네
9 에-,이거대단하군! へえ、これはすごい →(독음) 에-, 코레와스고이
10 우와,멋지다 うわあ、すばらしい →(독음) 우와아,스바라시
11 아름답구나 うつくしいなあ →(독음) 우츠쿠시나아

―놀람의 표현

1 아,깜짝놀랬어 ああ、びっくりした →(독음) 아-,빋쿠리시타
2 그거,놀랍군요 それはおどろきましたね →(독음) 소레와오도로키마시타네
3 야,스즈키 너를만나다니 놀랍군 やあ、すずき、きみにあうとはあどろいたね
→(독음) 야 아,스즈키,키미니아우토와오도로이타네
4 놀라게 하지말하요 びっくりさせないでよ →(독음) 빋쿠리사세나이데요
5 어, 어 おや、おや →(독음) 오야,오야 (뜻밖의일에 놀라서 내는말로 우리말의 〃어,어마〃에 해당한다)
6 어머,어머 あら、まあ →(독음) 아라,마아 (놀랐을때에 내는소리로 주로 여성들이 많이 쓴다. 〃어머나,아아〃)
7 어, 어떻게아니? おや、どしてわかるの →(독음) 오야,도시테와카루노
8 이거 참 놀랬어요 これはこれは、おどろきましたね →(독음) 코레와코레와,오도로키마시타네 (놀라거나 실패함을 깨달았을때 하는 소리 〃아차〃
9 두렵군 おそろしいね →(독음) 오소로시이네
10 무섭다 こわい →(독음) 코와이
11 어이없군 あきれたね →(독음) 아키레타네
12 저건 도대체 뭐야? あれはいったいなんだ →(독음) 아레와읻타이난다
13 어, 정말바보같군 おや、なんてばかな →(독음) 오야, 난테바카나
14 어머, 너야? まあ、あなたなの →(독음) 마아,아나타나노
15 깜짝놀랐어! びっくりした →(독음) 빋쿠리시타
16 그거 놀라운데! それはおどろきだ →(독음) 소레와오도로키다
17 기가막혀! あきれた →(독음) 아키레타
18 어머저런! おやおや →(독음) 오야오야
19 에, 뭐라고? え、なんだって →(독음) 에- 난닫테
20 아차! 큰일났다! しまった →(독음) 시맏타 (우리말로 〃아차〃아뿔사〃큰일났다〃에 해당,
21 아니,또야?もう、またなの →(독음) 모우,마타나노

馬鹿（ばか）:가장 흔히(?) 쓰이는 말입니다.님들도 들어본적

              있으시겠죠(??)."바보"란 말입니다만,이거 발음을

              좀 강하게 한다던가 뒤에 "놈"이란 말 더 붙여서리

              심각한(?) 욕을 만들 수 있습니다.

ばか＝＞ぱが＝＞ばかやろう＝ばかめ＝＞ぱがやろう＝ぱがめ

오른 쪽으로 갈 수록 정도가 심해집니다.

*あほ:이거 역시 "바보"."멍청이" 정도로 해석할 수 있습니다.

*まぬけもの:이것도 "바보""멍청이""머저리"정도...

＊おろかもの:이건 보다 어리석음에 강조한 말.

＊やろう、め:둘 다 "놈"이란 뜻으로 명사뒤에 붙여서 자주 씁니다.

＊くそ:직역하면 찌끄러기,쓰레기...등의 뜻입니다만,욕으로도
       쓰이고,혼자말로 "빌어먹을"이라고 할 때도 씁니다.

＊畜生（ちくしょう）:직역하면 축생-짐승...정도의 뜻입니다만,
                     절대 그 정도의 가벼운 욕이 아닙니다.
                     우리말로 "씨팔"정도의 심한 욕에 속합니다.

＊すけべ:여자를 밝히는 남성을 지칭해서 씁니다.
         우리말로 "색광"정도...

＊?態（へんたい）:말 그대로 "변태"

＊くだらない:쓰잘데기 없음,별 볼일 없음...을 지칭합니다만,
             뒤에 명사를 붙여서 "쓰잘데기 없는 ~" 식으로
             자주 쓰입니다.

＊しんじまえ:이것은 しんでしまえ의 줄임말로.말 그대로 "죽어버려"

＊ぶっころす:이건 ころす의 강조형."콱 죽여버린다"..정도.

＊ぶっつぶす:이건 つぶす의 강조형."콱 찌그려뜨린다"...정도.

＊ぶん?る（ぶんなぐる）:이건 ?る의 강조형."줘 패버린다"...정도.

＊くたばれ:이건 くたばる의 명령형."쿠타바루"는 지치셔 널부러지다.
           정도의 뜻입니다만,욕으로 쓰면 "돼져버려"가 되지용.

쿠소(クソ/똥)

보케(ボケ/노망),

마누케(マヌケ/멍청이

키치가이(キチガイ/미치광이)

바카(バカ/바보),

쿠솟타레(クソッタレ/똥싸게)

카스(カス/찌꺼기, 앙금),

고미(ゴミ/쓰레기)

칭카스(チンカス/왕찌꺼기, 왕앙금)

노타린(ノ-タリン/나는 모자라다, 부족하다, 머리가 둔하다)

마에노카쨩데메소(まえのか-ちゃん デベソ)

쿠솟타레(くそったれ/똥싸게)

일본 욕의 종류와 어원

일본어의 욕에는 바카(バカ/바보, 멍청이), 아호(アホ (ウ)/바보, 천치=バカ),

톤마(トンマ/언행이 어딘지 모자람, 얼뜨기, 얼간이),

마누케(マヌケ/얼간이 짓을 함, 멍청이=トンマ),

즈보라(ずぼら/흐리터분 함)

본쿠라(ボンクラ/멍텅구리, 바보, 얼간이=マヌケ),

구우타라(ぐうたら/무시근한, 늘쩡늘쩡한 사람)

 노로마(のろま/굼벵이, 동작이나 머리가 아둔함, 바보),

쿠루쿠루빠(クルクルパ? )

, 오탄코나스(オタンコナス)

, 오탄친(オタンチン),

 오카치멘코(オカチメンコ)

1) 馬鹿/バカ(바카/바보)

2) アホ(아호/바보)

바보라는 말은 관동에서는 바카(バカ),

관서에서는 아호(アホ)라고 하는 이미지가 있고,

동해 지방에서는 타와케(たわけ)라고 한다.

3) ずぼら(즈보라/흐리터분 함)

4) ボンクラ(본쿠라/멍텅구리, 바보, 얼간이=マヌケ)

육감이 둔한 인간을 본쿠라(盆暗)라고 했다고 유래되고 있다.

5) ぐうたら(구우타라/무시근한, 늘쩡늘쩡한 사람)

일본어에는 논베에(呑兵衛/のんべえ/술부대, 모주), 스케베이「에」(助平/すけべい「え」/호색가, 색골)등과 같이

6) のろま(노로마/굼벵이,동작이나 머리가 아둔함, 바보)

이분 このかた(코노카타)

이사람 こひと(코히토)

이자식 このいつ (코노이쯔)

이새끼 このやろう(코노야로우)

이씨발새끼 このくそやろう(코노쿠소야로우)

씨발새끼 くそやろう (쿠소야로우)

오늘은 욕(惡口)에 대해 말을 할까 합니다.

한국도 욕하면 한나라 하죠(다른 나라들도 있겠지만)

동경에서는 대부분 バカヤロ-、(바까야로)バカ、(바까)クソッタレ(쿠솟타레?)등이 있는 반면,

오사까 쪽에서는 ドアホ(도아호)、アホンダラ、(아혼다라?)アホタレ、(아호타레)ボケ、(보케)ボケナス、(보케나스)

ボングラ、スカタン、ホウスケ(본구라,스카탄,호우스케)등 동경보다 압도적으로 많습니다.

バカ(바까)와 アホ(아호)의 차이는 利口와 賢い이 차이라고 생각하면 됩니다. 

이런 말들 중에 알고 있는 말이 몇 개나 될까요!

ケチン坊=シミッタレ시밋타레) 구두쇠, 노랭이,

素寒貧(すかんぴん스칸빈) 빈털털이

强突張り(ごうつくばり고우쯔꾸바리) 욕심 많고 고집이 샘

破落戶(ごろつき고로쯔끼) 불량배, 생양아치

木偶坊(でくのぼう데쿠노보우) 등신, 병신 같은놈

夜郞自大(やろうじだい야로우지다이) 능력 없으면서 분수 모르고 으스대는 놈
(재수없는 놈)

阿漕(あこぎ아꼬기) 얍삽이, 독한 놈

碌で無し(ろくでなし로꾸데나시) 쓸모 없는 인간

因業(いんこう인꼬-) 피도 눈물도 없는 놈

阿婆擦れ(あばずれ아바즈레) 닳고닳은.걸레 같은 년(헉-정말 나빠요-)

頓珍漢(とんちんかん톤친깐) 어벙이, 띨띨이

下種野郞(げすやろう바스야로우) 비열한 자식

人非人(にんぴにん닌비닌) 인간도 아닌 놈

表六玉(ひょうろくだま히요오로꾸다마) 멍텅구리, 숙맥

醜男(ぶおとこ부오또꼬) 추남

醜女(ぶおんな、しこめ부온나, 시꼬메) 추녀

氣障(きざ키자) 같잖음, 아니꼬움

痴者(しれもの시레모노) 천치

朴念仁(ぼくねんじん보꾸넨진) 벽창호

行かれた奴(いかれたやつ이까레따야쯔)미친놈