/*
 * MosP - Mind Open Source Project    http://www.mosp.jp/
 * Copyright (C) MIND Co., Ltd.       http://www.e-mind.co.jp/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package jp.mosp.common.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;

import jp.mosp.common.CommonConst;
import jp.mosp.common.common.KanaConvertUtility;
import jp.mosp.common.common.MospUtility;

/**
 * Stringに関するPartクラス
 * @author yoshida
 * 	@version	0.0.2
 */
public class StringUtil {
	
	/**
	 * 
	 */
	private StringUtil() {
		// 他クラスによるインスタンス化を防止
	}
	
	/*		配列関連		*/

	/**
	 * 二次元配列を一次元配列へ変換
	 * @param ary 対象二次元配列
	 * @param d 選択No.
	 * @return 選択一次元配列
	 */
	public static String[] separateArrayList(String[][] ary, int d) {
		String[] aryName = new String[ary.length];
		for (int i = 0; i < ary.length; i++) {
			aryName[i] = ary[i][d];
		}
		return aryName;
	}
	
	/**
	 * 配列同士の結合
	 * @param frontarray 前方n行2列
	 * @param behindarray 後方n行2列
	 * @return	String[][]	結合配列
	 */
	public static String[][] combineArray(String[][] frontarray, String[][] behindarray) {
		String[][] result = new String[frontarray.length + behindarray.length][2];
		System.arraycopy(frontarray, 0, result, 0, frontarray.length);
		System.arraycopy(behindarray, 0, result, frontarray.length, behindarray.length);
		return result;
	}
	
	/**
	 * 配列同士の結合
	 * @param frontarray 前方n行2列
	 * @param centerarray 中間n行2列
	 * @param behindarray 後方n行2列
	 * @return	String[][]	結合配列
	 */
	public static String[][] combineArray(String[][] frontarray, String[][] centerarray, String[][] behindarray) {
		String[][] result = combineArray(combineArray(frontarray, centerarray), behindarray);
		return result;
	}
	
	/**
	 * 配列同士の結合
	 * @param list	二次元配列のリスト
	 * @return	リストを配列に変換
	 */
	public static String[][] combineArray(List<String[][]> list) {
		String[][] result = new String[0][2];
		for (String[][] array : list) {
			result = combineArray(result, array);
		}
		return result.clone();
	}
	
	/**
	 * 有り／無しリスト
	 * @return [0]…無し、[1]…有り
	 */
	public static String[][] getExistenceArray() {
		return getFlagArray(CommonConst.NAM_COMMON_NASI, CommonConst.NAM_COMMON_ARI);
	}
	
	/**
	 * 有り／無しリスト
	 * @return [0]…無、[1]…有
	 */
	public static String[][] getExistenceShortArray() {
		return getFlagArray(CommonConst.NAM_MISSING_INPUT_OFF_OPT, CommonConst.NAM_MISSING_INPUT_ON);
	}
	
