項目「quick」中まとめした共通方法

/**
* 数字を日本通貨表示形式に整形する 小数点後最大1桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormatJC(Object target) {
String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter = NumberFormat.getInstance(Locale.JAPAN);
numberFormatter.setGroupingUsed(true);
numberFormatter.setMaximumFractionDigits(1);
numberFormatter.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormatエラーが発生した,target="+target+"、target.class ="+target.getClass());
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字の形式に整形する 小数点後最大1桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormat(Object target) {
String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter = NumberFormat.getInstance();
numberFormatter.setGroupingUsed(true);
numberFormatter.setMaximumFractionDigits(1);
numberFormatter.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormatエラーが発生した,target="+target+"、target.class ="+target.getClass());
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を日本通貨表示形式に整形する(イベント：資本異動→第三者増資、第三者処分専用) 小数点後最大3桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormatJCForThirdParty(Object target) {
String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter = NumberFormat.getInstance(Locale.JAPAN);
numberFormatter.setGroupingUsed(true);
numberFormatter.setMaximumFractionDigits(3);
numberFormatter.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormatForThirdPartyエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字をパーセント形式に整形する 小数点後最大2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormatPercent(Object target) {
String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatterPercent = NumberFormat.getPercentInstance();
numberFormatterPercent.setMaximumFractionDigits(2);
numberFormatterPercent.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatterPercent.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormatPercentエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を普通形式に整形する(イベント：資本異動→立会外分売専用) 小数点後最大2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormat2DigitDecimal(Object target) {


String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter2DigitDecimal = NumberFormat.getInstance();
numberFormatter2DigitDecimal.setMaximumFractionDigits(2);
numberFormatter2DigitDecimal.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter2DigitDecimal.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormat2DigitDecimalエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を日本通貨表示形式に整形する(イベント：資本異動→立会外分売専用) 小数点後最大2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormatJC2DigitDecimal(Object target) {


String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter2DigitDecimal = NumberFormat.getInstance(Locale.JAPAN);
numberFormatter2DigitDecimal.setMaximumFractionDigits(2);
numberFormatter2DigitDecimal.setMinimumFractionDigits(0);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter2DigitDecimal.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormat2DigitDecimalエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を日本通貨表示形式に整形する 小数点後最小1桁、最大2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormatJCForDivData(Object target) {
String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter = NumberFormat.getInstance(Locale.JAPAN);
numberFormatter.setGroupingUsed(true);
numberFormatter.setMaximumFractionDigits(2);
numberFormatter.setMinimumFractionDigits(1);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormatForDivDataエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を普通表示形式に整形する 小数点後固定2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormat2DigitDecimalFixing(Object target) {


String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter2DigitDecimal = NumberFormat.getInstance();
numberFormatter2DigitDecimal.setMaximumFractionDigits(2);
numberFormatter2DigitDecimal.setMinimumFractionDigits(2);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter2DigitDecimal.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormat2DigitDecimalエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 数字を普通表示形式に整形する 小数点後固定2桁
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String numberFormat4DigitDecimalFixing(Object target) {


String targetStr = "";
if (target != null && !"".equals(target)) {
NumberFormat numberFormatter2DigitDecimal = NumberFormat.getInstance();
numberFormatter2DigitDecimal.setMaximumFractionDigits(4);
numberFormatter2DigitDecimal.setMinimumFractionDigits(4);
try {
targetStr = objToStr(target);
double targetDoub = objToDoub(targetStr);
targetStr = numberFormatter2DigitDecimal.format(targetDoub);
} catch (Exception e) {
// logger.debug("numberFormat2DigitDecimalエラーが発生した,target="+target);
targetStr = "";
}
} else {
targetStr = "";
}
return targetStr;
}


/**
* 文字列を整形数字に転換する
* 
* @param String 転換対象
* @return int 転換結果
*/
public int strToInteger(String target) {
Integer targetInt = 0;
if (target == null) {
return targetInt;
} else {
try {
targetInt = Integer.valueOf(target);
} catch (Exception ex) {
targetInt = 0;
}
}
return targetInt;
}


