import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import java.util.TreeMap;
/**
 *<CODE>Utilities</CODE>クラスは、開発時に頻繁に使用される機能を簡素化してメソッド化したものをまとめたクラスです。
 *@author junmix
 *@version 1.0
 */
public class Utilities {
    /**
     *<CODE>Utilities</CODE>クラスのインスタンスを生成します。
     */
    public Utilities() {
    }
    /**
     *デバッグログを出力します。
     *@param  sMessage      出力メッセージ
     *@param  isTimeless    時刻を出力しないかのフラグ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void debugMessage(String sMessage, boolean isTimeless) throws Exception {
        Calendar cal = null;
        SimpleDateFormat sdf = null;
        String sCurrentTime = new String();
        PrintWriter pw = null;
        try {
            cal = Calendar.getInstance();
            sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
            sCurrentTime = sdf.format(cal.getTime());
            pw = new PrintWriter(new BufferedWriter(new FileWriter("Utilities.log", true)));
            pw.println("----------------------------------------------------------------------------------------------------");
            if (isTimeless) {
                pw.println(sMessage);
            } else {
                pw.println(sCurrentTime + " : " + sMessage);
            }
            pw.println("");
            pw.flush();
            pw.close();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *デバッグログを出力します。
     *@param  sMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void debugMessage(String sMessage) throws Exception {
        Calendar cal = null;
        SimpleDateFormat sdf = null;
        String sCurrentTime = new String();
        PrintWriter pw = null;
        try {
            cal = Calendar.getInstance();
            sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
            sCurrentTime = sdf.format(cal.getTime());
            pw = new PrintWriter(new BufferedWriter(new FileWriter("Utilities.log", true)));
            pw.println("----------------------------------------------------------------------------------------------------");
            pw.println(sCurrentTime + " : " + sMessage);
            pw.println("");
            pw.flush();
            pw.close();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  bMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(boolean bMessage) throws Exception {
        try {
            System.out.println(bMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  cMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(char cMessage) throws Exception {
        try {
            System.out.println(cMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  iMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(int iMessage) throws Exception {
        try {
            System.out.println(iMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  lMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(long lMessage) throws Exception {
        try {
            System.out.println(lMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  dMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(double dMessage) throws Exception {
        try {
            System.out.println(dMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  sMessage      出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(String sMessage) throws Exception {
        try {
            System.out.println(sMessage);
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  htMessage     出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(Hashtable htMessage) throws Exception {
        try {
            System.out.println(htMessage.toString());
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  hmMessage     出力メッセージ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public void printMessage(HashMap hmMessage) throws Exception {
        try {
            System.out.println(hmMessage.toString());
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  sarMessage        出力メッセージ
     *@throws Exception         例外が発生した場合にスローされる
     */
    public void printMessage(String[] sarMessage) throws Exception {
        try {
            int iLength = sarMessage.length;
            boolean isFirst = true;
            for (int j = 0; j < iLength; j++) {
                if (isFirst) {
                    System.out.print("[" + sarMessage[j] + "]");
                    isFirst = false;
                } else {
                    System.out.print(", [" + sarMessage[j] + "]");
                }
            }
            System.out.println("");
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  iarMessage        出力メッセージ
     *@throws Exception         例外が発生した場合にスローされる
     */
    public void printMessage(int[] iarMessage) throws Exception {
        try {
            int iLength = iarMessage.length;
            boolean isFirst = true;
            for (int j = 0; j < iLength; j++) {
                if (isFirst) {
                    System.out.print("[" + iarMessage[j] + "]");
                    isFirst = false;
                } else {
                    System.out.print(", [" + iarMessage[j] + "]");
                }
            }
            System.out.println("");
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  carMessage        出力メッセージ
     *@throws Exception         例外が発生した場合にスローされる
     */
    public void printMessage(char[] carMessage) throws Exception {
        try {
            int iLength = carMessage.length;
            boolean isFirst = true;
            for (int j = 0; j < iLength; j++) {
                if (isFirst) {
                    System.out.print("[" + carMessage[j] + "]");
                    isFirst = false;
                } else {
                    System.out.print(", [" + carMessage[j] + "]");
                }
            }
            System.out.println("");
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  sarMessage        出力メッセージ
     *@throws Exception         例外が発生した場合にスローされる
     */
    public void printMessage(String[][] sarMessage) throws Exception {
        try {
            int iLength = sarMessage.length;
            boolean isFirst = true;
            for (int i = 0; i < iLength; i++) {
                for (int j = 0; j < sarMessage[i].length; j++) {
                    if (isFirst) {
                        System.out.print("[" + sarMessage[i][j] + "]");
                        isFirst = false;
                    } else {
                        System.out.print(", [" + sarMessage[i][j] + "]");
                    }
                }
                System.out.println("");
                isFirst = true;
            }
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *標準出力を行います。
     *@param  iarMessage        出力メッセージ
     *@throws Exception         例外が発生した場合にスローされる
     */
    public void printMessage(int[][] iarMessage) throws Exception {
        try {
            int iLength = iarMessage.length;
            boolean isFirst = true;
            for (int i = 0; i < iLength; i++) {
                for (int j = 0; j < iarMessage[i].length; j++) {
                    if (isFirst) {
                        System.out.print("[" + iarMessage[i][j] + "]");
                        isFirst = false;
                    } else {
                        System.out.print(", [" + iarMessage[i][j] + "]");
                    }
                }
                System.out.println("");
                isFirst = true;
            }
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *時刻を取得します。
     *@return yyyy/MM/dd HH:mm:ss.SSS形式の時刻
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String getTime() throws Exception {
        Calendar cal = null;
        SimpleDateFormat sdf = null;
        String sCurrentTime = new String();
        try {
            cal = java.util.Calendar.getInstance();
            sdf = new java.text.SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
            sCurrentTime = sdf.format(cal.getTime());
            return sCurrentTime;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *時刻をミリ秒で取得します。
     *@return 現在時刻のミリ秒数
     *@throws Exception     例外が発生した場合にスローされる
     */
    public long getMillis() throws Exception {
        try {
            return System.currentTimeMillis();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列内に指定された区切り文字が連続している場合に半角スペースを入れ、区切り文字と区切り文字との間に値が無い場合などに頻発するケースである、<CODE>StringTokenizer</CODE>の使用時での<CODE>NoSuchElementException</CODE>を回避します。
     *@param  sData         変換対象の文字列出力
     *@param  sSplit        区切り文字
     *@return 連続する区切り文字の間に半角スペースを入れた文字列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String convertToken(String sData, String sSplit) throws Exception {
        StringBuffer sbReturn = new StringBuffer();
        String sTempData = new String();
        String sTempDataPrev = sSplit;
        int iLength = sData.length();
        try {
            for (int i = 0; i < iLength; i++) {
                sTempData = sData.substring(i, i + 1);
                if (sTempDataPrev.equals(sSplit) && sTempData.equals(sSplit)) {
                    sTempData = sTempData.concat(" ").concat(sSplit);
                    sTempDataPrev = sSplit;
                } else {
                    sTempDataPrev = sTempData;
                }
                sbReturn.append(sTempData);
            }
            return sbReturn.toString();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *一定の区切り文字と改行で構成された文字列を多次元配列に変換します。<BR>
     *<BR>
     *<CODE>SingleLineToken</CODE>を呼び出して合わせて使用し、こちらは改行数分の多次元配列を生成します。
     *@param  sData         一定の区切り文字と改行で構成された文字列
     *@param  sSplit        区切り文字
     *@return 変換後の文字列型の二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] MultiLineToken(String sData, String sSplit) throws Exception {
        int ix;
        try {
            StringTokenizer stk = new StringTokenizer(sData, "\n");
            ix = stk.countTokens();
            if (ix == 0) {
                return new String[0][0];
            }
            String sarReturn[][] = new String[ix][0];
            for (int i = 0; i < ix; i++) {
                sarReturn[i] = this.SingleLineToken(stk.nextToken() + " ", sSplit);
            }
            return sarReturn;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *一定の区切り文字と改行で構成された文字列を多次元配列に変換します。<BR>
     *<BR>
     *<CODE>MultiLineToken</CODE>に呼び出されて合わせて使用し、こちらは区切り文字で各行に配列を生成します。
     *@param  sData         一定の区切り文字で構成された文字列
     *@param  sSplit        区切り文字
     *@return 変換後の文字列型の配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[] SingleLineToken(String sData, String sSplit) throws Exception {
        int ix;
        try {
            StringTokenizer stk = new StringTokenizer(this.convertToken(sData, sSplit), sSplit);
            ix = stk.countTokens();
            if (ix == 0) {
                return new String[0];
            }
            String sarReturn[] = new String[ix];
            for (int i = 0; i < ix; i++) {
                sarReturn[i] = stk.nextToken().trim();
            }
            return sarReturn;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、指定したキーの値を取り出します。
     *@param  ht            値が格納されているハッシュ
     *@param  sKey          指定したキー
     *@return ハッシュから取得した値
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String getHashData(Hashtable ht, String sKey) throws Exception {
        String sOutText = new String();
        try {
            if (ht.get(sKey) != null) {
                sOutText = (String)ht.get(sKey);
            }
            return sOutText;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、指定したキーの値を取り出します。
     *@param  hm            値が格納されているハッシュ
     *@param  sKey          指定したキー
     *@return ハッシュから取得した値
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String getHashData(HashMap hm, String sKey) throws Exception {
        String sOutText = new String();
        try {
            if (hm.get(sKey) != null) {
                sOutText = (String)hm.get(sKey);
            }
            return sOutText;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、指定したキーの値を取り出します。
     *@param  tm            値が格納されているハッシュ
     *@param  sKey          指定したキー
     *@return ハッシュから取得した値
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String getHashData(TreeMap tm, String sKey) throws Exception {
        String sOutText = new String();
        try {
            if (tm.get(sKey) != null) {
                sOutText = (String)tm.get(sKey);
            }
            return sOutText;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、文字列型の二次元配列を生成します。
     *@param  ht            値が格納されているハッシュ
     *@param  isSort        キーでソートするかどうかのフラグ
     *@param  isReverse     上記のフラグが立っている場合の降順ソートするかどうかのフラグ
     *@return ハッシュのキー、ハッシュの値のを配列に格納した二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] convertHashDataToStringTwoDimensionalArray(Hashtable ht, boolean isSort, boolean isReverse) throws Exception {
        String[] sarHashKey;
        String[][] sarResult;
        try {
            int iSize = ht.size();
            sarHashKey = new String[iSize];
            Iterator itr = ht.keySet().iterator();
            for (int i = 0; i < iSize; i++) {
                sarHashKey[i] = (String)itr.next();
            }
            if (isSort) {
                if (isReverse) {
                    Arrays.sort(sarHashKey, Collections.reverseOrder());
                } else {
                    Arrays.sort(sarHashKey);
                }
            }
            sarResult = new String[sarHashKey.length][2];
            for (int i = 0; i < sarResult.length; i++) {
                sarResult[i][0] = sarHashKey[i];
                sarResult[i][1] = this.getHashData(ht, sarHashKey[i]);
            }
            return sarResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、文字列型の二次元配列を生成します。
     *@param  hm            値が格納されているハッシュ
     *@param  isSort        キーでソートするかどうかのフラグ
     *@param  isReverse     上記のフラグが立っている場合の降順ソートするかどうかのフラグ
     *@return ハッシュのキー、ハッシュの値のを配列に格納した二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] convertHashDataToStringTwoDimensionalArray(HashMap hm, boolean isSort, boolean isReverse) throws Exception {
        String[] sarHashKey;
        String[][] sarResult;
        try {
            int iSize = hm.size();
            sarHashKey = new String[iSize];
            Iterator itr = hm.keySet().iterator();
            for (int i = 0; i < iSize; i++) {
                sarHashKey[i] = (String)itr.next();
            }
            if (isSort) {
                if (isReverse) {
                    Arrays.sort(sarHashKey, Collections.reverseOrder());
                } else {
                    Arrays.sort(sarHashKey);
                }
            }
            sarResult = new String[sarHashKey.length][2];
            for (int i = 0; i < sarResult.length; i++) {
                sarResult[i][0] = sarHashKey[i];
                sarResult[i][1] = this.getHashData(hm, sarHashKey[i]);
            }
            return sarResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列をキーにして文字列を格納したハッシュから、文字列型の二次元配列を生成します。
     *@param  tm            値が格納されているハッシュ
     *@param  isSort        キーでソートするかどうかのフラグ
     *@param  isReverse     上記のフラグが立っている場合の降順ソートするかどうかのフラグ
     *@return ハッシュのキー、ハッシュの値のを配列に格納した二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] convertHashDataToStringTwoDimensionalArray(TreeMap tm, boolean isSort, boolean isReverse) throws Exception {
        String[] sarHashKey;
        String[][] sarResult;
        try {
            int iSize = tm.size();
            sarHashKey = new String[iSize];
            Iterator itr = tm.keySet().iterator();
            for (int i = 0; i < iSize; i++) {
                sarHashKey[i] = (String)itr.next();
            }
            if (isSort) {
                if (isReverse) {
                    Arrays.sort(sarHashKey, Collections.reverseOrder());
                } else {
                    Arrays.sort(sarHashKey);
                }
            }
            sarResult = new String[sarHashKey.length][2];
            for (int i = 0; i < sarResult.length; i++) {
                sarResult[i][0] = sarHashKey[i];
                sarResult[i][1] = this.getHashData(tm, sarHashKey[i]);
            }
            return sarResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *区切り文字で区切られた文字列の中から、指定した場所のトークンを取得します。
     *@param  sData         区切り文字で区切られた文字列
     *@param  iNo           取得するトークンの場所
     *@param  sSplit        区切り文字
     *@return 取得したトークンの値
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String getToken(String sData, int iNo, String sSplit) throws Exception {
        int i = 0;
        String sResult = new String();
        String sWork = new String();
        try {
            StringTokenizer stk = new StringTokenizer(this.convertToken(sData, sSplit), sSplit);
            if (iNo > stk.countTokens()) {
                throw new NoSuchElementException();
            }
            while (stk.hasMoreTokens()) {
                i++;
                sWork = stk.nextToken().trim();
                if (i == iNo) {
                    sResult = sWork;
                    break;
                }
            }
            return sResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *一定の区切り文字と改行で構成された文字列を、指定したトークンの位置で行単位でソートします。<BR>
     *<BR>
     *サンプル：<BR>
     *<BLOCKQUOTE><PRE>String sData = "abc|adf|cdb" + "\n" +
     *               "akf|cmd|amd" + "\n" +
     *               "opr|ndj|ymj";</PRE></BLOCKQUOTE>
     *このように"|"で区切った文字列が複数行あるStringを用意し、<BR>
     *<BLOCKQUOTE><PRE>sortTokens(sData, 3, "|", false, false);</PRE></BLOCKQUOTE>
     *とメソッドを呼ぶと、各行の3つ目の文字列のトークンを比較して、以下の結果のようにソートします。<BR>
     *<BLOCKQUOTE><PRE>実行前：          結果：
     *abc|adf|cdb       akf|cmd|amd
     *akf|cmd|amd       abc|adf|cdb
     *opr|ndj|ymj       opr|ndj|ymj</PRE></BLOCKQUOTE>
     *@param  sData         一定の区切り文字と改行で構成された文字列
     *@param  iNum          ソートの基準とするトークンの場所
     *@param  sSplit        区切り文字
     *@param  AsInteger     数値としてソートするかのフラグ
     *@param  isReverse     降順としてソートするかのフラグ
     *@return 指定したトークンの位置でソートされた、区切り文字と改行で構成された文字列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String sortTokens(String sData, int iNo, String sSplit, boolean AsInteger, boolean isReverse) throws Exception {
        StringBuffer sbResult = new StringBuffer();
        String sWork = new String();
        String sTokenLine = new String();
        String sTokenLineToken = new String();
        String sarResult[];
        int iTokenLineTokenNum = 0;
        int iTokenLineTokenCount = 0;
        try {
            StringTokenizer stk = new StringTokenizer(sData, "\n");
            while (stk.hasMoreTokens()) {
                sTokenLine = this.convertToken(stk.nextToken(), sSplit);
                StringTokenizer stk2 = new StringTokenizer(sTokenLine, sSplit);
                iTokenLineTokenNum = stk2.countTokens();
                if (iNo > iTokenLineTokenNum || iNo <= 0) {
                    throw new NoSuchElementException();
                }
                sWork = this.getToken(sTokenLine, iNo, sSplit) + sSplit;
                while (stk2.hasMoreTokens()) {
                    iTokenLineTokenCount++;
                    sTokenLineToken = stk2.nextToken().trim();
                    if (iTokenLineTokenCount == iNo) {
                        continue;
                    }
                    sWork = sWork.concat(sTokenLineToken).concat(sSplit);
                }
                if (!sTokenLine.endsWith(sSplit)) {
                    sWork = sWork.substring(0, (sWork.length() - 1));
                }
                sbResult.append(sWork).append("\n");
                iTokenLineTokenNum = 0;
                iTokenLineTokenCount = 0;
            }
            if (AsInteger) {
                StringTokenizer stkCheckInt = new StringTokenizer(sbResult.toString(), "\n");
                int intLength = 0;
                while (stkCheckInt.hasMoreTokens()) {
                    String sLengthCheck = this.getToken(stkCheckInt.nextToken(), 1, sSplit);
                    if (sLengthCheck.length() > intLength) {
                        intLength = sLengthCheck.length();
                    }
                }
                String sResultIntCheck = new String();
                StringTokenizer stkCheckInt2 = new StringTokenizer(sbResult.toString(), "\n");
                while (stkCheckInt2.hasMoreTokens()) {
                    String sTokenLineCheckInt = stkCheckInt2.nextToken();
                    if (this.getToken(sTokenLineCheckInt, 1, sSplit).length() <= intLength) {
                        int iDiffDigit = intLength - this.getToken(sTokenLineCheckInt, 1, sSplit).length();
                        for (int i = 0; i < iDiffDigit; i++) {
                            sTokenLineCheckInt = "0".concat(sTokenLineCheckInt);
                        }
                    }
                    sResultIntCheck = sResultIntCheck.concat(sTokenLineCheckInt).concat("\n");
                }
                sbResult = new StringBuffer(sResultIntCheck);
            }
            StringTokenizer stk3 = new StringTokenizer(sbResult.toString(), "\n");
            List arResult = new ArrayList();
            while (stk3.hasMoreTokens()) {
                arResult.add(stk3.nextToken());
            }
            sarResult = new String[arResult.size()];
            for (int i = 0; i < arResult.size(); i++) {
                sarResult[i] = (String)arResult.get(i);
            }
            Arrays.sort(sarResult);
            if (isReverse) {
                int iStringArrayResultlength = sarResult.length;
                String[] sarResultReverse = new String[iStringArrayResultlength];
                for (int i = 0; i < iStringArrayResultlength; i++) {
                    sarResultReverse[i] = sarResult[iStringArrayResultlength - i - 1];
                }
                sarResult = sarResultReverse;
            }
            sbResult = new StringBuffer();
            for (int i = 0; i < sarResult.length; i++) {
                sbResult.append(sarResult[i]).append("\n");
            }
            StringTokenizer stk4 = new StringTokenizer(sbResult.toString(), "\n");
            sbResult = new StringBuffer();
            while (stk4.hasMoreTokens()) {
                sTokenLine = this.convertToken(stk4.nextToken(), sSplit);
                StringTokenizer stk5 = new StringTokenizer(sTokenLine, sSplit);
                while (stk5.hasMoreTokens()) {
                    iTokenLineTokenCount++;
                    if (iTokenLineTokenCount == 1) {
                        sWork = stk5.nextToken().trim();
                        continue;
                    }
                    if (iNo >= iTokenLineTokenCount) {
                        sTokenLineToken = stk5.nextToken().trim();
                        sbResult.append(sTokenLineToken).append(sSplit);
                    } else if (iTokenLineTokenCount == iNo + 1) {
                        if (AsInteger) {
                            while (sWork.startsWith("0")) {
                                sWork = sWork.substring(1, sWork.length());
                            }
                            if (sWork.equals("")) {
                                sWork = "0";
                            }
                        }
                        sbResult.append(sWork).append(sSplit);
                    } else if (iTokenLineTokenCount > iNo + 1) {
                        sTokenLineToken = stk5.nextToken().trim();
                        sbResult.append(sTokenLineToken).append(sSplit);
                    }
                }
                if (iTokenLineTokenCount == iNo) {
                    if (AsInteger) {
                        while (sWork.startsWith("0")) {
                            sWork = sWork.substring(1, sWork.length());
                        }
                        if (sWork.equals("")) {
                            sWork = "0";
                        }
                    }
                    sbResult.append(sWork).append(sSplit);
                }
                if (!sTokenLine.endsWith(sSplit)) {
                    sbResult = new StringBuffer(sbResult.toString().substring(0, (sbResult.toString().length() - 1)));
                }
                sbResult.append("\n");
                iTokenLineTokenCount = 0;
            }
            return sbResult.toString();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *設定ファイルをハッシュとして取得します。
     *@param  sFilePath     設定ファイルのパス（設定ファイルの文字コードはEUCで記述する）
     *@return 設定ファイルのハッシュ
     *@throws Exception     例外が発生した場合にスローされる
     */
    public Hashtable getHashIni(String sFilePath) throws Exception {
        Hashtable htIni = new Hashtable();
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(sFilePath), "EUCJP"));
            while (br.ready()) {
                String sLine = this.convertToken(new String((br.readLine()).getBytes("SJIS")), "=");
                if (sLine.length() == 0 || sLine.startsWith("//") || sLine.startsWith("#") || (sLine.startsWith("[") && sLine.substring(sLine.length() - 1, sLine.length()).equals("]"))) {
                    continue;
                }
                int iCount = 0;
                String sKey = new String();
                String sValue = new String();
                StringTokenizer stk = new StringTokenizer(this.convertToken(sLine, "="), "=");
                if (stk.countTokens() == 1) {
                    continue;
                } else if (stk.countTokens() == 2) {
                    while (stk.hasMoreTokens()) {
                        String sTempStr = stk.nextToken();
                        if (sTempStr.equals(" ")) {
                            sTempStr = "";
                        }
                        iCount++;
                        if (iCount == 1) {
                            sKey = new String(sTempStr.getBytes("SJIS"));
                        } else if (iCount == 2) {
                            sValue = new String(sTempStr.getBytes("SJIS"));
                        }
                    }
                    htIni.put(sKey, sValue);
                } else if (stk.countTokens() > 2) {
                    sKey = new String(this.getToken(stk.nextToken(), 1, "=").getBytes("SJIS"));
                    while (stk.hasMoreTokens()) {
                        sValue = sValue.concat(new String(this.getToken(stk.nextToken(), 1, "=").getBytes("SJIS")));
                        if (stk.hasMoreTokens()) {
                            sValue = sValue.concat("=");
                        }
                    }
                    htIni.put(sKey, sValue);
                }
            }
            br.close();
            return htIni;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列を指定バイト数に切り詰めます。
     *@param  sData         バイト数を切り詰める元の文字列
     *@param  iLength       切り詰めるバイト数
     *@return sNewData      バイト数を切り詰めた後の文字列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String cutString(String sData, int iLength) throws Exception {
        String sNewData;
        try {
            byte[] bData = sData.getBytes("SJIS");
            sNewData = new String(bData, 0, iLength);
            if (sNewData == null || sNewData.equals("")) {
                sNewData = new String(bData, 0, iLength - 1);
            }
            return sNewData;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *特定の文字列を指定した文字列に置き換えます。<BR>
     *<BR>
     *サンプル：<BR>
     *<BLOCKQUOTE><PRE>String sData = "123|456|123|456|";</PRE></BLOCKQUOTE>
     *このような数値を格納したStringを用意し、<BR>
     *<BLOCKQUOTE><PRE>replaceString(sData, "123|", "999$");</PRE></BLOCKQUOTE>
     *とメソッドを呼ぶと、文字列の中の「123|」を検索して「999$」に置換して、以下の結果のような文字列を生成します。<BR>
     *<BLOCKQUOTE><PRE>実行前：                  結果：
     *"123|456|123|456|"        "999$456|999$456|"</PRE></BLOCKQUOTE>
     *@param  sData         置換対象の文字列
     *@param  sOld          置き換えられる文字列
     *@param  sNew          置き換える文字列
     *@return 変換後の文字列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String replaceString(String sData, String sOld, String sNew) throws Exception {
        StringBuffer sbResult = new StringBuffer();
        boolean bBreakFlg = false;
        try {
            char car[] = sData.toCharArray();
            int iLength = sOld.length();
            for (int i = 0; i < car.length; i++) {
                String sWork = new String();
                for (int j = 0; j < iLength; j++) {
                    if (i + j >= car.length) {
                        bBreakFlg = true;
                        break;
                    }
                    sWork = sWork.concat(String.valueOf(car[i + j]));
                }
                if (sWork.equals(sOld)) {
                    sbResult.append(sNew);
                    i = i + iLength - 1;
                } else {
                    sbResult.append(String.valueOf(car[i]));
                }
            }
            return sbResult.toString();
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *数値を格納した文字列型の二次元配列を指定したカラムの値でソートをかけます。<BR>
     *<BR>
     *サンプル：<BR>
     *<BLOCKQUOTE><PRE>String[][] sarValue = new String[][]{
     *                                      {"4", "0", "7"},
     *                                      {"6", "8", "1"}
     *                                    };</PRE></BLOCKQUOTE>
     *このような数値を格納した文字列型のString[][]を用意し、<BR>
     *<BLOCKQUOTE><PRE>sortStringTwoDimensionalArrayIntegerType(sarValue, 2, false);</PRE></BLOCKQUOTE>
     *とメソッドを呼ぶと、各配列の3つ目（配列の添え字は0から始まるため）の値を比較して、以下の結果のようにソートします。<BR>
     *<BLOCKQUOTE><PRE>実行前：              結果：
     *{"4", "0", "7"},      {"6", "8", "1"},
     *{"6", "8", "1"}       {"4", "0", "7"}</PRE></BLOCKQUOTE>
     *@param  sarValue      文字列型の数値を格納した二次元配列
     *@param  iNum          ソートの基準とする配列の添え字
     *@param  isReverse     降順としてソートするかのフラグ
     *@return 指定した配列の添え字の位置でソートされた二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] sortStringTwoDimensionalArrayIntegerType(String[][] sarValue, int iNum, boolean isReverse) throws Exception {
        String sWork = new String();
        String sResult = new String();
        String[][] sarResult;
        try {
            sarResult = new String[sarValue.length][sarValue[0].length];
            for (int i = 0; i < sarValue.length; i++) {
                for (int j = 0; j < sarValue[i].length; j++) {
                    sWork = sWork.concat(sarValue[i][j]).concat("|");
                }
                sWork = sWork.concat("\n");
            }
            sResult = this.sortTokens(sWork, iNum + 1, "|", true, isReverse);
            StringTokenizer stk1 = new StringTokenizer(sResult, "\n");
            for (int i = 0; stk1.hasMoreTokens(); i++) {
                String stk1Line = stk1.nextToken();
                StringTokenizer stk2 = new StringTokenizer(stk1Line, "|");
                for (int j = 0; stk2.hasMoreTokens(); j++) {
                    sarResult[i][j] = stk2.nextToken();
                }
            }
            return sarResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *文字列型の二次元配列を指定したカラムの値でソートをかけます。<BR>
     *<BR>
     *サンプル：<BR>
     *<BLOCKQUOTE><PRE>String[][] sarValue = new String[][]{
     *                                      {"abc", "pqr", "jkl"},
     *                                      {"stu", "def", "vwx"},
     *                                      {"mno", "yzx", "ghi"}
     *                                    };</PRE></BLOCKQUOTE>
     *このような数値を格納した文字列型のString[][]を用意し、<BR>
     *<BLOCKQUOTE><PRE>sortStringTwoDimensionalArrayStringType(sarValue, 1, true, "|");</PRE></BLOCKQUOTE>
     *とメソッドを呼ぶと、各配列の2つ目（配列の添え字は0から始まるため）の値を比較して、以下の結果のようにソートします。<BR>
     *<BLOCKQUOTE><PRE>実行前：                      結果：
     *{"abc", "pqr", "jkl"},        {"mno", "yzx", "ghi"},
     *{"stu", "def", "vwx"},        {"abc", "pqr", "jkl"},
     *{"mno", "yzx", "ghi"}         {"stu", "def", "vwx"}</PRE></BLOCKQUOTE>
     *@param  sarValue      文字列を格納した二次元配列
     *@param  iNum          ソートの基準とする配列の添え字
     *@param  isReverse     降順としてソートするかのフラグ
     *@param  sSplit        配列のどの部分にも含まれない、<CODE>StringTokenizer</CODE>に使っても問題無い区切り文字（<CODE>String</CODE>かつ1文字）
     *@return 指定した配列の添え字の位置でソートされた二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public String[][] sortStringTwoDimensionalArrayStringType(String[][] sarValue, int iNum, boolean isReverse, String sSplit) throws Exception {
        String sWork = new String();
        String sResult = new String();
        String[][] sarResult;
        try {
            sarResult = new String[sarValue.length][sarValue[0].length];
            for (int i = 0; i < sarValue.length; i++) {
                for (int j = 0; j < sarValue[i].length; j++) {
                    sWork = sWork.concat(sarValue[i][j]).concat(sSplit);
                }
                sWork = sWork.concat("\n");
            }
            sResult = this.sortTokens(sWork, iNum + 1, sSplit, false, isReverse);
            StringTokenizer stk1 = new StringTokenizer(sResult, "\n");
            for (int i = 0; stk1.hasMoreTokens(); i++) {
                String stk1Line = stk1.nextToken();
                StringTokenizer stk2 = new StringTokenizer(stk1Line, sSplit);
                for (int j = 0; stk2.hasMoreTokens(); j++) {
                    sarResult[i][j] = stk2.nextToken();
                }
            }
            return sarResult;
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     *数値型の二次元配列を指定したカラムの値でソートをかけます。<BR>
     *<BR>
     *サンプル：<BR>
     *<BLOCKQUOTE><PRE>int[][] iarValue = new int[][]{
     *                                  {2, 3, 7},
     *                                  {5, 7, 9},
     *                                  {8, 9, 3}
     *                              };</PRE></BLOCKQUOTE>
     *このような数値を格納した数値型のint[][]を用意し、<BR>
     *<BLOCKQUOTE><PRE>sortIntegerTwoDimensionalArray(iarNum, 2, false);</PRE></BLOCKQUOTE>
     *とメソッドを呼ぶと、各配列の3つ目（配列の添え字は0から始まるため）の値を比較して、以下の結果のようにソートします。<BR>
     *<BLOCKQUOTE><PRE>実行前：          結果：
     *{2, 3, 7},        {8, 9, 3},
     *{5, 7, 9},        {2, 3, 7},
     *{8, 9, 3}         {5, 7, 9}</PRE></BLOCKQUOTE>
     *@param  iarValue      数値を格納した二次元配列
     *@param  iNum          ソートの基準とする配列の添え字
     *@param  isReverse     降順としてソートするかのフラグ
     *@return 指定した配列の添え字の位置でソートされた二次元配列
     *@throws Exception     例外が発生した場合にスローされる
     */
    public int[][] sortIntegerTwoDimensionalArray(int[][] iarValue, int iNum, boolean isReverse) throws Exception {
        String sWork = new String();
        String sResult = new String();
        int[][] iarResult;
        try {
            iarResult = new int[iarValue.length][iarValue[0].length];
            for (int i = 0; i < iarValue.length; i++) {
                for (int j = 0; j < iarValue[i].length; j++) {
                    sWork = sWork.concat(Integer.toString(iarValue[i][j])).concat("|");
                }
                sWork = sWork.concat("\n");
            }
            sResult = this.sortTokens(sWork, iNum + 1, "|", true, isReverse);
            StringTokenizer stk1 = new StringTokenizer(sResult, "\n");
            for (int i = 0; stk1.hasMoreTokens(); i++) {
                String stk1Line = stk1.nextToken();
                StringTokenizer stk2 = new StringTokenizer(stk1Line, "|");
                for (int j = 0; stk2.hasMoreTokens(); j++) {
                    iarResult[i][j] = Integer.parseInt(stk2.nextToken());
                }
            }
            return iarResult;
        } catch (Exception e) {
            throw e;
        }
    }
}