	/**
	 * 同一配列チェック
	 * @param ary1		対象配列１
	 * @param ary2		対象配列２
	 * @return
	 * <p>
	 * 配列が一緒であればtrue、そうでない場合false
	 * </p>
	 */
	public static boolean checkArraysEquals(String[] ary1, String[] ary2) {
		if (Arrays.equals(ary1, ary2)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 一次元配列をListへ
	 * @param array		一次元配列
	 * @return	List
	 */
	public static List<String> arrayToList(String[] array) {
		List<String> list = new ArrayList<String>();
		for (String element : array) {
			list.add(element);
		}
		return list;
	}
	
	/**
	 * Listを一次元配列へ
	 * @param list	文字列のリスト
	 * @return	一次元配列
	 */
	public static String[] listToArray(List<String> list) {
		return list.toArray(new String[list.size()]);
	}
	
	/**
	 * 配列→カンマ区切りの文字列
	 * @param array		対象一次元配列
	 * @return	カンマ区切りの文字列
	 */
	public static String convArrayToFormattedByComma(String[] array) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i]);
			if (i != array.length - 1) {
				sb.append(CommonConst.STR_UNDER_SEPARATOR);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 配列次元変換
	 * @param ary1D		変換元一次元配列
	 * @return	変換後二次元配列
	 */
	public static String[][] convArrayDimension(String[] ary1D) {
		String[][] array = new String[1][2];
		array[0][0] = "";
		array[0][1] = "";
		if (ary1D != null) {
			array[0][0] = ary1D[0];
			array[0][1] = ary1D[1];
		}
		return array;
	}
	
	/**
	 * 配列次元変換
	 * @param ary2D		変換元二次元配列
	 * @return	変換後一次元配列
	 */
	public static String[] convArrayDimension(String[][] ary2D) {
		String[] array = new String[2];
		array[0] = "";
		array[1] = "";
		if (ary2D != null) {
			array[0] = ary2D[0][0];
			array[1] = ary2D[0][1];
		}
		return array;
	}
	
	/**
	 * 一次元配列生成
	 * @param str1		対象要素１
	 * @param str2		対象要素２
	 * @return　生成配列
	 */
	public static String[] createArray(String str1, String str2) {
		return new String[]{ str1, str2 };
	}
	
	/**
	 * 空白プルダウン取得
	 * @return  空白プルダウン用配列
	 */
	public static String[][] getBlankArray() {
		String[][] array = new String[1][2];
		array[0][0] = "";
		array[0][1] = "";
		return array;
	}
	
	/**
	 * 空白配列生成
	 * @param arraySize		生成配列長
	 * @return	空白配列
	 */
	public static String[][] getBlankArray(int arraySize) {
		String[][] array = new String[arraySize][2];
		for (int i = 0; i < array.length; i++) {
			array[i][0] = "";
			array[i][1] = "";
		}
		return array;
	}
	
	/**
	 * 空白配列生成（一次元）
	 * @param arraySize	生成配列長
	 * @return	空白配列（一次元）
	 */
	public static String[] getBlankArrayOneDimension(int arraySize) {
		String[] array = new String[arraySize];
		for (int i = 0; i < array.length; i++) {
			array[i] = "";
		}
		return array;
	}
	
	/**
	 * 空白配列生成（二次元）
	 * @param arraySize		生成親配列長
	 * @param childSize 	生成子配列長
	 * @return	空白配列（二次元）
	 */
	public static String[][] getBlankArray(int arraySize, int childSize) {
		String[][] array = new String[arraySize][childSize];
		for (String[] child : array) {
			for (int i = 0; i < child.length; i++) {
				child[i] = "";
			}
		}
		return array;
	}
	
	/**
	 * 在職/退職リスト取得
	 * @return 在職/退職リスト
	 */
	public static String[][] getRetirementFlagArrayAll() {
		// 配列の作成
		return addArrayFirstRowSpace(getRetirementFlagArray());
	}
	
	/**
	 * 在職/退職リスト取得（空欄無し）
	 * @return 在職/退職リスト
	 */
	public static String[][] getRetirementFlagArray() {
		// 配列の作成
		String[][] aryRetirementFlag = new String[3][2];
		aryRetirementFlag[0][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_OFF);
		aryRetirementFlag[0][1] = CommonConst.NAM_RETIREMENT_OFF;
		aryRetirementFlag[1][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_LEAVE);
		aryRetirementFlag[1][1] = CommonConst.NAM_RETIREMENT_LEAVE;
		aryRetirementFlag[2][0] = String.valueOf(CommonConst.RETIREMENT_FLAG_ON);
		aryRetirementFlag[2][1] = CommonConst.NAM_RETIREMENT_ON;
		return aryRetirementFlag;
	}
	
	/**
	 * 名称取得
	 * @param code  取得対象コード
	 * @param array コードとコード名称を含んだ配列
	 * @return コード名称
	 */
	public static String getCodeName(String code, String[][] array) {
		String codeName = code;
		if (array == null) {
			return codeName;
		}
		for (String[] element : array) {
			if (code.equals(element[0])) {
				codeName = element[1];
				break;
			}
		}
		return codeName;
	}
	
	/**
	 * コード取得
	 * @param name  取得対象コード
	 * @param array  取得対象配列
	 * @return コード名称
	 */
	public static String getCodeValue(String name, String[][] array) {
		String codeValue = name;
		if (array == null) {
			return codeValue;
		}
		for (String[] element : array) {
			if (name.equals(element[1])) {
				codeValue = element[0];
				break;
			}
		}
		return codeValue;
	}
	
	/**
	 * 年プルダウン取得
	 * @param year 基準年
	 * @return 年プルダウン用文字列配列
	 */
	public static String[][] getYearArray(int year) {
		String[][] aryYear = new String[3][2];
		aryYear[0][0] = String.valueOf(year - 1);
		aryYear[0][1] = String.valueOf(year - 1);
		aryYear[1][0] = String.valueOf(year);
		aryYear[1][1] = String.valueOf(year);
		aryYear[2][0] = String.valueOf(year + 1);
		aryYear[2][1] = String.valueOf(year + 1);
		return aryYear;
	}
	
	/**
	 * 年プルダウン取得
	 * @param year 基準年
	 * @param former 過去
	 * @param further 未来
	 * @return 年プルダウン用文字列配列
	 */
	public static String[][] getYearArray(int year, int former, int further) {
		String[][] aryYear = new String[former + further + 1][2];
		int i = 0;
		int index = 0;
		for (i = year - former; i < year; i++) {
			aryYear[index][0] = String.valueOf(i);
			aryYear[index][1] = String.valueOf(i);
			index++;
		}
		aryYear[index][0] = String.valueOf(year);
		aryYear[index][1] = String.valueOf(year);
		index++;
		for (i = year + 1; i <= year + further; i++) {
			aryYear[index][0] = String.valueOf(i);
			aryYear[index][1] = String.valueOf(i);
			index++;
		}
		return aryYear;
	}
	
	/**
	 * 月プルダウン取得
	 * @return 月プルダウン用文字列配列
	 */
	public static String[][] getMonthArray() {
		String[][] aryMonth = new String[12][2];
		for (int i = 0; i < 12; i++) {
			aryMonth[i][0] = String.valueOf(i + 1);
			aryMonth[i][1] = String.valueOf(i + 1);
		}
		return aryMonth;
	}
	
	/**
	 * 日プルダウン取得
	 * @return 月プルダウン用文字列配列
	 */
	public static String[][] getDayArray() {
		final int days = 31;
		String[][] aryDay = new String[days][2];
		for (int i = 0; i < days; i++) {
			aryDay[i][0] = String.valueOf(i + 1);
			aryDay[i][1] = String.valueOf(i + 1);
		}
		return aryDay;
	}
	
	/**
	 * 時間プルダウン取得
	 * @param hour          開始時
	 * @param minute        開始分
	 * @param count         データ数
	 * @param interval      データ間隔(分)
	 * @param isValueMinute 分設定フラグ(true：valueは分単位、false：valueは時間文字列)
	 * @return 時間プルダウン用文字列配列
	 */
	public static String[][] getTimeArray(int hour, int minute, int count, int interval, boolean isValueMinute) {
		String[][] aryTime = new String[count][2];
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.HOUR_OF_DAY, hour);
		cal.set(Calendar.MINUTE, minute);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		for (int i = 0; i < count; i++) {
			if (isValueMinute) {
				aryTime[i][0] = String.valueOf(cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE));
			} else {
				aryTime[i][0] = MospUtility.getDateString(cal.getTime(), CommonConst.FORMAT_TIME_SHORT);
			}
			aryTime[i][1] = MospUtility.getDateString(cal.getTime(), CommonConst.FORMAT_TIME_SHORT);
			cal.add(Calendar.MINUTE, interval);
		}
		return aryTime;
	}
	
	/**
	 * 数値プルダウン取得
	 * @param start		開始値
	 * @param end		終了値
	 * @param interval	間隔
	 * @return 数値プルダウン用文字列配列
	 */
	public static String[][] getCountArray(int start, int end, int interval) {
		int count = (end - start) / interval + 1;
		int value = start;
		String[][] aryCount = new String[count][2];
		for (int i = 0; i < count; i++) {
			aryCount[i][0] = String.valueOf(value);
			aryCount[i][1] = String.valueOf(value);
			value += interval;
		}
		return aryCount;
	}
	
	/**
	 * プルダウン行除去
	 * @param target 除去対象プルダウン配列
	 * @param value 除去対象行値
	 * @return 除去後プルダウン
	 */
	public static String[][] removeArrayRow(String[][] target, String value) {
		int count = target.length;
		for (String[] element : target) {
			if (element[0].equals(value)) {
				--count;
			}
		}
		String[][] aryNew = new String[count][2];
		count = 0;
		for (String[] element : target) {
			if (element[0].equals(value)) {
				continue;
			}
			aryNew[count][0] = element[0];
			aryNew[count][1] = element[1];
			++count;
		}
		return aryNew;
	}
	
	/**
	 * プルダウンの先頭行に空白を追加
	 * @param target 対象プルダウン配列
	 * @return 追加後プルダウン
	 */
	public static String[][] addArrayFirstRowSpace(String[][] target) {
		return addArrayFirstRowValue(target, "", "");
	}
	
	/**
	 * プルダウンの先頭行に任意の値を追加
	 * @param target 対象プルダウン配列
	 * @param code 対象行コード
	 * @param value 対象行表示値
	 * @return aryNew	生成配列
	 */
	public static String[][] addArrayFirstRowValue(String[][] target, String code, String value) {
		String[][] aryNew = new String[target.length + 1][2];
		for (int i = 0; i < aryNew.length; i++) {
			if (i == 0) {
				aryNew[0][0] = code;
				aryNew[0][1] = value;
			} else {
				aryNew[i][0] = target[i - 1][0];
				aryNew[i][1] = target[i - 1][1];
			}
		}
		return aryNew;
	}
	
	/**
	 * プルダウンの最終行に任意の値を追加
	 * @param target 対象プルダウン配列
	 * @param code 対象行コード
	 * @param value 対象行表示値
	 * @return aryNew	生成配列
	 */
	public static String[][] addArrayLastRowValue(String[][] target, String code, String value) {
		String[][] aryNew = new String[target.length + 1][2];
		for (int i = 0; i < aryNew.length; i++) {
			if (i == aryNew.length - 1) {
				aryNew[i][0] = code;
				aryNew[i][1] = value;
			} else {
				aryNew[i][0] = target[i][0];
				aryNew[i][1] = target[i][1];
			}
		}
		return aryNew;
	}
	
	/*		文字列関連	*/

	/**
	 * StringのNull、長さチェック
	 * @param str		対象String
	 * @return
	 * <p>Nullもしくは長さが0の場合true、そうでない場合false</p>
	 */
	public static boolean isNull(String str) {
		try {
			if (str == null || str.length() == 0) {
				return true;
			}
		} catch (NullPointerException e) {
			return true;
		}
		return false;
	}
	
	/**
	 * StringのNotNullチェック
	 * @param str		対象String
	 * @return
	 * <p>Nullもしくは長さが0以外の場合true、そうでない場合false</p>
	 */
	public static boolean isNotNull(String str) {
		return !isNull(str);
	}
	
	/**
	 * 改行表示処理
	 * @param aStr 改行対象文字列
	 * @return 改行後文字列
	 */
	public static String brHTML(String aStr) {
		char c;
		String strTarget = aStr != null ? aStr : "";
		StringBuffer returnStr = new StringBuffer();
		int length = strTarget.length();
		for (int i = 0; i < length; i++) {
			c = strTarget.charAt(i);
			if (c == '\n') {
				returnStr = returnStr.append("<br>");
			} else if (c == '<') {
				returnStr = returnStr.append("&lt;");
			} else if (c == '>') {
				returnStr = returnStr.append("&gt;");
			} else if (c == '&') {
				returnStr = returnStr.append("&amp;");
			} else if (c == '"') {
				returnStr = returnStr.append("&quot;");
			} else if (c == '\'') {
				returnStr = returnStr.append("&#39;");
			} else {
				returnStr = returnStr.append(c);
			}
		}
		return new String(returnStr);
	}
	
	/**
	 * ゼロ付の数字から整数へ変換
	 * @param number ゼロ付数字
	 * @return 整数
	 */
	public static String removeZero(String number) {
		return String.valueOf(Integer.parseInt(number));
	}
	
	/**
	 * 整数からゼロ付の数字へ変換
	 * @param number	数字
	 * @return String	数字（0~9）→（00~09）
	 */
	public static String addZero(int number) {
		StringBuffer sb = new StringBuffer();
		if (number < 10) {
			sb.append(CommonConst.NAM_COMMON_INTEGER_INITIAL_VALUE);
		}
		sb.append(number);
		return sb.toString();
	}
	
	/**
	 * 整数からゼロ付の数字へ変換
	 * @param number	数字
	 * @return String	数字（0~9）→（00~09）
	 */
	public static String addZero(String number) {
		StringBuffer sb = new StringBuffer();
		if (number.length() < 2) {
			sb.append(CommonConst.NAM_COMMON_INTEGER_INITIAL_VALUE);
		}
		sb.append(number);
		return sb.toString();
	}
	
	/**
	 * 郵便番号分離
	 * @param	code 郵便番号
	 * @return 前3桁
	 */
	public static String divideYubinCodeForward(String code) {
		return getIndexValue(code, CommonConst.STR_SEPARATOR, 0);
	}
	
	/**
	 * 郵便番号分離
	 * @param	code 郵便番号
	 * @return 後4桁
	 */
	public static String divideYubinCodeBackward(String code) {
		return getIndexValue(code, CommonConst.STR_SEPARATOR, 1);
	}
	
	/**
	 * 指定文字分割
	 * @param code 対象文字列
	 * @param sep 分割文字
	 * @return 	分割後配列
	 */
	public static String[] divide(String code, String sep) {
		String[] base = code.split(sep);
		String[] array = getBlankArrayOneDimension(base.length);
		int i = 0;
		for (String string : base) {
			array[i] = string;
			i++;
		}
		return array;
	}
	
	/**
	 * 指定文字分割
	 * @param code 対象文字列
	 * @param sep 分割文字
	 * @param count 分割文字数
	 * @return 	分割後配列
	 */
	public static String[] divide(String code, String sep, int count) {
		String[] base = code.split(sep);
		String[] array = getBlankArrayOneDimension(count + 1);
		int i = 0;
		for (String string : base) {
			array[i] = string;
			i++;
		}
		return array;
	}
	
	/**
	 * 指定文字結合
	 * @param array		対象配列
	 * @param sep 分割文字
	 * @return	string	結合文字列
	 */
	public static String combine(String[] array, String sep) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i]);
			if (i < array.length - 1) {
				sb.append(sep);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 指定文字結合
	 * @param front 前方文字列
	 * @param behind 後方文字列
	 * @param sep 分割文字
	 * @return 結合文字列
	 */
	public static String combine(Object front, Object behind, String sep) {
		return String.valueOf(front) + sep + String.valueOf(behind);
	}
	
	/**
	 * ハイフン分割
	 * @param code 対象データ
	 * @param hyphen ハイフン数
	 * @return 分割配列<br>
	 * ハイフンとハイフンの間に何も無い場合、
	 * 配列に「""」が代入される。
	 * 
	 */
	public static String[] divideByHyphen(String code, int hyphen) {
		return divide(code, CommonConst.STR_SEPARATOR, hyphen);
	}
	
	/**
	 * ハイフン分割
	 * @param code 対象データ
	 * @return 分割配列<br>
	 * ハイフンとハイフンの間に何も無い場合、
	 * 配列に「""」が代入される。<br>
	 * ハイフンで文字列が終わる場合、ハイフンの前の文字列までを、
	 * 配列にする。
	 */
	public static String[] divideByHyphen(String code) {
		return divide(code, CommonConst.STR_SEPARATOR);
	}
	
	/**
	 * ハイフン結合
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	public static String combineByHyphen(String[] array) {
		return combine(array, CommonConst.STR_SEPARATOR);
	}
	
	/**
	 * ハイフン結合
	 * @param front 前方文字列
	 * @param behind 後方文字列
	 * @return 結合文字列
	 */
	public static String combineByHyphen(Object front, Object behind) {
		return combine(front, behind, CommonConst.STR_SEPARATOR);
	}
	
	/**
	 * カンマ分割
	 * @param code 対象データ
	 * @param comma カンマ数
	 * @return 分割配列<br>
	 * カンマとカンマの間に何も無い場合、
	 * 配列に「""」が代入される。
	 * 
	 */
	public static String[] divideByComma(String code, int comma) {
		return divide(code, CommonConst.STR_UNDER_SEPARATOR, comma);
	}
	
	/**
	 * カンマ分割
	 * @param code 対象データ
	 * @return 分割配列<br>
	 * カンマとカンマの間に何も無い場合、
	 * 配列に「""」が代入される。
	 */
	public static String[] divideByComma(String code) {
		return divide(code, CommonConst.STR_UNDER_SEPARATOR);
	}
	
	/**
	 * カンマ結合
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	public static String combineByComma(String[] array) {
		return combine(array, CommonConst.STR_UNDER_SEPARATOR);
	}
	
	/**
	 * カンマ結合
	 * @param front 前方文字列
	 * @param behind 後方文字列
	 * @return 結合文字列
	 */
	public static String combineByComma(Object front, Object behind) {
		return combine(front, behind, CommonConst.STR_UNDER_SEPARATOR);
	}
	
	/**
	 * スラッシュ分割
	 * @param code		対象コード
	 * @return　分割配列
	 */
	public static String[] divideBySlash(String code) {
		return divide(code, CommonConst.STR_SLASH_SEPARATOR);
	}
	
	/**
	 * スラッシュ分割
	 * @param code		対象コード
	 * @param slash		スラッシュ数
	 * @return　分割配列
	 */
	public static String[] divideBySlash(String code, int slash) {
		return divide(code, CommonConst.STR_SLASH_SEPARATOR, slash);
	}
	
	/**
	 * スラッシュ結合
	 * @param front 前方文字列
	 * @param behind 後方文字列
	 * @return 結合文字列
	 */
	public static String combineBySlash(Object front, Object behind) {
		return combine(front, behind, CommonConst.STR_SLASH_SEPARATOR);
	}
	
	/**
	 * コードから指定箇所の文字列を取得
	 * @param code 対象文字列
	 * @param sep 分割文字
	 * @param index インデックス
	 * @return 取得対象文字列
	 */
	public static String getIndexValue(String code, String sep, int index) {
		String[] array = divide(code, sep);
		int i = 0;
		for (String string : array) {
			if (i == index) {
				return string;
			}
			i++;
		}
		return "";
	}
	
	/**
	 * nullに初期値をセット
	 * @param obj	対象Object
	 * @param init	初期値
	 * @return	string 変換文字列
	 */
	public static String convNullToInitialValue(Object obj, String init) {
		if (obj == null) {
			return init;
		}
		return (String)obj;
	}
	
	/**
	 * 文字列を分割する
	 * @param sspl1		対象文字列
	 * @param sspl2		含まれる文字列
	 * @param sspl3		前方後方フラグ
	 * @return	sspl3が0の場合、前方をそれ以外の場合後方を出力
	 */
	public static String splitStrings(String sspl1, String sspl2, int sspl3) {
		if (sspl1.length() > 0) {
			if (sspl1.indexOf(sspl2) != -1) {
				// 出現箇所
				int i = sspl1.indexOf(sspl2);
				if (sspl3 == 0) {
					return sspl1.substring(0, i);
				} else {
					return sspl1.substring(i + 1, sspl1.length());
				}
			} else {
				return sspl1;
			}
		} else {
			return "";
		}
	}
	
	/**
	 * 仮名文字列を半角カナへ統一
	 * @param input		対象仮名文字列
	 * @return	半角カナ変換後文字列
	 */
	public static String toHankakuKana(String input) {
		return KanaConvertUtility.convZenkakuToHankaku(KanaConvertUtility.convHiraGanaToHankaku(input));
	}
	
	/**
	 * 全角スペースを半角スペースへ変換
	 * @param input		全角スペースが含まれる文字列
	 * @return	全角スペースを半角スペースへ変換後の文字列
	 */
	public static String to1byteSpace(String input) {
		StringBuffer sb = new StringBuffer();
		String[] aryInput = input.split("　");
		for (int i = 0; i < aryInput.length; i++) {
			sb.append(aryInput[i]);
			if (i != aryInput.length - 1) {
				sb.append(CommonConst.NAM_COMMON_HALF_KANA_SPACE);
			}
		}
		return sb.toString();
	}
	
	/*	フラグ変換	*/

	/**
	 * フラグ変換（String→boolean）
	 * @param target 対象String
	 * @param trueflag trueを返す条件
	 * @param falseflag falseを返す条件
	 * @return 結果 どちらでもない場合false
	 */
	public static boolean convFlagToBoolean(String target, String trueflag, String falseflag) {
		if (target.equals(trueflag)) {
			return true;
		} else if (target.equals(falseflag)) {
			return false;
		}
		return false;
	}
	
	/**
	 * フラグ変換（String→boolean）
	 * @param target 対象String
	 * @param trueflag trueを返す条件
	 * @return 結果
	 */
	public static boolean convFlagToBoolean(String target, String trueflag) {
		if (target.equals(trueflag)) {
			return true;
		}
		return false;
	}
	
	/**
	 * フラグ変換（int→boolean）
	 * @param target 対象int
	 * @param trueflag trueを返す条件
	 * @return 結果
	 */
	public static boolean convFlagToBoolean(int target, int trueflag) {
		if (target == trueflag) {
			return true;
		}
		return false;
	}
	
	/**
	 * フラグ変換（boolean→String）
	 * @param isTrue 	trueの場合のString
	 * @param isFalse	falseの場合のString
	 * @param flag 		true or false
	 * @return	String 	判別名称
	 */
	public static String convFlagToString(String isTrue, String isFalse, boolean flag) {
		if (flag) {
			return isTrue;
		}
		return isFalse;
	}
	
	/**
	 * フラグ変換（boolean→String）
	 * @param flag 	true or false
	 * @return true…{@link CommonConst#NAM_COMMON_FLAG_OFF}、false…{@link CommonConst#NAM_COMMON_FLAG_ON}
	 */
	public static String convTrueIsOff(boolean flag) {
		if (flag) {
			return CommonConst.NAM_COMMON_FLAG_OFF;
		}
		return CommonConst.NAM_COMMON_FLAG_ON;
	}
	
	/**
	 * フラグ変換（boolean→String）
	 * @param flag 	true or false
	 * @return true…{@link CommonConst#NAM_COMMON_FLAG_ON}、false…{@link CommonConst#NAM_COMMON_FLAG_OFF}
	 */
	public static String convTrueIsOn(boolean flag) {
		if (flag) {
			return CommonConst.NAM_COMMON_FLAG_ON;
		}
		return CommonConst.NAM_COMMON_FLAG_OFF;
	}
	
	/**
	 * 記号で文字列を囲む
	 * @since	0.0.2
	 * @param value		対象文字列
	 * @param leftMark	左側の記号
	 * @param rightMark	右側の記号
	 * @return	変換後文字列
	 */
	public static String surroundMarks(String value, String leftMark, String rightMark) {
		StringBuffer sb = new StringBuffer();
		sb.append(leftMark);
		sb.append(value);
		sb.append(rightMark);
		return sb.toString();
	}
	
	/**
	 * 括弧で文字列を囲む
	 * @since	0.0.2
	 * @param value	対象文字列
	 * @return	(value)
	 */
	public static String surroundRoundBracket(String value) {
		return surroundMarks(value, CommonConst.NAM_ROUND_BRACKETS_LEFT, CommonConst.NAM_ROUND_BRACKETS_RIGHT);
	}
	
	/**
	 * 括弧で文字列を囲む
	 * @since	0.0.2
	 * @param value	対象文字列
	 * @return	【value】
	 */
	public static String surroundBracket(String value) {
		return surroundMarks(value, CommonConst.BRACKET_LEFT, CommonConst.BRACKET_RIGHT);
	}
	
	/**
	 * 指定文字列長の終点を三点リーダへ変換
	 * @param input 入力文字列
	 * @param outputLength 出力文字列長
	 * @return 出力文字列長までの文字列＋…
	 */
	public static String changeTerminal(String input, int outputLength) {
		int size = input.length();
		StringBuffer sb = new StringBuffer();
		if (size > outputLength) {
			sb.append(input.substring(0, outputLength - 1));
			sb.append(CommonConst.STR_ELLIPSIS);
		} else {
			sb.append(input);
		}
		return sb.toString();
	}
	
	/**
	 * @param code 対象コード
	 * @return
	 * <p>
	 * 対象コードが{@link CommonConst#NAM_COMMON_FLAG_ON}の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isFlagOn(String code) {
		return CommonConst.NAM_COMMON_FLAG_ON.equals(code);
	}
	
	/**
	 * @param code 対象コード
	 * @return
	 * <p>
	 * 対象コードが{@link CommonConst#NAM_COMMON_FLAG_OFF}の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isFlagOff(String code) {
		return CommonConst.NAM_COMMON_FLAG_OFF.equals(code);
	}
	
	/**
	 * フラグ用配列の生成
	 * @param flagOffName {@link CommonConst#NAM_COMMON_FLAG_OFF}の名称
	 * @param flagOnName {@link CommonConst#NAM_COMMON_FLAG_ON}の名称
	 * @return
	 * <p>
	 * [0]…{@link CommonConst#NAM_COMMON_FLAG_OFF}、<br>
	 * [1]…{@link CommonConst#NAM_COMMON_FLAG_ON}、
	 * </p>
	 */
	public static String[][] getFlagArray(String flagOffName, String flagOnName) {
		String[][] aryFlag = getBlankArray(2);
		aryFlag[0][0] = CommonConst.NAM_COMMON_FLAG_OFF;
		aryFlag[0][1] = convNullToInitialValue(flagOffName, "");
		aryFlag[1][0] = CommonConst.NAM_COMMON_FLAG_ON;
		aryFlag[1][1] = convNullToInitialValue(flagOnName, "");
		return aryFlag;
	}
	
}