/**
* Mues HTTP-API「項目フィード取得」 から「項目フィード」を取得する
* 
* @param quoteList 銘柄コードリスト
* @param String 検索項目
* @return JSONObject 検索結果
*/
public JSONObject getItemData(List quoteList, String[] elmAry) {
GetItemController getItemCntl = new GetItemController();
ItemQuoteElementReq iqer = new ItemQuoteElementReq();
JSONObject itemJson = new JSONObject();
int quoteListSize =  quoteList.size();
if (quoteListSize > 100) {
List tempQuoteList = new ArrayList();
JSONObject tempItemJson = new JSONObject();
for (int i = 0; i < quoteListSize; i = i + 100) {
if (quoteListSize - 1 < i + 100) {
tempQuoteList = quoteList.subList(i, quoteListSize);
} else {
tempQuoteList = quoteList.subList(i, i + 100);
}
iqer.setQCs((String[]) tempQuoteList.toArray(new String[tempQuoteList.size()]));
iqer.setECs(elmAry);
tempItemJson = getItemCntl.getItemData(iqer, AwsConstant.USER_WEB, AwsConstant.PASSWORD_WEB).getJSONObject("D");
itemJson.putAll(tempItemJson);
}
} else {
iqer.setQCs((String[]) quoteList.toArray(new String[quoteList.size()]));
iqer.setECs(elmAry);
itemJson = getItemCntl.getItemData(iqer, AwsConstant.USER_WEB, AwsConstant.PASSWORD_WEB);

itemJson = itemJson.getJSONObject("D");
}
return itemJson;
}


/**
* Objectを文字列に転換する
* 
* @param Object 転換対象
* @return String 転換結果
*/
public String objToStr(Object target) {
String targetStr = "";
if (target != null) {
targetStr = String.valueOf(target);
}
return targetStr;
}


/**
* マップに対象を設定する時、誤入替えを防止する設定メソッド ※しばらく用がない
* 
* @param Map 設定対象マップ
* @param String 設定キー
* @param String 設定バリュー
* @return Map 設定済対象マップ
*/
public Map putToMap(Map targetMap, String key, Object value) {


if (value != null) {
if (targetMap.containsKey(key)) {
String before = objToStr(targetMap.get(key));
String after = objToStr(value);
// logger.debug("値が入り替えた、エラーの可能性があります。　前："+before+"　後："+after);
}
if (!"null".equals(value)) {
targetMap.put(key, value);
} else {
targetMap.put(key, "");
}
} else {
targetMap.put(key, "");
}
return targetMap;
}


/**
* 値設定、出力するとき、文字列「null」の出力を防止する設定メソッド ※しばらく用がない
* 
* @param String 対象値
* @return String チェック、変換済値
*/
public String itemFilter(String item) {


if (item != null) {
if ("null".equals(item)) {
item = "";
}
} else {
item = "";
}
return item;
}


/**
* Objectをdouble数字に転換する
* 
* @param Object 転換対象
* @return double 転換結果
*/
public double objToDoub(Object target) {
double targetDoub = 0;
try {
targetDoub = Double.parseDouble(objToStr(target));
} catch (Exception ex) {
// logger.debug("Double.parseDoubleエラー発生、target="+target);
targetDoub = 0;
}
return targetDoub;
}


/**
* ObjectをInt数字に転換する
* 
* @param Object 転換対象
* @return double 転換結果
*/
public int objToInt(Object target) {
int targetInt = 0;
try {
targetInt = Integer.valueOf(objToStr(target));
} catch (Exception ex) {
// logger.debug("Integer.valueOfエラー発生、target="+target);
targetInt = 0;
}
return targetInt;
}


/**
* NULLと空文字判断用メソッド(IsNotEmpty)
* 
* @param String 判断対象
* @return boolean 判断結果
*/
public boolean strIsNotEmpty(String target) {
if (target != null && !"null".equals(target)) {
return StringUtils.isNotEmpty(target.trim());
} else {
return false;
}
}


/**
* NULLと空文字判断用メソッド(IsEmpty)
* 
* @param String 判断対象
* @return boolean 判断結果
*/
public boolean strIsEmpty(String target) {
if (target != null && !"null".equals(target)) {
return StringUtils.isEmpty(target.trim());
} else {
return true;
}
}


/**
* JSON転換エラー防止メソッド
* 
* @param target JSON転換対象
* @return JSONObject JSON転換結果
*/
public JSONObject toJSON(Object target) {
if (target != null) {
return JSONObject.fromObject(target);
} else {
String tempStr = "JSON転換エラーが発生しました、ログを見てください";
return JSONObject.fromObject(tempStr);
}
}


/**
* １、イベント詳細種類コードによって、イベント詳細種類名称を取得する ２、異動日コードによって、異動日名称を取得する
* 
* @param eventCode イベント詳細種類コード/異動日コード
* @return String イベント詳細種類名称/異動日名称
*/
// イベント種類３　イベント種類４の取得
public String getEventName(String eventCode) {
String eventName = "";
if (300 < strToInteger(eventCode) && strToInteger(eventCode) < 400) {
eventName = objToStr(eventMap3.get(eventCode));
} else if (599 < strToInteger(eventCode) && strToInteger(eventCode) < 700) {
eventName = objToStr(eventMap4.get(eventCode));
}
return eventName;
}


