// IO
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
// Text
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
// Util
import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import jp.co.hitachi_sk.cool.util.string.converter.AlphabetConverterFromZenkakuToHankaku;
import jp.co.hitachi_sk.cool.util.string.converter.KatakanaConverterFromZenkakuToHankaku;
import jp.co.hitachi_sk.cool.util.string.converter.NumberConverterFromZenkakuToHankaku;
import jp.co.hitachi_sk.cool.util.string.converter.SymbolConverterFromZenkakuToHankaku;
// Apache
import org.apache.commons.validator.GenericValidator;
/**
* <p> [機 能] 文字列ユーティリティ</p>
* <p> [説 明] 文字列に関するユーティリティです。</p>
* <p> [備 考] 特になし</p>
* @author [作 成] 0000/00/00 氏名<br>
* @version 1.0 0000/00/00
*/
public final class StringUtil {
/** インスタンス生成抑止 */
private StringUtil() {
}
/** ASCII_CHAR_0X21 */
private static final int ASCII_CHAR_0X21 = 0x21;
/** ASCII_CHAR_0X7E */
private static final int ASCII_CHAR_0X7E = 0x7E;
/** EXPRESSION_NUMERIC */
private static final String EXPRESSION_NUMERIC = "^(-[0-9])?[0-9]*$";
/** TRIM_FULL_SPACE */
private static final String TRIM_FULL_SPACE = "[ ]*$";
/** TRIM_HALF_SPACE */
private static final String TRIM_HALF_SPACE = "[ ]*$";
/** STRING_ZERO */
private static final String STRING_ZERO = "0";
/** CHAR_ZERO */
private static final char CHAR_ZERO = '0';
/** CHAR_NINE */
private static final char CHAR_NINE = '9';
/** CHAR_LOWER_A */
private static final char CHAR_LOWER_A = 'a';
/** CHAR_LOWER_Z */
private static final char CHAR_LOWER_Z = 'z';
/** CHAR_UPPER_A */
private static final char CHAR_UPPER_A = 'A';
/** CHAR_UPPER_Z */
private static final char CHAR_UPPER_Z = 'Z';
/** ENCODE_MS932 */
private static final String ENCODE_MS932 = "MS932";
/** STRING_EMPTY */
private static final String STRING_EMPTY = "";
/** 全角スペース */
public static final char WS_CHAR = ' ';
/** 半角スペース */
public static final char S_CHAR = ' ';
/** 半角ゼロ */
public static final char Z_CHAR = '0';
/** LF */
public static final byte LF_CHAR = 0x0A;
/** 全角スペース */
private static final String WS_STRING = " ";
/** 半角スペース */
private static final String S_STRING = " ";
/** 全角左括弧 */
public static final char WKL_CHAR = '（';
/** 半角左括弧 */
public static final char KL_CHAR = '(';
/** 全角右括弧 */
public static final char WKR_CHAR = '）';
/** 半角右括弧 */
public static final char KR_CHAR = ')';
/** BRの定數 */
public static final String HTMLBR = "<br>";
/** ブランクの定數 */
public static final String BLACK = "";
/** キー */
public static final String KEY = "key";
/** 半角スーベース */
public static final String SPACE = " ";
/** の定數 */
public static final String NBSP = " ";
/**
* <P>パディングデータ</P>
*/
private static final String[] PADDING_DATA = new String[Character.MAX_VALUE];
static {
//128char
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
PADDING_DATA[WS_CHAR] = " ";
PADDING_DATA[S_CHAR] = " ";
PADDING_DATA[Z_CHAR] = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
}
/**
* <P>SJIS</P>
*/
private static final char SJIS_WD = 0x301c;
/**
* <P>MS932</P>
*/
private static final char MS932_WD = 0xff5e;
/**
* <P>MS932(記號)</P>
*/
private static final char[] MS932_U = {
/* ￥, ~, ～, ∥, －, ￠, ￡, ￢ ―*/
0x005C, 0x007E, 0xFF5E, 0x2225, 0xFF0D, 0xFFE0, 0xFFE1, 0xFFE2, 0x2015
};
/**
* <P>ISO2022(記號)</P>
*/
private static final char[] ISO2022JP_U = {
0x00A5, 0x203E, 0x301C, 0x2016, 0x2212, 0x00A2, 0x00A3, 0x00AC, 0x2014
};
/**
* <P>EUC-JP(記號)</P>
*/
private static final char[] EUCJP_U = {
0x005c, 0x007E, 0x301C, 0x2016, 0x2212, 0x00A2, 0x00A3, 0x00AC, 0x2014
};
/**
* <P>文字列検索パターン(CRLF or CR or LF)</P>
*/
public static final String PTN_NEW_LINE = "\r\n|[\r\n]";
/**
* <P>畫面TextArea改行コード(CRLF)</P>
*/
public static final String STR_NEW_LINE = "\r\n";
/**
* <P>「？」</P>
*/
public static final String QUESTION_STRING = "？";
/**
* <P>全角カナ濁點</P>
*/
public static final String WDAKUTEN_STRING = "゛";
/**
* <P>全角カナ半濁點</P>
*/
public static final String WHANDAKUTEN_STRING = "゜";
/**
* <P>全角カナ濁點変換テーブル</P>
*/
public static final String[][] WKANA_DAKUTEN_TABLE = {
{ "ウ゛", "ヴ" },
{ "カ゛", "ガ" },
{ "キ゛", "ギ" },
{ "ク゛", "グ" },
{ "ケ゛", "ゲ" },
{ "コ゛", "ゴ" },
{ "サ゛", "ザ" },
{ "シ゛", "ジ" },
{ "ス゛", "ズ" },
{ "セ゛", "ゼ" },
{ "ソ゛", "ゾ" },
{ "タ゛", "ダ" },
{ "チ゛", "ヂ" },
{ "ツ゛", "ヅ" },
{ "テ゛", "デ" },
{ "ト゛", "ド" },
{ "ハ゛", "バ" },
{ "ヒ゛", "ビ" },
{ "フ゛", "ブ" },
{ "ヘ゛", "ベ" },
{ "ホ゛", "ボ" },
};
/**
* <P>全角カナ半濁點変換テーブル</P>
*/
public static final String[][] WKANA_HANDAKUTEN_TABLE = {
{ "ハ゜", "パ" },
{ "ヒ゜", "ピ" },
{ "フ゜", "プ" },
{ "ヘ゜", "ペ" },
{ "ホ゜", "ポ" },
};
/**
* <P>ひらがな濁點変換テーブル</P>
*/
public static final String[][] WHIRA_DAKUTEN_TABLE = {
{ "か゛", "が" },
{ "き゛", "ぎ" },
{ "く゛", "ぐ" },
{ "け゛", "げ" },
{ "こ゛", "ご" },
{ "さ゛", "ざ" },
{ "し゛", "じ" },
{ "す゛", "ず" },
{ "せ゛", "ぜ" },
{ "そ゛", "ぞ" },
{ "た゛", "だ" },
{ "ち゛", "ぢ" },
{ "つ゛", "づ" },
{ "て゛", "で" },
{ "と゛", "ど" },
{ "は゛", "ば" },
{ "ひ゛", "び" },
{ "ふ゛", "ぶ" },
{ "へ゛", "べ" },
{ "ほ゛", "ぼ" },
};
/**
* <P>ひらがな半濁點変換テーブル</P>
*/
public static final String[][] WHIRA_HANDAKUTEN_TABLE = {
{ "は゜", "ぱ" },
{ "ひ゜", "ぴ" },
{ "ふ゜", "ぷ" },
{ "へ゜", "ぺ" },
{ "ほ゜", "ぽ" },
};
/** ひらがな入力項目許容文字 */
private static final String HIRAGANA_ALLOW_CHARS =
// 全角スペース
" " +
// 半角スペース
" " +
// ひらがな
"ーぁあぃいぅうぇえぉおかがきぎく" +
"ぐけげこごさざしじすずせぜそぞた" +
"だちぢっつづてでとどなにぬねのは" +
"ばぱひびぴふぶぷへべぺほぼぽまみ" +
"むめもゃやゅゆょよらりるれろゎわ" +
"ゐゑをん‐";
/** 全角カナ入力項目許容文字 */
private static final String ZENKAKUKANA_ALLOW_CHARS =
// 全角スペース
" " +
// 半角スペース
" " +
// 全角カタカナ
"ーァアィイゥウェエォオカガキギク" +
"グケゲコゴサザシジスズセゼソゾタ" +
"ダチヂッツヅテデトドナニヌネノハ" +
"バパヒビピフブプヘベペホボポマミ" +
"ムメモャヤュユョヨラリルレロヮワ" +
"ヰヱヲンヴヵヶ‐";
/** 半角カナ入力項目許容文字 */
private static final String HANKAKUKANA_ALLOW_CHARS =
// 半角カタカナ
"ｰｧｱｨｲｩｳｪｴｫｵｶｷｸｹｺｻｼｽｾｿﾀﾁｯﾂﾃﾄﾅﾆﾇﾈﾉ" +
"ﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓｬﾔｭﾕｮﾖﾗﾘﾙﾚﾛﾜｦﾝﾞﾟ";
// Shift-JISコード判別用（第一バイト）
private static int[][] byte1 = { {0x81,0x81}, // 81
{0x82,0x82}, // 82
{0x83,0x83}, // 83
{0x84,0x84}, // 84
{0x88,0x88}, // 88
{0x89,0x97}, // 89～97
{0x98,0x98}, // 98
{0xEA,0xEA}, // EA
{0x99,0x9F}, // 99～9F
{0xE0,0xE9} // E0～E9
};
// Shift-JISコード判別用（第二バイト）
private static int[][][] byte2 = {{{0x40,0x40},{0xFC,0xFC},{0x41,0xAC},{0xB8,0xBF},{0xC8,0xCE},{0xDA,0xE8},{0xF0,0xF7}}, //1行目２バイト
{{0x4F,0x58},{0x60,0x79},{0x81,0x9A},{0x9F,0xF1}}, //２行目２バイト
{{0x40,0x96},{0x9F,0xB6},{0xBF,0xD6}},
{{0x40,0x60},{0x70,0x91},{0x9F,0xBE}},
{{0x9F,0xFC}},
{{0x40,0xFC}},
{{0x40,0x73},{0x9F,0xFC}},
{{0x40,0xA2}},
{{0x40,0xFC}},
{{0x40,0xFC}}
};
/** <、>、&、"、'を含む文字列（複數行にも対応） */
private static final String CHARACTER_CRITICAL = "(?s).*(<|>|&|\"|\').*";
/**
* <p> [機 能]數値の文字列化</p>
* <p> [説 明]數値を指定した長さの文字へ変換し、指定文字でパディングする。</p>
* <p> [備 考]左側にパディングする。</p>
* @param intData 対象數値
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String leftPad(int intData, int size, char padChar) {
return leftPad(Integer.toString(intData),size,padChar);
}
/**
* <p> [機 能]數値の文字列化</p>
* <p> [説 明]數値を指定した長さの文字へ変換し、指定文字でパディングする。</p>
* <p> [備 考]左側にパディングする。</p>
* @param longData 対象數値
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String leftPad(long longData, int size, char padChar) {
return leftPad(Long.toString(longData),size,padChar);
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列を指定數分、指定文字でパディングする。</p>
* <p> [備 考]左側にパディングする。</p>
* @param paramStrData 対象文字列
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String leftPad(String paramStrData, int size, char padChar) {
String pad = PADDING_DATA[padChar];
String strData = paramStrData;
if (pad == null) {
//対応
int len = size - strData.length();
for (int i = 0; i < len; i++) {
strData = padChar + strData;
}
return strData;
}
if (strData == null) {
return null;
}
int pads = size - strData.length();
if (pads <= 0) {
return strData;
}
if (pads > pad.length()) {
return leftPad(pad.concat(strData), size, padChar);
}
return pad.substring(0,pads).concat(strData);
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列を指定バイト數分、指定文字でパディングする。</p>
* <p> [備 考]左側にパディングする。</p>
* @param paramStrData 対象文字列
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String leftPadByte(String paramStrData, int size, char padChar) {
String pad = PADDING_DATA[padChar];
String strData = paramStrData;
String strPad = null;
try {
if (pad == null) {
//対応
int len = size - strData.getBytes(ENCODE_MS932).length;
for (int i = 0; i < len; i++) {
strData = padChar + strData;
strPad = new Character(padChar).toString();
if (strPad.getBytes(ENCODE_MS932).length == 2) {
i++;
}
}
return strData;
}
if (strData == null) {
return null;
}
int pads = size - strData.getBytes(ENCODE_MS932).length;
if (pads <= 0) {
return strData;
}
if (pads > pad.getBytes(ENCODE_MS932).length) {
return leftPad(pad.concat(strData), size, padChar);
}
return pad.substring(0,pads).concat(strData);
} catch(UnsupportedEncodingException uee) {
return null;
}
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列を指定數分、指定文字でパディングする。</p>
* <p> [備 考]右側にパディングする。</p>
* @param paramStrData 対象文字列
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String rightPad(String paramStrData, int size, char padChar) {
String pad = PADDING_DATA[padChar];
String strData = paramStrData;
if (pad == null) {
//対応
int len = size - strData.length();
for (int i = 0; i < len; i++) {
strData = strData+padChar;
}
return strData;
}
if (strData == null) {
return null;
}
int pads = size - strData.length();
if (pads <= 0) {
return strData;
}
if (pads > pad.length()) {
return rightPad(strData.concat(pad), size, padChar);
}
return strData.concat(pad.substring(0,pads));
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列を指定バイト數分、指定文字でパディングする。</p>
* <p> [備 考]右側にパディングする。</p>
* @param paramStrData 対象文字列
* @param size パディングサイズ
* @param padChar パディング文字
* @return String パディングされた文字列
*/
public static final String rightPadByte(String paramStrData, int size, char padChar) {
String pad = PADDING_DATA[padChar];
String strData = paramStrData;
String strPad = null;
try {
if (pad == null) {
//対応
int len = size - strData.getBytes(ENCODE_MS932).length;
for (int i = 0; i < len; i++) {
strData = strData+padChar;
strPad = new Character(padChar).toString();
if (strPad.getBytes(ENCODE_MS932).length == 2) {
i++;
}
}
return strData;
}
if (strData == null) {
return null;
}
int pads = size - strData.getBytes(ENCODE_MS932).length;;
if (pads <= 0) {
return strData;
}
if (pads > pad.getBytes(ENCODE_MS932).length) {
return rightPad(strData.concat(pad), size, padChar);
}
return strData.concat(pad.substring(0,pads));
} catch(UnsupportedEncodingException uee) {
return null;
}
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]対象文字列からターゲット文字をトリムする。</p>
* <p> [備 考]なし</p>
* @param strData 対象文字列
* @param targetChar トリム文字
* @return String トリムされた文字列
*/
public static final String trim(String strData,char targetChar) {
final int len = strData.length();
int st = 0;
int ed = len - 1;
while (st <= ed) {
if(targetChar != strData.charAt(st)){
break;
}
st++;
}
while (st <= ed) {
if(targetChar != strData.charAt(ed)){
break;
}
ed--;
}
if (st == 0 && ed == len - 1) {
return strData;
}
return strData.substring(st, ed + 1);
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]対象文字列からターゲット文字をトリムする。</p>
* <p> [備 考]なし</p>
* @param strData 対象文字列
* @param targetChar トリム文字
* @return String トリムされた文字列
*/
public static final String leftTrim(String strData,char targetChar) {
final int len = strData.length();
int st = 0;
int ed = len - 1;
while (st <= ed) {
if(targetChar != strData.charAt(st)){
break;
}
st++;
}
if (st == 0) {
return strData;
}
return strData.substring(st, ed + 1);
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]対象文字列からターゲット文字をトリムする。</p>
* <p> [備 考]なし</p>
* @param strData 対象文字列
* @param targetChar トリム文字
* @return String トリムされた文字列
*/
public static final String rightTrim(String strData,char targetChar) {
final int len = strData.length();
int st = 0;
int ed = len - 1;
while (st <= ed) {
if(targetChar != strData.charAt(ed)){
break;
}
ed--;
}
if (ed == len - 1) {
return strData;
}
return strData.substring(st, ed + 1);
}
/**
* <p>[説 明] 指定した文字列の末端の半角、全角空白文字を取り除きます。</p>
* <p>[備 考] インスタンスが null 値の場合、長さ 0 の文字列を返します。</p>
* @param paramText トリミング対象の文字列。
* @return トリミングされた文字列。
*/
public static String trimEx(String paramText) {
String text = paramText;
if (text == null) {
return STRING_EMPTY;
} else {
int len = text.length();
char c = ' ';
int endIndex = 0;
for (int i=0;i<len;i++) {
c = text.charAt((len - 1) - i);
if (c != ' ' && c != ' ') {
endIndex = len - i;
break;
}
}
return text.substring(0, endIndex);
}
}
/**
* <p>[機 能] 文字列操作</p>
* <p>[説 明] 文字列をひらがな入力支援機能に従い変換する。</p>
* <p>[備 考] なし</p>
* @param paramStr 対象文字列
* @return String 変換された文字列
*/
public static final String convZenkakuForInputAssist(String paramStr) {
String str = paramStr;
str = convHankakuSpToZenkakuSp(str); // 半角スペース→全角スペース変換
str = convHankakuMKToZenkakuMK(str); // 半角丸括弧→全角丸括弧
str = convZenkakuSonantMark(str); // ひらがな濁點・半濁點変換
return str;
}
/**
* <p>[機 能] 文字列操作</p>
* <p>[説 明] 文字列を全角カナ入力支援機能に従い変換する。</p>
* <p>[備 考] なし</p>
* @param paramStr 対象文字列
* @return String 変換された文字列
*/
public static final String convZenkakuKanaForInputAssist(String paramStr) {
String str = paramStr;
str = convHankakuSpToZenkakuSp(str); // 半角スペース→全角スペース変換
str = convHankakuMKToZenkakuMK(str); // 半角丸括弧→全角丸括弧
str = convZenkakuKanaSonantMark(str); // 濁點・半濁點変換
return str;
}
/**
* <p>[機 能] 文字列操作</p>
* <p>[説 明] 文字列內に含まれるすべての半角スペースを全角スペースへ変換する。</p>
* <p>[備 考] なし</p>
* @param str 対象文字列
* @return String 変換された文字列
*/
public static final String convHankakuSpToZenkakuSp(String str) {
if (str == null) {
return null;
}
return str.replace(S_CHAR, WS_CHAR);
}
/**
* <p>[機 能] 文字列操作</p>
* <p>[説 明] 文字列內に含まれるすべての半角丸括弧を全角丸括弧へ変換する。</p>
* <p>[備 考] なし</p>
* @param str 対象文字列
* @return String 変換された文字列
*/
public static final String convHankakuMKToZenkakuMK(String str) {
String ret = null;
if (str == null) {
return null;
}
ret = str.replace(KL_CHAR, WKL_CHAR);
ret = ret.replace(KR_CHAR, WKR_CHAR);
return ret;
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列內に含まれるすべてのひらがな濁點・半濁點を変換する。</p>
* <p> [備 考]変換例：か゛→が、は゜→ぱ</p>
* @param paramStr 対象文字列
* @return String 変換された文字列
*/
public static final String convZenkakuSonantMark(String paramStr) {
String str = paramStr;
if (str == null) {
return null;
}
// 文字列內に濁點文字が存在する場合は、濁點の変換を行う。
if (str.indexOf(WDAKUTEN_STRING) != -1) {
for (int i = 0; i < WHIRA_DAKUTEN_TABLE.length; i++) {
str = str.replaceAll(WHIRA_DAKUTEN_TABLE[i][0], WHIRA_DAKUTEN_TABLE[i][1]);
}
str = str.replaceAll(WDAKUTEN_STRING, STRING_EMPTY); // 不要な濁點文字を削除する。
}
// 文字列內に半濁點文字が存在する場合は、半濁點の変換を行う。
if (str.indexOf(WHANDAKUTEN_STRING) != -1) {
for (int i = 0; i < WHIRA_HANDAKUTEN_TABLE.length; i++) {
str = str.replaceAll(WHIRA_HANDAKUTEN_TABLE[i][0], WHIRA_HANDAKUTEN_TABLE[i][1]);
}
str = str.replaceAll(WHANDAKUTEN_STRING, STRING_EMPTY); // 不要な半濁點文字を削除する。
}
return str;
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]文字列內に含まれるすべての全角カナ濁點・半濁點を変換する。</p>
* <p> [備 考]変換例：カ゛→ガ、ハ゜→パ、ア゛→ア</p>
* @param paramStr 対象文字列
* @return String 変換された文字列
*/
public static final String convZenkakuKanaSonantMark(String paramStr) {
String str = paramStr;
if (str == null) {
return null;
}
// 文字列內に濁點文字が存在する場合は、濁點の変換を行う。
if (str.indexOf(WDAKUTEN_STRING) != -1) {
for (int i = 0; i < WKANA_DAKUTEN_TABLE.length; i++) {
str = str.replaceAll(WKANA_DAKUTEN_TABLE[i][0], WKANA_DAKUTEN_TABLE[i][1]);
}
str = str.replaceAll(WDAKUTEN_STRING, STRING_EMPTY); // 不要な濁點文字を削除する。
}
// 文字列內に半濁點文字が存在する場合は、半濁點の変換を行う。
if (str.indexOf(WHANDAKUTEN_STRING) != -1) {
for (int i = 0; i < WKANA_HANDAKUTEN_TABLE.length; i++) {
str = str.replaceAll(WKANA_HANDAKUTEN_TABLE[i][0], WKANA_HANDAKUTEN_TABLE[i][1]);
}
str = str.replaceAll(WHANDAKUTEN_STRING, STRING_EMPTY); // 不要な半濁點文字を削除する。
}
return str;
}
/**
* <p>[説 明] 文字列內に含まれるすべての改行を全角スペースへ変換します。</p>
* @param str 変換前の文字列
* @return String 変換後の文字列
*/
public static String newLineToZenkakuSp(String str) {
if (str == null) {
return null;
}
return str.replaceAll(PTN_NEW_LINE, WS_STRING);
}
/**
* <p>[機 能] 指定した數字を文字列に変換します。</p>
* <p>[説 明] 指定した桁數に満たない場合、桁數分、左を 0 で埋めます。</p>
* @param value 変換する數値。
* @param length 変換後の文字列。
* @return 変換された文字列。
*/
public static String intToString(int value, int length) {
String text = Integer.toString(value);
int cnt = length - text.length();
for (int i = 0; i < cnt; i++) {
text = STRING_ZERO + text;
}
return text;
}
/**
* <p>[機 能] この文字列內にある、すべてのJISX0208-1983範囲外の全角文字を、</p>
* <p>[説 明] 「？」に置換した結果生成される、新しい文字列を返します。</p>
* @param str 変換対象の文字列
* @return String 変換後の文字列
* @throws UnsupportedEncodingException
*/
public static String replaceOutside2Question(String str) throws UnsupportedEncodingException {
// NULLのチェック
if (str == null) {
return null;
}
// バイト列に変換
byte[] by = str.getBytes(ENCODE_MS932);
// 1文字(2バイト)づつ処理
String buf = new String();
for (int i = 0; i < by.length; i = i + 2) {
// JISX0208-1983範囲外の文字でないかチェック
if (isJISX0208_1983((by[i] & 0xff), by[i + 1] & 0xff)) {
buf = buf + new String(by, i, 2, ENCODE_MS932);
}
else {
buf = buf + QUESTION_STRING;
}
}
return buf;
}
/**
* <p>[説 明] この文字が、JISX0208-1983の範囲內であるかをチェックし、結果を返します。</p>
* @param up 上位1バイト
* @param low 下位1バイト
* @return boolean 変換後の文字列
*/
public static boolean isJISX0208_1983(int up, int low) {
for (int i = 0; i < byte1.length; i++) {
if ((up >= byte1[i][0]) && (up <= byte1[i][1])) {
for (int j = 0; j < byte2[i].length; j++) {
if ((low >= byte2[i][j][0]) && (low <= byte2[i][j][1])) {
return true;
}
}
}
}
return false;
}
/**
* <p> [機 能] 文字列操作</p>
* <p> [説 明] 指定された文字列中に含まれるSJIS形式の'～'(WAVE_DASH)をMS932形式へ変換</p>
* <p> [備 考] なし</p>
* @param strData 対象文字列
* @return String 文字コード変換された文字列
*/
public static final String wdCnv(String strData) {
if (strData != null){
return strData.replace(SJIS_WD, MS932_WD);
}else{
return strData;
}
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]MS932からISO2022へ文字コード変換する。</p>
* <p> [備 考]なし</p>
* @param strData 対象文字列
* @return String 文字コード変換された文字列
*/
public static final String MS932toISO2022(String strData) {
final int len = MS932_U.length;
String result = null;
if (strData != null){
result = strData;
for(int i=0;i<len;i++){
result = result.replace(MS932_U[i],ISO2022JP_U[i]);
}
}else{
return strData;
}
return result;
}
/**
* <p>MS932からEUC_JPへの変換</p>
* @param str MS932文字列
* @return String EUC_JP文字列
*/
public static final String MS932toEUCJP(String str) {
final int length = MS932_U.length;
String result = null;
if (str != null){
result = str;
for(int i=0; i < length; i++){
result = result.replace(MS932_U[i], EUCJP_U[i]);
}
}else{
return str;
}
return result;
}
/**
* <p> [機 能]文字列操作</p>
* <p> [説 明]ISO2022からMS932へ文字コード変換する。</p>
* <p> [備 考]なし</p>
* @param strData 対象文字列
* @return String 文字コード変換された文字列
*/
public static final String ISO2022toMS932(String strData) {
final int len = MS932_U.length;
String result = null;
if (strData != null){
result = strData;
for(int i=0;i<len;i++){
result = result.replace(ISO2022JP_U[i],MS932_U[i]);
}
}else{
return strData;
}
return result;
}
/**
* ひらがなチェック<BR>
* @param str
* @return 全角カナの場合はTrue
*/
public static boolean isHiragana(String str) {
final String START = "^[";
final String END = "]*$";
return str.matches(START + HIRAGANA_ALLOW_CHARS + END);
}
/**
* 全角カナチェック<BR>
* @param str
* @return 全角カナの場合はTrue
*/
public static boolean isZenkakuKana(String str) {
final String START = "^[";
final String END = "]*$";
return str.matches(START + ZENKAKUKANA_ALLOW_CHARS + END);
}
/**
* 半角カナチェック<BR>
* @param str
* @return 半角カナの場合はTrue
*/
public static boolean isHankakuKana(String str) {
final String START = "^[";
final String END = "]*$";
return str.matches(START + HANKAKUKANA_ALLOW_CHARS + END);
}
/**
* ゼロチェックメソッド
* @param str チェックする文字列
* @return 全ての文字が"0"かどうか
*/
public static boolean isZero(String str){
for (int i=0;i < str.length();i++) {
char charData = str.charAt(i);
if (charData != CHAR_ZERO){
return false;
}
}
return true;
}
/**
* <P>ASCII數字チェッククラス</P>
* @param str チェックする文字列
* @return アスキー數字かどうか
*/
public static boolean isAsciiNumber(String str) {
for (int i = 0; i < str.length(); i++ ) {
char charData = str.charAt(i);
if (charData < 0x30 || charData > 0x39) {
return false;
}
}
return true;
}
/**
* <P>16進數字チェッククラス</P>
* @param str チェックする文字列
* @return 16進數字かどうか
*/
public static boolean isHexNumber(String str) {
for (int i = 0; i < str.length(); i++ ) {
char charData = str.charAt(i);
if (charData < 0x30) {
return false;
} else if (0x39 < charData && charData < 0x41) {
return false;
} else if (0x46 < charData && charData < 0x61) {
return false;
} else if (0x66 < charData) {
return false;
}
}
return true;
}
/**
* 數字チェック
* @param str チェックする文字列
* @return 數字だけの文字列かどうか
*/
public static boolean isNumericChar(String str){
// 初期化
String value = null;
value = str;
// 空でない
if (!StringUtil.required(value) == false) {
// 數字が指定文字數以上含まれているか
if (isIncludeNumericChar(value, value.length()) == false) {
return false;
}
}
return true;
}
/**
* <p>[機能] 英字チェック</p>
* <p>[説明] 英字かどうか</p>
* @param str
* @return 全ての文字が英字の場合true
*/
public static boolean isAlphabet(String str) {
// 全文字をチェック
for (int i = 0; i < str.length(); i++ ) {
char charData = str.charAt(i);
// A～Z、a～zの範囲外の文字だった場合false
if (((charData < CHAR_UPPER_A) || (charData > CHAR_UPPER_Z)) &&
((charData < CHAR_LOWER_A) || (charData > CHAR_LOWER_Z))) {
return false;
}
}
return true;
}
/**
* <p>[機能] 英數字チェック</p>
* <p>[説明] 英數字かどうか</p>
* @param str チェックする文字列
* @return 英數字だけの文字列かどうか
*/
public static boolean isAlphaNumber(String str) {
for (int i = 0; i < str.length(); i++ ) {
char charData = str.charAt(i);
if (((charData < CHAR_UPPER_A) || (charData > CHAR_UPPER_Z)) &&
((charData < CHAR_LOWER_A) || (charData > CHAR_LOWER_Z)) &&
((charData < CHAR_ZERO) || (charData > CHAR_NINE))) {
return false;
}
}
return true;
}
/**
* <p>[機能] 英數字記號チェック</p>
* <p>[説明] 英數字記號かどうか</p>
* @param str チェックする文字列
* @return 英數字と記號だけの文字列かどうか
*/
public static boolean isAlphaNumberSymbol(String str) {
for (int i = 0; i < str.length(); i++ ) {
char charData = str.charAt(i);
if (charData < 0x21 || charData > ASCII_CHAR_0X7E) {
return false;
}
}
return true;
}
/**
* 數字包含チェッククラス
* @param str チェックする文字列
* @param num 含まれていなければならない文字數
* @return 含まれるべき數に足りているかどうか
*/
public static boolean isIncludeNumericChar(String str, int num){
int count = 0;
// 文字列の長さが足りてないときは論外
if (str.length() < num){
return false;
}
// 文字列を扱う準備
CharacterIterator iter = new StringCharacterIterator(str);
// 1文字目から最終文字まで、1文字ずつチェック
for (char c = iter.first();
c != CharacterIterator.DONE;
c = iter.next()){
// '0'～'9'であればカウント
if (c >= CHAR_ZERO && c <= CHAR_NINE){
count++;
}
// カウントが設定値に達したら、trueを戻して終了
if (num <= count){
return true;
}
}
// カウントが設定値に達しなかったら、falseを戻す
return false;
}
/**
* 符號付數字(仮)のチェック
* @param str
* @return 符號付數字かどうか
*/
public static boolean isSignMoney(String str) {
// 屬性「S9」のチェックを作成
// 今はマイナスのみ可
return str.matches(EXPRESSION_NUMERIC);
}
/**
* <p>[機能] 小文字チェック</p>
* <p>[説明] 小文字かどうか</p>
* @param str
* @return 全ての文字が小文字だった場合True
*/
public static boolean isLower(String str) {
String lower = str.toLowerCase();
return lower.equals(str);
}
/**
* <p>[機能] 大文字チェック</p>
* <p>[説明] 大文字かどうか</p>
* @param str
* @return 全ての文字が大文字だった場合True
*/
public static boolean isUpper(String str) {
String upper = str.toUpperCase();
return upper.equals(str);
}
/**
* <p>[機能] 全角チェック</p>
* <p>[説明] 指定された文字列の全角チェック（定義されたShift-JISコードの範囲であるかどうか）</p>
* <p>[備考] なし</p>
* @param str チェックする文字列
* @return 全角文字かどうか
*/
public static boolean isZenkaku(String str) {
// Windows-31Jコードの文字セットを取得
CharsetEncoder encoder = Charset.forName("Windows-31J").newEncoder();
encoder.reset();
boolean spp_flg = true; // 判定用
char[] ch = new char[1]; // チェック文字格納用
CharBuffer cb; // ByteBuffer生成用
ByteBuffer bb; // ByteBuffer変換格納用
int ccode = 0; // Windows31J変換格納用
try {
// １文字毎にサポート文字範囲內かチェックする
for (int idx = 0; idx < str.length(); idx++) {
ch[0] = str.charAt(idx);
cb = CharBuffer.wrap(ch);
bb = encoder.encode(cb);
// 半角文字の場合、不正とする
if (bb.limit() == 1) {
spp_flg = false;
break;
// 半角文字以外、２バイト取得
} else {
ccode = bb.getChar();
}
// tabコードチェック
if (ccode == 0x0009) {
spp_flg = false;
break;
}
// サポート文字セットに該當するか
if ((ccode >= 0x0000 && ccode <= 0x007F)
|| (ccode >= -95 && ccode <= -33)
|| (ccode >= 0x889F && ccode <= 0x9872)
|| (ccode >= 0x989F && ccode <= 0x9FFC)
|| (ccode >= 0xE040 && ccode <= 0xEAA4)
|| (ccode >= 0x8740 && ccode <= 0x879C)
|| (ccode >= 0xED40 && ccode <= 0xEEFC)
|| (ccode >= 0xFA40 && ccode <= 0xFC4B)
|| (ccode >= 0x8140 && ccode <= 0x81AC)
|| (ccode >= 0x81B8 && ccode <= 0x81BF)
|| (ccode >= 0x81C8 && ccode <= 0x81CE)
|| (ccode >= 0x81DA && ccode <= 0x81E8)
|| (ccode >= 0x81F0 && ccode <= 0x81F7)
|| (ccode == 0x81FC)
|| (ccode >= 0x824F && ccode <= 0x8258)
|| (ccode >= 0x8260 && ccode <= 0x8279)
|| (ccode >= 0x8281 && ccode <= 0x829A)
|| (ccode >= 0x829F && ccode <= 0x82F1)
|| (ccode >= 0x8340 && ccode <= 0x8396)
|| (ccode >= 0x839F && ccode <= 0x83B6)
|| (ccode >= 0x83BF && ccode <= 0x83D6)
|| (ccode >= 0x8440 && ccode <= 0x8460)
|| (ccode >= 0x8470 && ccode <= 0x8491)
|| (ccode >= 0x849F && ccode <= 0x84BE)) {
spp_flg = true;
} else {
spp_flg = false;
break;
}
}
} catch(CharacterCodingException cce) {
return false;
}
return spp_flg;
}
/**
* 全角チェック
* @param value 判定値
* @return 全角文字かどうか
*/
public static boolean isFull(String value) {
try {
byte[] targetByte = value.getBytes(ENCODE_MS932);
return (targetByte.length % 2 == 0) && (targetByte.length / 2 == value.length());
} catch (UnsupportedEncodingException e) {
return false;
}
}
/**
* 文字包含チェッククラス
* @param str チェックする文字列
* @param num 含まれていなければならない文字數
* @return チェック結果の真偽
*/
public static boolean isIncludeDifferentChar(String str, int num){
char work[] = new char[str.length()];
int count = 0;
int i = 0;
int j = 0;
// 文字列の長さが足りてないときは論外
if (str.length() < num){
return false;
}
// 文字列を扱う準備
CharacterIterator iter = new StringCharacterIterator(str);
// 1文字目から最終文字まで、1文字ずつチェック
for (char c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
// 配列に格納
work[i] = c;
i++;
}
// 配列內の文字をソート
Arrays.sort(work);
// ソート後に配列の前後の文字を比較して、違っていればカウントアップ
for (j=0; j < i - 1; j++){
if (work[j] != work[j+1]) {
count++;
}
// カウントが設定値に達したら、trueを戻して終了
if (num <= count + 1) {
return true;
}
}
// カウントが設定値に達しなかったら、falseを戻す
return false;
}
/**
* 未設定判定
* 文字列がnullまたは長さ0の場合を未設定とする
* @param value 判定値
* @return true:設定済、false:未設定
*/
public static boolean required(String value) {
if ((value == null) || (value.length() == 0)) {
return false;
} else {
return true;
}
}
/**
* 最小桁數判定
* @param value 判定値
* @param min 最小値
* @return 桁數が最小値以上であるかどうか
*/
public static boolean minLength(String value, int min) {
if (value == null) {
return false;
}
return GenericValidator.minLength(value, min);
}
/**
* 最小桁數(バイト數)判定
* @param value 判定値
* @param min 最小値
* @return 桁數が最小値以上であるかどうか
*/
public static boolean minByteLength(String value, int min) {
if (value == null) {
return false;
}
try {
if (value.getBytes(ENCODE_MS932).length >= min) {
return true;
} else {
return false;
}
} catch(UnsupportedEncodingException uee) {
return false;
}
}
/**
* 最大桁數判定
* @param value 判定値
* @param max 最大値
* @return 桁數が最大値以下であるかどうか
*/
public static boolean maxLength(String value, int max) {
if (value == null) {
return true;
}
return GenericValidator.maxLength(value, max);
}
/**
* 最大桁數(バイト數)判定
* @param value 判定値
* @param max 最大値
* @return 桁數が最大値以下であるかどうか
*/
public static boolean maxByteLength(String value, int max) {
if (value == null) {
return true;
}
try {
if (value.getBytes(ENCODE_MS932).length <= max) {
return true;
} else {
return false;
}
} catch(UnsupportedEncodingException uee) {
return false;
}
}
/**
* 桁數一致判定
* @param value 判定値
* @param len 桁數
* @return 桁數が一致するかどうか
*/
public static boolean matchLength(String value, int len) {
if (value == null) {
return false;
}
return GenericValidator.maxLength(value, len) &&
GenericValidator.minLength(value, len);
}
/**
* 桁數(バイト數)一致判定
* @param value 判定値
* @param len 桁數
* @return 桁數が一致するかどうか
*/
public static boolean matchByteLength(String value, int len) {
if (value == null) {
return false;
}
try {
if (value.getBytes(ENCODE_MS932).length == len) {
return true;
} else {
return false;
}
} catch(UnsupportedEncodingException uee) {
return false;
}
}
/**
* 屬性判定
* @param value 判定値
* @param regexp 正規表現
* @return 指定した表現であるかどうか
*/
public static boolean mask(String value, String regexp) {
return GenericValidator.matchRegexp(value, regexp);
}
/**
* 脆弱性につながる文字を検出する。<br>
* <、>、&、"、'を含んでいないかどうかを検出する。<br>
* @param message 確認する文字
* @return 正常の場合true、異常な文字が含まれる場合false
*/
public static boolean checkCriticalCharacter(String message) {
// <、>、&、"、'を含む文字列の場合、エラー
if (message.matches(CHARACTER_CRITICAL)) {
return false;
} else {
if (message.indexOf("=")!=-1){
return false;
}
if (message.indexOf("!")!=-1){
return false;
}
// 數値（金額）を許容するため、カンマを許す
// if (message.indexOf(",")!=-1){
// return false;
// }
if (message.indexOf(";")!=-1){
return false;
}
if (message.indexOf("|")!=-1){
return false;
}
if (message.indexOf("+")!=-1){
return false;
}
if (message.indexOf("{")!=-1){
return false;
}
if (message.indexOf("}")!=-1){
return false;
}
if (message.indexOf("#")!=-1){
return false;
}
if (message.indexOf("`")!=-1){
return false;
}
if (message.indexOf("~")!=-1){
return false;
}
if (message.indexOf("$")!=-1){
return false;
}
if (message.indexOf("%")!=-1){
return false;
}
// 半角中點は外字チェックでエラーになるため、禁止文字からは外す
// if (message.indexOf("･")!=-1){
// return false;
// }
if (message.indexOf("[")!=-1){
return false;
}
if (message.indexOf("]")!=-1){
return false;
}
if (message.indexOf("^")!=-1){
return false;
}
if (message.indexOf("?")!=-1){
return false;
}
return true;
}
}
/**
* 文字列が全て半角文字かどうかをチェックする。<br>
* ASCIIコードの0x21～0x7Eまでを半角文字とする。<br>
* null、空文字の場合はfalseを返す。
* @param half チェック対象の文字列
* @return 半角文字の場合はtrue、それ以外はfalse
*/
public static final boolean isHankaku(String half) {
// 空文字をチェック
if (!required(half)) {
return false;
}
int c;
char[] chars = half.toCharArray();
// 全ての文字をチェック
for (int i = 0; i < half.length(); i++) {
c = chars[i];
// 0x21～0x7Eの範囲外の場合はエラー
if (c < ASCII_CHAR_0X21 || ASCII_CHAR_0X7E < c) {
return false;
}
}
return true;
}
/**
* 許可文字列チェック。<br>
* 外字が含まれていないかどうかチェックする。<br>
* null、または空文字の場合はfalseを返す。
* @param allowable チェック対象の文字列
* @return 許可文字列であればtrue
*/
public static final boolean isAllowable(String allowable) {
// 空文字をチェック
if (!required(allowable)) {
return false;
}
// 全ての文字をチェックする
String checkString = null;
for (int i = 0; i < allowable.length(); i++) {
checkString = allowable.substring(i, i + 1);
// 半角文字チェック（半角スペースは許可される）
if (!StringUtil.isHankaku(checkString) && !S_STRING.equals(checkString)) {
// 半角カナチェック
if (!StringUtil.isHankakuKana(checkString)) {
// 全角文字チェック
if (!StringUtil.isZenkaku(checkString)) {
// 全角文字でもなかった場合、エラーとする
return false;
}
}
}
}
return true;
}
/**
* URLの部分取得処理。<br>
* URL各種類("/pc/", "/ezxht/", "/cs/", "/mg/")以降を取得する。<br>
* 接尾辭に".jsp"がある場合、その部分は除いた値となる。<br>
* @param uri "/xxx/pc/yyy.jsp"(PCの場合)
* @return String 編集したURI:"/pc/yyy"(上記パラメタの場合)
*/
public static final String getActionPath(String uri) {
// 削除接尾辭
final String EXTENSION_JSP = ".jsp";
// URL編集用
String editUri = new String();
// URL接尾辭に".jsp"がある場合は削除する
if (editUri.endsWith(EXTENSION_JSP)) {
editUri = editUri.substring(0, editUri.length() - EXTENSION_JSP.length());
}
// 編集後のURLを返す
return editUri;
}
//--- yt start----//
/**
* 引數に改行コードを含めば、全部｢<br>｣に変換して返す。
* @param strValue "aa\r\nbb\r\ncc"(テーブルの場合)
* @return String 編集したデータ："aa<BR>bb<BR>cc"(HTMLの場合)
*/
public static final String convEnterToBR(String strValue) {
// nullの判斷
if (strValue == null) {
return null;
}
// 編集後の引數を返す
return strValue.replaceAll(PTN_NEW_LINE, HTMLBR)
.replaceAll(SPACE, NBSP);
}
/**
* 引數に改行コードを含めば、全部外して、返す。
* @param strValue "aa\r\nbb\r\ncc"(テーブルの場合)
* @return String 編集したデータ："aabbcc" (HTMLの場合)
*/
public static final String convEnterToNull(String strValue) {
// nullの判斷
if (strValue == null) {
return null;
}
// 引數編集用
String strBlack = strValue.replaceAll(PTN_NEW_LINE, BLACK).replaceAll(
SPACE, NBSP);
// 編集後の引數を返す
return strBlack;
}
/**
* 引數に改行コードを含めば、全部外して、返す。
* @param strValue 編集前データ(改行コードあり)
* @return String 編集後データ(改行コードなし)
*/
public static final String convEnter(String strValue) {
// nullの判斷
if (strValue == null) {
return null;
}
// 引數編集用
String strBlack = strValue.replaceAll(PTN_NEW_LINE, BLACK);
// 編集後の引數を返す
return strBlack;
}
/**
* 二つ文字列は分割文字を分割してから、連結し、返す。
* でも、 前後文字列は全部空白の場合は、空白を返す。
* @param before 前文字列
* @param delimeter 分割文字
* @param after 後文字列
* @return 連結したデータ："aa:cc" (前文字列は"aa"、分割文字は":"、後文字列は"cc"の場合)
*/
public static final String concateWithDelimeter(String before, String delimeter, String after) {
// nullの判斷
if ((before == null || before.length() == 0) && (after == null || after.length() == 0) ) {
return BLACK;
}
StringBuffer sb = new StringBuffer();
if (before == null || before.length() == 0) {
sb.append(delimeter != null ? delimeter : BLACK).append(after);
} else if (after == null || after.length() == 0) {
sb.append(before).append(delimeter != null ? delimeter : BLACK);
} else {
sb.append(before).append(delimeter != null ? delimeter : BLACK).append(after);
}
// 編集後の結果を返す
return sb.toString();
}
// --- yt end ----//
/**
* 二つ文字列を連結して、返す。
* でも、 前後文字列の何れは空白の場合は、空白を返す。
* @param before 前文字列
* @param after 後文字列
* @return 連結したデータ："aacc" (前文字列は"aa"、後文字列は"cc"の場合)
*/
public static final String concate(String before, String after) {
// nullの判斷
if (before == null || before.length() == 0 || after == null || after.length() == 0) {
return BLACK;
}
// 編集後の結果を返す
return before + after;
}
/**
* TextArea先頭の改行を無視される制限を解ける為、TextArea先頭文字列は改行コード場合、もう一つの改行コードを先頭に追加する。
* @param strValue TextArea文字列
* @return String 編集したデータ："\r\n\r\ncc"(パラメーターは"\r\ncc"場合)
*/
public static final String addEnterToFirst(String strValue) {
// nullの判斷
if (strValue == null) {
return null;
}
String result = strValue;
if (strValue.startsWith(STR_NEW_LINE)) {
result = STR_NEW_LINE + strValue;
}
// 編集後の引數を返す
return result;
}
/**
* 文字列を目標長さに編集する。長すぎる場合は、長すぎる分を捨てる。長さ足りない場合は、半角スペースを追加する。
* @param oldValue 文字列
* @param targetSize 目標長さ
* @return 編集したデータ
*/
public static final String toFixLength(String oldValue, int targetSize) {
String newValue = null;
if (oldValue == null) {
StringBuffer sb = new StringBuffer(targetSize);
for(int i = 0; i < targetSize; i++) {
sb.append(S_CHAR);
}
newValue = sb.toString();
} else {
if(oldValue.length() > targetSize){
newValue = oldValue.substring(0, targetSize);
}else if(oldValue.length() < targetSize){
newValue = StringUtil.rightPad(oldValue, targetSize, S_CHAR);
}else{
newValue = oldValue;
}
}
return newValue;
}
/**
* 全角の英字、數字、カタカナ、記號を半角に変換する。
* @param before 変換前文字列
* @return 変換後の文字列
*/
public static final String convertFullToHalf(String before) {
String result = before;
// 全角英字を半角英字に変換する
AlphabetConverterFromZenkakuToHankaku alphaConvert = new AlphabetConverterFromZenkakuToHankaku();
result = alphaConvert.convertString(result);
// 全角數字を半角數字に変換する
NumberConverterFromZenkakuToHankaku numberConvert = new NumberConverterFromZenkakuToHankaku();
result = numberConvert.convertString(result);
// 全角カタカナを半角カタカナに変換する
KatakanaConverterFromZenkakuToHankaku katakanaConvert = new KatakanaConverterFromZenkakuToHankaku();
result = katakanaConvert.convert(result);
// 全角記號を半角記號に変換する
SymbolConverterFromZenkakuToHankaku symbolConvert = new SymbolConverterFromZenkakuToHankaku();
result = symbolConvert.convertString(result);
return result;
}
/**
* 文字化けする可能性がある文字をコード変換する<br>
* (Unicode → Shift-Jis)<br>
* @param before 変換前文字列
* @return 変換後の文字列
*/
public static final String convertUnicodeToSjis(String before) {
return before.replaceAll("\u301C", "～")
.replaceAll("\u2016", "∥")
.replaceAll("\u2212", "－")
.replaceAll("\u00A2", "￠")
.replaceAll("\u00AC", "￢")
.replaceAll("\u00A3", "￡");
}
/**
* 文字化けする可能性がある文字をコード変換する<br>
* (Shift-Jis → Unicode)<br>
* @param before 変換前文字列
* @return 変換後の文字列
*/
public static final String convertSjisToUnicode(String before) {
return before.replaceAll("～", "\u301C")
.replaceAll("∥", "\u2016")
.replaceAll("－", "\u2212")
.replaceAll("￠", "\u00A2")
.replaceAll("￢", "\u00AC")
.replaceAll("￡", "\u00A3");
}
/**
* 未設定判定
* 文字列がnullまたはTrimした文字列の長さ0の場合を未設定とする
* @param value 判定値
* @return true:設定済、false:未設定
*/
public static boolean requiredTrim(String value) {
if ((value == null) || (value.trim().length() == 0)) {
return false;
} else {
return true;
}
}
/**
* セッションIDを取得する。（リクエストを特定させるために使用する）
* 処理概要：リクエストからセッションIDを取得する。lengthで取得するidの長さを指定する。
* <pre> length <= 0 idを返卻</pre>
* <pre> length = n 長さnのID</pre>
* <pre>length = nでid.length <= length だった場合idを返す。 </pre>
* <pre>length = nでid.length > length だった場合、左からn桁取得したidを返す。 </pre>
* @param request リクエスト
* @param length 取得するidの長さ
* @return String id
*/
public static String getSessionId(HttpServletRequest request, int length){
String id = "null";
if(null == request){
return id;
}
HttpSession session = request.getSession();
if (null != session) {
id = session.getId();
if (length <= 0) {
return id;
} else {
if (id.length() <= length) {
return id;
} else {
return id.substring(0, length);
}
}
}
return id;
}
}