/**
* 先週の金曜日を取得する
* 
* @return String 先週の金曜日
*/
public String getFriday(String date) {


Calendar now = Calendar.getInstance();


if (strIsNotEmpty(date)) {
now = toCalendar(date);
}
String returnDate = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");


// 曜日を取得
int week = now.get(Calendar.DAY_OF_WEEK);


// 日付を加減算する
now.add(Calendar.DATE, (Integer) fridayMap.get(week));
returnDate = sdf.format(now.getTime());


CheckedBits checked = new CheckedBits();
BizCalendarAccess bizCalendarAccess = new BizCalendarAccess(checked);


// 営業日情報取得
Map bizCalendarInfo = bizCalendarAccess.getCalendarData(returnDate);
returnDate = objToStr(bizCalendarInfo.get("cur_biz_date"));
return returnDate;
}


/**
* 指定された日付・時刻文字列を、可能であれば Calendarクラスに変換します。 以下の形式の日付文字列を変換できます。
* 
* ●変換可能な形式は以下となります。 yyyy/MM/dd yy/MM/dd yyyy-MM-dd yy-MM-dd yyyyMMdd
* 
* 上記に以下の時間フィールドが組み合わされた状態 でも有効です。 HH:mm HH:mm:ss HH:mm:ss.SSS
* 
* @param strDate 日付・時刻文字列。
* @return 変換後のCalendarクラス。
* @throws IllegalArgumentException 日付文字列が変換不可能な場合 または、矛盾している場合（例：2000/99/99）。
*/
public Calendar toCalendar(String strDate) {
strDate = format(strDate);
Calendar cal = Calendar.getInstance();
cal.setLenient(false);


int yyyy = Integer.parseInt(strDate.substring(0, 4));
int MM = Integer.parseInt(strDate.substring(5, 7));
int dd = Integer.parseInt(strDate.substring(8, 10));
int HH = cal.get(Calendar.HOUR_OF_DAY);
int mm = cal.get(Calendar.MINUTE);
int ss = cal.get(Calendar.SECOND);
int SSS = cal.get(Calendar.MILLISECOND);
cal.clear();
cal.set(yyyy, MM - 1, dd);
int len = strDate.length();
switch (len) {
case 10:
break;
case 16: // yyyy/MM/dd HH:mm
HH = Integer.parseInt(strDate.substring(11, 13));
mm = Integer.parseInt(strDate.substring(14, 16));
cal.set(Calendar.HOUR_OF_DAY, HH);
cal.set(Calendar.MINUTE, mm);
break;
case 19: // yyyy/MM/dd HH:mm:ss
HH = Integer.parseInt(strDate.substring(11, 13));
mm = Integer.parseInt(strDate.substring(14, 16));
ss = Integer.parseInt(strDate.substring(17, 19));
cal.set(Calendar.HOUR_OF_DAY, HH);
cal.set(Calendar.MINUTE, mm);
cal.set(Calendar.SECOND, ss);
break;
case 23: // yyyy/MM/dd HH:mm:ss.SSS
HH = Integer.parseInt(strDate.substring(11, 13));
mm = Integer.parseInt(strDate.substring(14, 16));
ss = Integer.parseInt(strDate.substring(17, 19));
SSS = Integer.parseInt(strDate.substring(20, 23));
cal.set(Calendar.HOUR_OF_DAY, HH);
cal.set(Calendar.MINUTE, mm);
cal.set(Calendar.SECOND, ss);
cal.set(Calendar.MILLISECOND, SSS);
break;
default:
throw new IllegalArgumentException("引数の文字列[" + strDate + "]は日付文字列に変換できません");
}
return cal;
}


/**
* 様々な日付、時刻文字列をデフォルトの日付・時刻フォーマット へ変換します。
* 
* ●デフォルトの日付フォーマットは以下になります。 日付だけの場合：yyyy/MM/dd 日付+時刻の場合：yyyy/MM/dd HH:mm:ss.SSS
* 
* @param str 変換対象の文字列
* @return デフォルトの日付・時刻フォーマット
* @throws IllegalArgumentException 日付文字列が変換不可能な場合
*/
private static String format(String str) {
if (str == null || str.trim().length() < 8) {
throw new IllegalArgumentException("引数の文字列[" + str + "]は日付文字列に変換できません");
}
str = str.trim();
String yyyy = null;
String MM = null;
String dd = null;
String HH = null;
String mm = null;
String ss = null;
String SSS = null;
// "-" or "/" が無い場合
if (str.indexOf("/") == -1 && str.indexOf("-") == -1) {
if (str.length() == 8) {
yyyy = str.substring(0, 4);
MM = str.substring(4, 6);
dd = str.substring(6, 8);
return yyyy + "/" + MM + "/" + dd;
}
yyyy = str.substring(0, 4);
MM = str.substring(4, 6);
dd = str.substring(6, 8);
HH = str.substring(9, 11);
mm = str.substring(12, 14);
ss = str.substring(15, 17);
return yyyy + "/" + MM + "/" + dd + " " + HH + ":" + mm + ":" + ss;
}
StringTokenizer token = new StringTokenizer(str, "_/-:. ");
StringBuffer result = new StringBuffer();
for (int i = 0; token.hasMoreTokens(); i++) {
String temp = token.nextToken();
switch (i) {
case 0:// 年の部分
yyyy = fillString(str, temp, "L", "20", 4);
result.append(yyyy);
break;
case 1:// 月の部分
MM = fillString(str, temp, "L", "0", 2);
result.append("/" + MM);
break;
case 2:// 日の部分
dd = fillString(str, temp, "L", "0", 2);
result.append("/" + dd);
break;
case 3:// 時間の部分
HH = fillString(str, temp, "L", "0", 2);
result.append(" " + HH);
break;
case 4:// 分の部分
mm = fillString(str, temp, "L", "0", 2);
result.append(":" + mm);
break;
case 5:// 秒の部分
ss = fillString(str, temp, "L", "0", 2);
result.append(":" + ss);
break;
case 6:// ミリ秒の部分
SSS = fillString(str, temp, "R", "0", 3);
result.append("." + SSS);
break;
}
}
return result.toString();
}


private static String fillString(String strDate, String str, String position, String addStr, int len) {
if (str.length() > len) {
throw new IllegalArgumentException("引数の文字列[" + strDate + "]は日付文字列に変換できません");
}
return fillString(str, position, len, addStr);
}


/**
* 文字列[str]に対して、補充する文字列[addStr]を [position]の位置に[len]に満たすまで挿入します。
* 
* ※[str]がnullや空リテラルの場合でも[addStr]を [len]に満たすまで挿入した結果を返します。
* 
* @param str 対象文字列
* @param position 前に挿入 ⇒ L or l 後に挿入 ⇒ R or r
* @param len 補充するまでの桁数
* @param addStr 挿入する文字列
* @return 変換後の文字列。
*/
private static String fillString(String str, String position, int len, String addStr) {
if (addStr == null || addStr.length() == 0) {
throw new IllegalArgumentException("挿入する文字列の値が不正です。addStr=" + addStr);
}
if (str == null) {
str = "";
}
StringBuffer buffer = new StringBuffer(str);
while (len > buffer.length()) {
if (position.equalsIgnoreCase("l")) {
int sum = buffer.length() + addStr.length();
if (sum > len) {
addStr = addStr.substring(0, addStr.length() - (sum - len));
buffer.insert(0, addStr);
} else {
buffer.insert(0, addStr);
}
} else {
buffer.append(addStr);
}
}
if (buffer.length() == len) {
return buffer.toString();
}
return buffer.toString().substring(0, len);
}


/**
* イベントコード情報を取得する
* 
* @return String 先週の金曜日
*/
public Map decideEventType(String eventCD1, String eventCD2, String eventCD3) {


String event_type_code4 = "";
String event_type_code3 = "";
if (strIsNotEmpty(eventCD3)){
event_type_code4 = objToStr(eventCD3Map.get(eventCD3));
if (strIsEmpty(eventCD2)){
eventCD2 = eventCD3.substring(0,4);
if (strIsEmpty(eventCD1)){
eventCD1 = eventCD3.substring(0,2);
}
}
event_type_code3 = objToStr(eventCD3Map.get(eventCD2));
} else if (strIsNotEmpty(eventCD2)) {
event_type_code3 = objToStr(eventCD3Map.get(eventCD2));
if (strIsEmpty(eventCD1)){
eventCD1 = eventCD3.substring(0,2);
}
}

Map resultMap = new HashMap();
resultMap.put("event_type_code3", event_type_code3);
resultMap.put("event_type_code4", event_type_code4);
resultMap.put("eventCD1", eventCD1);
resultMap.put("eventCD2", eventCD2);
resultMap.put("eventCD3", eventCD3);
return resultMap;
}