Skip to content

Instantly share code, notes, and snippets.

@kaku87

kaku87/SstyleTools.java

Last active December 24, 2015 06:59
Show Gist options
  • Save kaku87/6760980 to your computer and use it in GitHub Desktop.
Save kaku87/6760980 to your computer and use it in GitHub Desktop.
Download ZIP
一些公用方法
Raw
SstyleTools.java
package sstyle.common;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.ibm.icu.math.BigDecimal;
import jp.co.intra_mart.foundation.datastore.common.structure.Term;
import jp.co.intra_mart.framework.base.message.MessageManager;
import jp.co.intra_mart.framework.base.message.MessageManagerException;
import jp.co.intra_mart.framework.base.service.ServiceManager;
import jp.co.intra_mart.framework.base.service.ServiceManagerException;
import jp.co.intra_mart.framework.base.service.ServiceServlet;
import jp.co.intra_mart.framework.system.exception.SystemException;
public class SstyleTools {
/**
* オブジェクトがnull,または型がStringの場合は空文字列か判定する。
* @param object
* @return true...null・空 / false...null・空でない
*/
public static boolean isEmpty(Object object) {
if (object == null) {
return true;
}
if (object instanceof String) {
if ("".equals(((String) object))) {
return true;
}
}
return false;
}
/**
* オブジェクトがnull、または型がStringの場合は空文字列でないか判定する。
* @param object
* @return true...null・空でない / false...null・空
*/
public static boolean isNotEmpty(Object object) {
return !(isEmpty(object));
}
/**
* 引数の配列からSQLのパラメータ文字列を返却する。
* @param sourceList 元の配列
* @return SQLのパラメータ文字列　配列内の要素が全てnullの場合はnullを返却する。
*/
public static String getCondValue(Object[] sourceList) {
if (sourceList == null) {
return null;
}
String strCond = null;
String strCondTmp = "";
boolean firstItem = true;
for (int i = 0; i < sourceList.length; i++) {
if (sourceList[i] != null) {
if (firstItem == false) {
strCondTmp = strCondTmp + ",'" + sourceList[i].toString() + "'";
} else {
strCondTmp = strCondTmp + "'" + sourceList[i].toString() + "'";
firstItem = false;
}
}
}
if (!"".equals(strCondTmp)) {
strCond = strCondTmp;
}
return strCond;
}
/**
* 日付(YYYY/MM/DD形式)をYYYYMMDD形式に変換する
* @param dateString:対象日付(YYYY/MM/DD)
* @return 変換後の日付(YYYYMMDD)
*/
public static String removeSeprator(String dateString) {
if (isEmpty(dateString) || dateString.length() != 10 || dateString.indexOf("/") == -1) {
if (isNotEmpty(dateString) && dateString.length()==19) {
// 次プロジェクトでは削除
return dateString.substring(0, 4) + dateString.substring(5, 7) + dateString.substring(8, 10);
}
return dateString;
} else {
if (isEmpty(checkDate(dateString))) {
// 日付でない
return dateString;
}
return dateString.replaceAll("/", "");
}
}
/**
* 日付(YYYYMMDD形式)をYYYY/MM/DD形式に変換する
* @param dateString:対象日付(YYYYMMDD)
* @return 変換後の日付(YYYY/MM/DD)
*/
public static String addSeprator(String dateString) {
if (isEmpty(dateString) || dateString.length() != 8) {
return dateString;
} else {
String tmpDateString = dateString.substring(0, 4) + "/" + dateString.substring(4, 6) + "/" + dateString.substring(6, 8);
if (isEmpty(checkDate(tmpDateString))) {
// 日付ではない
return dateString;
}
return tmpDateString;
}
}
/**
* 年月(YYYY/MM形式)をYYYYMM形式に変換する
* @param ymString:対象年月(YYYY/MM)
* @return 変換後の年月(YYYYMM)
*/
public static String removeSepratorYM(String ymString) {
if (isEmpty(ymString) || ymString.length() != 7 || ymString.indexOf("/") == -1) {
if (isNotEmpty(ymString) && ymString.length() > 7) {
// 次プロジェクトでは削除
return ymString.substring(0, 4) + ymString.substring(5, 7);
}
return ymString;
} else {
if (isEmpty(checkDate(ymString + "/01"))) {
// 日付でない
return ymString;
}
return ymString.replaceAll("/", "");
}
}
/**
* 年月(YYYYMM形式)をYYYY/MM形式に変換する
* @param ymString:対象年月(YYYYMM)
* @return 変換後の年月(YYYY/MM)
*/
public static String addSepratorYM(String ymString) {
if (isEmpty(ymString) || ymString.length() != 6) {
return ymString;
} else {
String tmpYmString = ymString.substring(0, 4) + "/" + ymString.substring(4, 6);
if (isEmpty(checkDate(tmpYmString + "/01"))) {
// 日付ではない
return ymString;
}
return tmpYmString;
}
}
/**
* 日付(YYYY/MM/DD)をYYYY.MM.DD形式に変換する
* @param d:対象日付(YYYY/MM/DD)
* @return 変換後の日付(YYYY.MM.DD)
*/
public static String printDateFormat(String d) {
if (isEmpty(d)) {
return "";
}
return d.substring(0, 4) + "." + d.substring(5, 7) + "." + d.substring(8, 10);
}
/**
* String型の日付をDate型の日付に変換する
* @param strDate:String型の日付(YYYY/MM/DD)
* @return Date型の日付
* @throws ParseException
*/
public static Date getDateParse(String strDate) throws ParseException {
DateFormat df = DateFormat.getDateInstance();
Date date = df.parse(strDate);
return date;
}
/**
* 日付をYYYYMMDD形式の文字列にする
* @param date:日付
* @return YYYYMMDD形式の文字列
*/
public static String getSimpleDateString(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
return sdf.format(date);
}
/**
* 日付をYYYY/MM/DD形式の文字列にする
* @param date:日付
* @return YYYY/MM/DD形式の文字列
*/
public static String getSimpleDateString2(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
return sdf.format(date);
}
/**
* 日付(YYYY/MM/DD形式またはYYYY/MM形式)の月末日を取得する（ex. 2006/05 →　2006/05/31）
* @param separateDate:対象日付(YYYY/MM/DDまたはYYYY/MM)
* @return 対象日付の月末日(YYYY/MM/DD)
*/
public static String getMonthEndDate(String separateDate) {
if (isEmpty(separateDate) || separateDate.length() != 7 && separateDate.length()!=10 && separateDate.length()!=19
|| separateDate.length() == 7 && isEmpty(checkDate(separateDate + "/01"))
|| separateDate.length() == 10 && isEmpty(checkDate(separateDate))) {
return null;
}
Calendar cal = Calendar.getInstance();
if (separateDate.length() != 11) {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 4)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(5, 7)) - 1);
} else {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 5)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(6, 8)) - 1);
}
cal.set(Calendar.DATE, Integer.parseInt("01"));
// 引数の翌月を求める
cal.add(Calendar.MONTH, 1);
// 翌月の前日を求める
cal.add(Calendar.DATE, -1);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
String str = simpleDateFormat.format(cal.getTime());
return str;
}
/**
* 日付(YYYY/MM/DD形式またはYYYY/MM形式)の翌月月初日を取得する（ex. 2006/05 → 2006/06/01）
* @param separateDate:対象日付(YYYY/MM/DDまたはYYYY/MM)
* @return 対象日付の翌月月初日(YYYY/MM/DD)
*/
public static String getNextMonthStartDate(String separateDate) {
Calendar cal = Calendar.getInstance();
if (separateDate.length() != 11) {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 4)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(5, 7)) - 1);
} else {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 5)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(6, 8)) - 1);
}
cal.set(Calendar.DATE, Integer.parseInt("01"));
// 引数の翌日を求める
cal.add(Calendar.MONTH, 1);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
String str = simpleDateFormat.format(cal.getTime());
return str;
}
/**
* 日付(YYYY/MM/DD形式)のNヶ月後を取得する（ex. 2006/05/01 → 200N/06/01）
* @param separateDate(YYYY/MM/DD形式)
* @return 対象日付のNヶ月後の日付(YYYY/MM/DD)
*/
public static String getAddMonth(String separateDate, int addMonth) {
Calendar cal = Calendar.getInstance();
if (separateDate.length() != 11) {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 4)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(5, 7)) - 1);
cal.set(Calendar.DATE, Integer.parseInt(separateDate.substring(8, 10)));
} else {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 5)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(6, 8)) - 1);
cal.set(Calendar.DATE, Integer.parseInt(separateDate.substring(9, 11)));
}
// 引数の月数を加える
cal.add(Calendar.MONTH, addMonth);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
String str = simpleDateFormat.format(cal.getTime());
return str;
}
/**
* 日付(YYYY/MM/DD形式)の加減算を行う
* @param separateDate:対象日付(YYYY/MM/DD)
* @param addDay:加減算する日数
* @return 加減算した日付(YYYY/MM/DD)
*/
public static String getAddDay(String separateDate, int addDay) {
Calendar cal = Calendar.getInstance();
if (separateDate.length() != 11) {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 4)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(5, 7)) - 1);
cal.set(Calendar.DATE, Integer.parseInt(separateDate.substring(8, 10)));
} else {
cal.set(Calendar.YEAR, Integer.parseInt(separateDate.substring(0, 5)));
cal.set(Calendar.MONTH, Integer.parseInt(separateDate.substring(6, 8)) - 1);
cal.set(Calendar.DATE, Integer.parseInt(separateDate.substring(9, 11)));
}
// 引数の日数を加える
cal.add(Calendar.DATE, addDay);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
String str = simpleDateFormat.format(cal.getTime());
return str;
}
/**
* 日付の加減算を行いその結果をYYYYMMDD形式の文字列で返す
*
* @param yyyymmdd 計算対象日付文字列（YYYYMMDD）
* @param addDay 加算する日数
* @return
*/
public static String getNextDate(String yyyymmdd, int addDay) {
String yyyy = "";
String mm = "";
String dd = "";
if (yyyymmdd.length() == 8) {
// YYYYMMDD
yyyy = yyyymmdd.substring(0, 4);
mm = yyyymmdd.substring(4, 6);
dd = yyyymmdd.substring(6, 8);
} else {
// YYYY/MM/DD
yyyy = yyyymmdd.substring(0, 4);
mm = yyyymmdd.substring(5, 7);
dd = yyyymmdd.substring(8, 10);
}
Calendar calendar = Calendar.getInstance();
calendar.setLenient(false);
calendar.set(Calendar.YEAR, Integer.parseInt(yyyy));
calendar.set(Calendar.MONTH, Integer.parseInt(mm) - 1);
calendar.set(Calendar.DATE, Integer.parseInt(dd));
calendar.add(Calendar.DATE, addDay);
if (yyyymmdd.length() == 8) {
return getSimpleDateString(calendar.getTime());
} else {
return getSimpleDateString2(calendar.getTime());
}
}
/**
* 時間(HHMM形式)をHH:MM形式に変換する
* @param hhmm:対象時間(HHMM)
* @return 変換後の時間(HH:MM)
*/
public static String addSeparatorTime(String hhmm) {
if (isEmpty(hhmm) || hhmm.length() != 4) {
return hhmm;
}
return hhmm.substring(0, 2) + ":" + hhmm.substring(2);
}
/**
* 時間(HH:MM形式)をHHMM形式に変換する
* @param hhmm:対象時間(HH:MM)
* @return 変換後の時間(HHMM)
*/
public static String removeSeparatorTime(String hhmm) {
if (isEmpty(hhmm) || hhmm.length() != 5) {
return hhmm;
}
return hhmm.replaceAll(":", "");
}
/**
* 日付(YYYY/MM/DD形式またはYYYYMMDD形式)から曜日コードを取得します
* @param yyyymmdd:対象日付(YYYY/MM/DDまたはYYYYMMDD)
* @return 曜日コード
* 1:日曜日
* 2:月曜日
* 3:火曜日
* 4:水曜日
* 5:木曜日
* 6:金曜日
* 7:土曜日
*/
public static String getWeekDay(String yyyymmdd) {
yyyymmdd = removeSeprator(yyyymmdd);
String yyyy = yyyymmdd.substring(0, 4);
String mm = yyyymmdd.substring(4, 6);
String dd = yyyymmdd.substring(6, 8);
String retVal = "";
Calendar calendar = Calendar.getInstance();
calendar.setLenient(false);
calendar.set(Calendar.YEAR, Integer.parseInt(yyyy));
calendar.set(Calendar.MONTH, Integer.parseInt(mm) - 1);
calendar.set(Calendar.DATE, Integer.parseInt(dd));
switch (calendar.get(Calendar.DAY_OF_WEEK)) {
case Calendar.SUNDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_SUNDAY;
break;
case Calendar.MONDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_MONDAY;
break;
case Calendar.TUESDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_TUESDAY;
break;
case Calendar.WEDNESDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_WEDNESDAY;
break;
case Calendar.THURSDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_THURSDAY;
break;
case Calendar.FRIDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_FRIDAY;
break;
case Calendar.SATURDAY:
retVal = SstyleConstants.NAMECLASS_WEEK_SATURDAY;
break;
}
return retVal;
}
/**
* Webサーバーのシステム日付(通常は使用しません)
* @return システム日付(YYYY/MM/DD)
*/
public static String getSysDate() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
return sdf.format(new Date());
}
/**
* Webサーバーのシステム日付時間(通常は使用しません)
* @return システム日付時間(YYYY/MM/DD|hh:mm:ss)
*/
public static String getSysDateTime() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd|HH:mm:ss");
return sdf.format(new Date());
}
/**
* 年(YYYY形式)の有効チェック(accept year 1999 - 9999)
* @param objectYear:対象年(YYYY)
* @return true if valid year, otherwise false
*/
public static boolean checkYear(String objectYear) {
// 半角チェック
if (!checkHalfSize(objectYear)) {
return false;
}
return objectYear.length() == 4 && checkNumeric(objectYear, 4, false) == 0
&& Integer.parseInt(objectYear) >= 1900;
}
/**
* 時間(hours)を分(minutes)に換算する
* @param param:時間
* @return 分
*/
public static long changeHoursToMinit(Double hrs) {
if (isEmpty(hrs)) {
return 0;
} else {
long minit = new Double(round(hrs.doubleValue() * 60, 0)).longValue();
return minit;
}
}
/**
* 分(minutes)を時間(hours)に換算する
* @param param:分
* @return 時間
*/
public static double changeMinitToHours(long minit) {
double hours = round(minit / 60d, 2);
return hours;
}
/**
* 開始時間と終了時間から経過時間を分で取得する。
* @param startTime HHMI
* @param endTime HHMI
* @return 経過時間(分単位)
*/
public static int getElapsedTime(String startTime, String endTime) {
int startTimeHH = Integer.parseInt(startTime.substring(0, 2));
int startTimeMM = Integer.parseInt(startTime.substring(2));
int endTimeHH = Integer.parseInt(endTime.substring(0, 2));
int endTimeMM = Integer.parseInt(endTime.substring(2));
if (startTimeMM > endTimeMM) {
endTimeHH -= 1;
endTimeMM += 60;
}
int elapsedTime = (endTimeHH - startTimeHH) * 60 + (endTimeMM - startTimeMM);
return elapsedTime;
}
/**
* 2つの日付の差を求めます。
* 日付文字列 strDate1 - strDate2 が何日かを返します。
*
* @param strDate1 日付文字列 yyyy/MM/dd
* @param strDate2 日付文字列 yyyy/MM/dd
* @return 2つの日付の差
* @throws ParseException 日付フォーマットが不正な場合
*/
public static int getDifferenceDays(String strDate1,String strDate2) {
try {
Date date1 = DateFormat.getDateInstance().parse(strDate1);
Date date2 = DateFormat.getDateInstance().parse(strDate2);
return getDifferenceDays(date1,date2);
} catch (ParseException ex) {
return 0;
}
}
/**
* 2つの日付の差を求めます。
* java.util.Date 型の日付 date1 - date2 が何日かを返します。
*
* 計算方法は以下となります。
* 1.最初に2つの日付を long 値に変換します。
* 　※この long 値は 1970 年 1 月 1 日 00:00:00 GMT からの
* 　経過ミリ秒数となります。
* 2.次にその差を求めます。
* 3.上記の計算で出た数量を 1 日の時間で割ることで
* 　日付の差を求めることができます。
* 　※1 日 ( 24 時間) は、86,400,000 ミリ秒です。
*
* @param date1 日付 java.util.Date
* @param date2 日付 java.util.Date
* @return 2つの日付の差
*/
public static int getDifferenceDays(Date date1,Date date2) {
long datetime1 = date1.getTime();
long datetime2 = date2.getTime();
long one_date_time = 1000 * 60 * 60 * 24;
long diffDays = (datetime1 - datetime2) / one_date_time;
return (int)diffDays;
}
/**
* 前年同曜日の日付を返します。
* @param objectDate : 対象となる日付（YYYY/MM/DD）
* @return 前年同曜日の日付
*/
public static String getSameDayOfWeekLastYear(String objectDate) {
// 曜日コードを取得
String weekDayCd = getWeekDay(objectDate);
// 前年
String lastYearDate = getAddMonth(objectDate, -12);
// 前年の曜日コードを取得
String lastYearWeekDayCd = getWeekDay(lastYearDate);
// 当年と前年の曜日差
int diff = Integer.parseInt(weekDayCd) - Integer.parseInt(lastYearWeekDayCd);
if (diff < -3) {
diff += 7;
} else if (3 < diff) {
diff -= 7;
}
// 前年同曜日の日付
return getAddDay(lastYearDate, diff);
}
/**
* 日付変換
* @param String YYYY/MM/DD, String YYYY/MM/DD,
* @return Term
*/
public static Term str2term(String sDate, String eDate) {
List<String> slist = new ArrayList<String>();
List<String> elist = new ArrayList<String>();
Term tm;
if (sDate != null && sDate.length() != 0) {
if (sDate.indexOf(" ") > 0) {
sDate = sDate.substring(0, sDate.indexOf(" "));
}
StringTokenizer stok = new StringTokenizer(sDate, "/");
while (stok.hasMoreTokens()) {
slist.add(stok.nextToken());
}
}
if (eDate != null && eDate.length() != 0) {
if (eDate.indexOf(" ") > 0) {
eDate = eDate.substring(0, eDate.indexOf(" "));
}
StringTokenizer etok = new StringTokenizer(eDate, "/");
while (etok.hasMoreTokens()) {
elist.add(etok.nextToken());
}
}
if (elist.size() == 0 || elist.get(0).toString().equals("9999")) {
if (slist.size() != 0) {
tm = new Term(new GregorianCalendar(new Long(slist.get(0).toString()).intValue(), new Long(
slist.get(1).toString()).intValue() - 1, new Long(slist.get(2).toString()).intValue()).getTime());
} else {
tm = new Term();
}
} else {
if (slist.size() != 0) {
GregorianCalendar wkdate = new GregorianCalendar(new Long(elist.get(0).toString()).intValue(), new Long(
elist.get(1).toString()).intValue() - 1, new Long(elist.get(2).toString()).intValue());
wkdate.add(GregorianCalendar.DATE, +1);
tm = new Term(new GregorianCalendar(new Long(slist.get(0).toString()).intValue(), new Long(
slist.get(1).toString()).intValue() - 1, new Long(slist.get(2).toString()).intValue()).getTime(),
wkdate.getTime());
} else {
GregorianCalendar wkdate = new GregorianCalendar(new Long(elist.get(0).toString()).intValue(), new Long(
elist.get(1).toString()).intValue() - 1, new Long(elist.get(2).toString()).intValue());
wkdate.add(GregorianCalendar.DATE, +1);
tm = new Term(null, wkdate.getTime());
}
}
return tm;
}
/**
* 日付に"|00:00:00"を付加する
* @param strDate(YYYY/MM/DD)
* @return YYYY/MM/DD|00:00:00
*/
public static String addDefaultTime(String strDate) {
if (isEmpty(strDate) || isEmpty(checkDate(strDate))) {
return strDate;
} else {
if (strDate.startsWith("9999")) {
return "9999/12/31|23:59:59";
} else if (strDate.length() != 19) {
return (strDate + "|00:00:00");
} else {
return strDate;
}
}
}
/**
* 日付から"|00:00:00"を取り除く
* @param strDate
* @return
*/
public static String removeDefaultTime(String strDate) {
if (isEmpty(strDate)) {
return "";
} else if (!isDate(strDate)) {
return strDate;
} else {
if (strDate.length() > 10) {
return strDate.substring(0, 10);
} else {
return strDate;
}
}
}
/**
* 日付のチェック
* @param strDate:対象日付(YYYY/MM/DD形式または、YYYY/MM/DD|hh:mm:ss形式)
* @return 正しい場合、引数の日付
* 正しくない場合、空文字
*/
public static String checkDate(String strDate) {
String retDate = "";
int yyyy, mm, dd;
if (isEmpty(strDate)) {
return "";
} else if (strDate.length()==19) {
strDate = strDate.substring(0, 10);
}
// YYYY/MM/DD形式以外エラー
String[] orgDate = strDate.split(" ");
String[] dates = orgDate[0].split("/");
if (dates.length != 3) {
return retDate;
} else if (booleancheckFullSize(strDate)) {
return retDate;
} else if (!(checkYear(dates[0]) && dates[1].length() == 2 && dates[2].length() == 2)) {
return retDate;
}
try {
yyyy = new Integer(dates[0]).intValue();
mm = new Integer(dates[1]).intValue();
dd = new Integer(dates[2]).intValue();
} catch (Exception ex) {
return retDate;
}
Calendar cal = new GregorianCalendar();
cal.setLenient(false);
cal.set(yyyy, mm - 1, dd);
try {
java.util.Date ud = cal.getTime();
DateFormat fmt = DateFormat.getDateInstance();
retDate = fmt.format(ud);
return retDate;
} catch (IllegalArgumentException ex) {
return retDate;
}
}
/**
* 日付のチェック
* @param strDate:対象日付(YYYY/MM/DD形式または、YYYY/MM/DD|hh:mm:ss形式)
* @return 正しい場合、引数の日付
* 正しくない場合、空文字
*/
public static String checkDateEdit(String strDate) {
String retDate = "";
int yyyy, mm, dd;
if (isEmpty(strDate)) {
return "";
}
if (strDate.length() > 10) {
strDate = strDate.substring(0, 10);
}
// YYYY/MM/DD形式以外エラー
String[] orgDate = strDate.split(" ");
String[] dates = orgDate[0].split("/");
if (dates.length != 3) {
return "";
} else if (!(checkYear(dates[0]) && dates[1].length() == 2 && dates[2].length() == 2)) {
return retDate;
}
try {
yyyy = new Integer(dates[0]).intValue();
mm = new Integer(dates[1]).intValue();
dd = new Integer(dates[2]).intValue();
} catch (Exception ex) {
return "";
}
Calendar cal = new GregorianCalendar();
cal.setLenient(false);
cal.set(yyyy, mm - 1, dd);
try {
java.util.Date ud = cal.getTime();
DateFormat fmt = DateFormat.getDateInstance();
retDate = fmt.format(ud);
return retDate;
} catch (IllegalArgumentException ex) {
return "";
}
}
/**
* 日付のチェック
* @param objectDate:対象日付(YYYY/MM/DD形式または、YYYY/MM/DD|hh:mm:ss形式)
* @return true:日付である false:日付ではない
*/
public static boolean isDate(String objectDate) {
if (isEmpty(checkDateEdit(objectDate))) {
return false;
}
return true;
}
/**
* 指定の日付形式にフォーマットする
* @param str：文字列の日付
* @param pattern:パターン
* @return 指定の日付形式にフォーマットされた文字列の日付
* @return エラーの場合:NULL
*/
public static String formatDate(String str, String pattern) {
String ret = null;
String[] dates = str.split("/");
if (dates.length != 3) {
return ret;
} else if (booleancheckFullSize(str)) {
return ret;
} else if (!(checkYear(dates[0])
&& dates[1].length() > 0 && dates[1].length() < 3
&& dates[2].length() > 0 && dates[2].length() < 3)) {
return ret;
}
try {
int yyyy = new Integer(dates[0]).intValue();
int mm = new Integer(dates[1]).intValue();
int dd = new Integer(dates[2]).intValue();
Calendar cal = new GregorianCalendar();
cal.setLenient(false);
cal.set(yyyy, mm - 1, dd);
Date date = cal.getTime();
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
ret = sdf.format(date);
} catch (Exception ex) {
return null;
}
return ret;
}
/**
* 日付変換<BR>
* 渡された文字列を日付型に変換して返す
*
* @param _strDate
* 日付変換対象文字列
* @return Date 変換後日付
* @exception ParseException
* @throws SystemException
*/
public static Date toDateType(String _strDate) throws SystemException {
// ローカル変数宣言//
Date dateRet_ = null; // 返却日付格納用
SimpleDateFormat sdfObject_ = null; // SimpleDateFormatクラスデータ型変数
try {
// 1.日付変換対象の文字列のレングスにより、処理を分ける
if (_strDate.length() == 6) {
// 1.1.レングスが6の場合
// /1.1.1.yyyyMMのオブジェクトを生成する
sdfObject_ = new SimpleDateFormat(YEAR_MONTH_FORMAT_SHORT);
// /1.1.2.変換対象文字列を日付型へ変換する
dateRet_ = sdfObject_.parse(_strDate);
} else if (_strDate.length() == 7) {
// 1.2.レングスが7の場合
// /1.2.1.yyyy/MMのオブジェクトを生成する
sdfObject_ = new SimpleDateFormat(YEAR_MONTH_FORMAT);
// /1.2.2.変換対象文字列を日付型へ変換する
dateRet_ = sdfObject_.parse(_strDate);
} else if (_strDate.length() == 8) {
// 1.3.レングスが8の場合
// /1.3.1.yyyyMMddのオブジェクトを生成する
sdfObject_ = new SimpleDateFormat(DATE_FORMAT_SHORT);
// /1.3.2.変換対象文字列を日付型へ変換する
dateRet_ = sdfObject_.parse(_strDate);
} else if (_strDate.length() == 10) {
// 1.4.レングスが8でない場合
// /1.4.1.yyyy/MM/ddのオブジェクトを生成する
sdfObject_ = new SimpleDateFormat(DATE_FORMAT_LONG);
// /1.4.2.変換対象文字列を日付型へ変換する
dateRet_ = sdfObject_.parse(_strDate);
} else if (_strDate.length() == 19) {
// 1.5.レングスが19でない場合
// /1.5.1.yyyy/MM/dd|HH:mm:ssのオブジェクトを生成する
sdfObject_ = new SimpleDateFormat(DATE_FORMAT_RECORD_DATE);
// /1.5.2.変換対象文字列を日付型へ変換する
dateRet_ = sdfObject_.parse(_strDate);
}
else {
// 16.該当するレングスがない場合
// /1.6.1.nullを返す
dateRet_ = null;
}
} catch (Exception e) {
// 2.例外が発生した場合
// 2.1. NULLを返却する
dateRet_ = null;
}
// 3.変換後日付を返す
return dateRet_;
}
/**
* 日付期間チェック<BR>
* 開始日付と終了日付の関係をチェックし、チェック結果を返す
*
* @param _strStartDate
* 開始日付
* @param _strEndDate
* 終了日付
* @return boolean チェック結果（開始日付≦終了日付：true、開始日付＞終了日付：false）
* @exception SystemException
* @throws SystemException
*/
public static boolean isDateTerm(String _strStartDate, String _strEndDate) {
// ローカル変数宣言//
boolean blnIsDate = false;
Date dateStart_ = null; // 日付型の開始日付格納用
Date dateEnd_ = null; // 日付型の終了日付格納用
// 1.文字列型を日付型に変換する
try {
// 1.1.開始日を日付型に変換する
dateStart_ = toDateType(_strStartDate);
// 1.2.終了日を日付型に変換する
dateEnd_ = toDateType(_strEndDate);
// 2.チェックを行う
if (dateStart_.toString().equals(dateEnd_.toString())) {
// 2.1.開始日付が終了日付等しい場合
// /2.1.1.結果にtrueを設定する
blnIsDate = true;
} else {
// 2.2.開始日付と終了日付が異なる場合
// /2.2.1.開始日付＜終了日付をチェックし、結果を設定する
blnIsDate = dateStart_.before(dateEnd_);
}
} catch (Exception e) {
// 3.例外が発生した場合
// 3.1.システム例外をスローする
blnIsDate = false;
}
// 4.チェック結果を返す
return blnIsDate;
}
/**
* 数値フォーマット
* @param num 数値
* @param pattern フォーマットパターン
* @return フォーマット後の数値
*/
public static String numberFormat(String num, String pattern) {
if (isEmpty(num) || "null".equals(num)) {
return "";
} else if (checkNumeric(num, 9999, true, true, 9999) != 0 || isEmpty(pattern)) {
// 数値じゃない、または、指定フォーマットなし
return num;
}
String ret = null;
Double d = Double.valueOf(num);
DecimalFormat form = new DecimalFormat(pattern);
ret = form.format(d);
return ret;
}
/**
* 数値フォーマット
* @param num 数値
* @param pattern フォーマットパターン
* @return フォーマット後の数値
*/
public static String numberFormat(Double num, String pattern) {
if (isEmpty(num)) {
return "";
} else if (isEmpty(pattern)) {
// 指定フォーマットなし
pattern = "###,###,###,###,###,###,###,###,###,###.########";
}
String ret = null;
Double d = Double.valueOf(num);
DecimalFormat form = new DecimalFormat(pattern);
ret = form.format(d);
return ret;
}
/**
* 数値フォーマット
* @param num 数値
* @param pattern フォーマットパターン
* @return フォーマット後の数値
*/
public static String numberFormat(Long num, String pattern) {
if (isEmpty(num)) {
return "";
} else if (isEmpty(pattern)) {
// 指定フォーマットなし
pattern = "###,###,###,###,###,###,###,###,###,###";
}
String ret = null;
Double d = Double.valueOf(num);
DecimalFormat form = new DecimalFormat(pattern);
ret = form.format(d);
return ret;
}
/**
* 数値フォーマット
* @param num 数値
* @return フォーマット後の数値
*/
public static String numberFormat(String num) {
if (isEmpty(num)) {
return "";
} else if (checkNumeric(num, 9999, true, true, 9999) == 0) {
num = replaceString(num, ",", "");
return numberFormat(num, "###,###,###,###,###,###,###,###,###,###.###");
} else {
return num;
}
}
/**
* 空文字をNULL値に変換する
* @param str:空文字
* @return NULL(空文字の場合)
*/
public static String emptyStringToNull(String str) {
if ("".equals(str)) {
return null;
} else {
return str;
}
}
/**
* NULL値を空文字列に変換する
* @param str:NULL値
* @return 空文字(NULL値の場合)
*/
public static String nullToEmptyString(String str) {
if (isEmpty(str)) {
return "";
} else {
return str;
}
}
/**
* requestからLong値を取得
* @param param
* @return
*/
public static Long toLongFromRequest(String param) {
if (isEmpty(param) || "null".equalsIgnoreCase(param)) {
return null;
} else {
return new Long(param);
}
}
/**
* requestからLong値 or 0(Nullの場合は) を取得
* @param param
* @return
*/
public static Long toLongOrZeroFromRequest(String param) {
if (isEmpty(param)) {
return new Long(0);
} else {
return new Long(param);
}
}
/**
* requestからDouble値を取得
* @param param
* @return
*/
public static Double toDoubleFromRequest(String param) {
if (isEmpty(param) || "null".equalsIgnoreCase(param)) {
return null;
} else {
return new Double(param);
}
}
/**
* requestからDouble値or 0(Nullの場合は)を取得
* @param param
* @return
*/
public static Double toDoubleOrZeroFromRequest(String param) {
if (isEmpty(param)) {
return new Double("0");
} else {
return new Double(param);
}
}
/**
* requestからInteger値or 0(Nullの場合は)を取得
* @param d
* @return
*/
public static Integer toIntegerOrZeroFromRequest(String param) {
if (isEmpty(param)) {
return new Integer("0");
} else {
return new Integer(param);
}
}
/**
* parseDouble　(nvl(d))
* @param param
* @return
*/
public static double parseDouble(String d) {
double ret = 0;
if (isEmpty(d)) {
} else {
ret = Double.parseDouble(d);
}
return ret;
}
/**
* 行MAPの先頭行にブランク行MAPを挿入する。
* @param list 行MAP
* @param valueKey 行MAPのValueのKey名
* @param labelKey　行MAPのLabelのKey名
*/
public static void setFirstBlankElementToRowMapList(List<Map<String, String>> list, String valueKey, String labelKey) {
Map<String, String> firstMap = new HashMap<String, String>();
firstMap.put(valueKey, SstyleConstants.COMBO_BLANK_VALUE);
firstMap.put(labelKey, SstyleConstants.COMBO_BLANK_LABEL);
list.add(0, firstMap);
}
/**
* 文字列の長さを取得する。
* @param str
* @param locale
* @return
*/
public static int getStringLength(String str, Locale locale) {
if (isEmpty(str)) {
return 0;
}
int strLength = 0;
try {
if (Locale.JAPANESE.equals(locale)) {
strLength = str.getBytes("Windows-31J").length;
} else {
strLength = str.length();
}
} catch (UnsupportedEncodingException ex) {
//System.out.println(ex.getStackTrace());
}
return strLength;
}
/**
* it will convert null value into the blank Space for all String properties for the given Object
* @param obj
* @return
*/
public static Object suppressNull(Object obj) throws RuntimeException {
try {
if (obj != null) {
Field[] fieldArray = obj.getClass().getDeclaredFields();
for (int i = 0; i < fieldArray.length; i++) {
if (String.class.equals(fieldArray[i].getType())) {
Object[] args = { "" };
Class[] parameterTypes = new Class[] { fieldArray[i].getType() };
String methodName = "get" + fieldArray[i].getName().substring(0, 1).toUpperCase()
+ fieldArray[i].getName().substring(1);
Method method = obj.getClass().getMethod(methodName, new Class[0]);
Object value = method.invoke(obj, new Object[0]);
if (value == null) {
methodName = "set" + fieldArray[i].getName().substring(0, 1).toUpperCase()
+ fieldArray[i].getName().substring(1);
method = obj.getClass().getMethod(methodName, parameterTypes);
value = method.invoke(obj, args);
}
}
}
}
} catch (NoSuchMethodException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException(ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
}
return obj;
}
/**
* リソースから項目名をgetする
* @param key
* @return
* @throws MessageManagerException
*/
public static String getMessageResource(String appricationID, String key, Locale locale) throws MessageManagerException {
String message = null;
if (checkHalfSize(key)) {
// 全て半角文字
// リソースの取得
MessageManager messageManager = MessageManager.getMessageManager();
message = messageManager.getMessage(appricationID, key, null, locale);
} else {
message = key;
}
// リソースが取得できなかった場合。
if (("???" + key + "???").equals(message)) {
message = key;
}
return message;
}
/**
* サービスURLを返す。
* @param id
* @return
* @throws ServiceManagerException
*/
public static String getServiceURL(String applicationId, String id) throws ServiceManagerException {
ServiceManager serviceManager = ServiceManager.getServiceManager();
String serviceURL = applicationId + ServiceServlet.REQUEST_SEPARATOR + id + SstyleConstants.KEY_SERVICE + "."
+ serviceManager.getExtesion();
return serviceURL;
}
/**
* オブジェクトがnull,または型がStringの場合は空文字列か判定する。
* @param object
* @return true...null・空・"0"・"0.0" / false...null・空でない
*/
public static boolean isEmptyOrZero(Object object) {
if (object == null) {
return true;
}
if (object instanceof String) {
if ("".equals(((String) object))) {
return true;
}
}
if (object instanceof Long) {
if (((Long) object).longValue() == 0) {
return true;
}
}
if (object instanceof Double) {
if (((Double) object).doubleValue() == 0) {
return true;
}
}
return false;
}
/**
* List 2次元配列から String 2次元配列に変換する。
* @param list
* @return
*/
public static String[][] list2Array(List<List<String>> list) {
List<String[]> tmp = new ArrayList<String[]>();
for (int i = 0; i < list.size(); i++) {
List<String> row = (List<String>) list.get(i);
String[] rowArray = (String[]) row.toArray(new String[0]);
tmp.add(rowArray);
}
String[][] dataArray = (String[][]) tmp.toArray(new String[list.size()][]);
return dataArray;
}
/**
* 区切り文字で区切られた文字列から文字列配列を取得する。
* （例：×××,○○○から×××と○○○を取り出す。）
* @param commaVal
* @return
*/
public static String[] split(String val, String separateStr) {
List<String> list = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(val, separateStr);
// log.debug("-- トークンされたカウント" + st.countTokens());
// 値を取得
while (st.hasMoreTokens()) {
list.add(st.nextToken());
}
return (String[]) list.toArray(new String[list.size()]);
}
/**
* 引数の文字列配列からseparateStr区切りの文字列を取得する。
* @param val
* @param separateStr
*/
public static String join(String[] val, String separateStr) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < val.length; i++) {
sb.append(val[i]);
sb.append(separateStr);
}
String joinVal = sb.toString();
// 結合後最後のseparateStrを削る。
return joinVal.substring(0, joinVal.length() - 1);
}
/**
* Long型をDouble型に変換する
* @param param
* @return
*/
public static Double toDoubleOrZeroFromLong(Long long1) {
if (isEmpty(long1)) {
return new Double("0");
} else {
return new Double(long1.doubleValue());
}
}
/**
* Long型の値がnullだったら0をセット
* @param long1
* @return
*/
public static Long toLongOrZeroFromLong(Long long1) {
if (isEmpty(long1)) {
return new Long("0");
} else {
return long1;
}
}
/**
* Double型の値がnullだったら0をセット
* @param double1
* @return
*/
public static Double toDoubleOrZeroFromDouble(Double double1) {
if (isEmpty(double1)) {
return new Double("0");
} else {
return double1;
}
}
/**
* requestからString値or ""(Nullの場合は)を取得
* @param d
* @return
*/
public static String toStringFromRequest(String param) {
if (isEmpty(param)) {
return "";
} else {
return param;
}
}
/**
* CSVを取り込みStringの二次元配列を返却する。
* @param filePath CSVファイルのパス
* @param セパレータ
* @return 読み込んだCSVデータの行列
* @throws SystemFatalException
*/
public static String[][] getCsvList(String filePath, String separator) throws IOException {
try {
// 戻り値のList生成
ArrayList<String[]> retArray = new ArrayList<String[]>();
// 区切り文字
char chSeparator = separator.charAt(0);
BufferedReader reader = new BufferedReader(new FileReader(filePath));
String line = null;
// 1行ごとに繰り返す
while (null != (line = reader.readLine())) {
String[] colmuns = getColumnsOfLine(line, chSeparator);
retArray.add(colmuns);
}
reader.close();
return (String[][]) retArray.toArray(new String[retArray.size()][]);
} catch (IOException ex) {
throw new IOException(ex.getMessage());
}
}
/**
* 1行分のデータからカラム毎に区切る。
* @param line 1行分のデータ
* @param separator セパレータ
* @return カラム毎のStringの配列
*/
public static String[] getColumnsOfLine(String line, char separator) {
ArrayList<String> colmuns = new ArrayList<String>();
char[] charArray = line.toCharArray();
int startPos = 0;
int endPos = 0;
boolean isOpen = false;
for (int i = 0; i < charArray.length; i++) {
boolean isLast = false;
if (i == charArray.length - 1) {
isLast = true;
}
if (charArray[i] == '"') {
if (!isOpen) {
startPos = i + 1;
isOpen = true;
} else {
if (!isLast && charArray[i + 1] == '"') {
i++;
continue;
} else {
isOpen = false;
}
}
} else if (charArray[i] == separator) {
if (isOpen) {
continue;
}
if (i == 0) {
endPos = i;
} else if (charArray[i - 1] == '"') {
endPos = i - 1;
} else {
endPos = i;
}
int len = endPos - startPos;
String column = "";
if (len != 0) {
column = String.copyValueOf(charArray, startPos, len);
// column = column.replaceAll("\"\"","\"");
}
colmuns.add(column.trim());
startPos = i + 1;
}
if (isLast) {
if (charArray[i] == '"') {
endPos = i - 1;
} else {
endPos = i;
}
int len = endPos - startPos + 1;
String column = "";
if (len != 0) {
column = String.copyValueOf(charArray, startPos, len);
// column = column.replace("\"\"","\"");
}
colmuns.add(column.trim());
}
}
return (String[]) colmuns.toArray(new String[colmuns.size()]);
}
/**
* String型で指定された数値データに、小数点以下の桁数をそろえるために0
* を追加したり、整数部にカンマを追加したりします。
* @param src 処理対象の文字列(double型として認識できること)
* @param scale 小数部の桁数
* @return
*/
public static String formatNumber(String src, int scale) {
if (isEmpty(src)) {
return "";
} else if ( checkNumeric(src, 10000, true, true, 10000) != 0) {
return src;
}
src = src.trim();
StringBuffer srcbuf = new StringBuffer(src);
/* まず整数部、小数部の桁数を求める */
int seiketa, shouketa;
int dotloc = src.indexOf('.');
if (dotloc == -1) {
/* 小数点がない */
seiketa = src.length();
shouketa = 0;
} else {
/* その他(先頭が小数点の場合も含む) */
seiketa = dotloc;
shouketa = src.length() - dotloc - 1;
}
/* shouketaがscaleに満たない場合、右に0を足す */
if (shouketa == 0 && scale != 0) {
srcbuf.append('.');
}
for (int i = shouketa; i < scale; i++) {
srcbuf.append('0');
}
/* カンマ区切り */
if (seiketa > 3) {
int startIndex = seiketa % 3;
if (startIndex == 0) {
startIndex = 3;
}
for (int i = startIndex; i < seiketa; i += 3) {
srcbuf.insert(i++, ',');
}
}
/* 先頭が小数点の場合、先頭に0をつける */
if (dotloc == 0) {
srcbuf.insert(0, '0');
}
return srcbuf.toString();
}
/**
* 値変換
* @param
* @return
*/
public static String cnvStringNull(String object) {
if (isEmpty(object)) {
return "";
} else {
return object;
}
}
/**
* String型の数値文字列をLong型の数値に変換する
* @param object:String型の数値文字列
* @return Long型の数値(NULL値は0)
*/
public static Long cnvLongNull(String object) {
if (isEmpty(object)) {
return new Long(0);
} else {
return new Long(object);
}
}
/**
* Long型の数値をString型の数値文字列に変換する
* @param object:Long型の数値
* @return String型の数値文字列(NULL値は空文字)
*/
public static String cnvLongtoStr(Long object) {
if (isEmpty(object)) {
return "";
} else {
return object.toString();
}
}
/**
* String型の数値文字列をInteger型の数値に変換する
* @param object:String型の数値文字列
* @return Integer型の数値(NULL値は0)
*/
public static Integer cnvIntegerNull(String object) {
if (isEmpty(object)) {
return new Integer(0);
} else {
return new Integer(object);
}
}
/**
* Integer型の数値をString型の数値文字列に変換する
* @param object:Integer型の数値
* @return String型の数値文字列(NULL値は空文字)
*/
public static String cnvIntegerStr(Integer object) {
if (isEmpty(object)) {
return "";
} else {
return object.toString();
}
}
/**
* String型の数値文字列をDouble型の数値に変換する
* @param object:String型の数値文字列
* @return Double型の数値(NULL値は0)
*/
public static Double cnvDoubleNull(String object) {
if (isEmpty(object)) {
return new Double(0);
} else {
return new Double(object);
}
}
/**
* Double型の数値をString型の数値文字列に変換する
* @param object:Double型の数値
* @return String型の数値文字列(NULL値は空文字)
*/
public static String cnvDoubleStr(Double object) {
if (isEmpty(object)) {
return "";
} else {
return object.toString();
}
}
/**
* Double型の数値をString型の数値文字列に変換する
* 小数点以下が0の場合、整数値を戻す
* 小数点以下が0以上の場合、フォーマット後の数値を戻す
* @param object
* @param pattern
* @return
*/
public static String cnvDoubleStrZeroRoundOff(Double object, String pattern) {
if (isEmpty(object)) {
return "";
}
long l = (long)object.doubleValue();
double d = object.doubleValue() - l;
if (d == 0) {
// 整数値
return numberFormat(String.valueOf(l));
}
// フォーマッティング
return numberFormat(String.valueOf(object), pattern);
}
/**
* 文字列のバイト数を返します。
* @param str
* @return バイト数
*/
public static int getByteLength(String str) {
int len;
try {
len = str.getBytes("Windows-31J").length;
} catch (UnsupportedEncodingException ex) {
len = -1;
}
return len;
}
/**
* 文字列の置換
* @param str:文字列
* @param patternStr:置換対象の文字列
* @param replaceStr:置換後の文字列
* @return 置換後の文字列
*/
public static String replaceString(String str, String patternStr, String replaceStr) {
if (str == null || patternStr == null || replaceStr == null) {
return str;
}
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(str);
return matcher.replaceAll(replaceStr);
}
/**
* 半角カナのチェック
* @param str
* @return true:全て半角カナ false:半角カナ以外が存在する
*/
public static boolean checkHankakuKana(String str) {
String HANKAKU_KANA = SstyleConstants.HANKAKU_KANA;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (-1 == HANKAKU_KANA.indexOf((int) c)) {
return false;
}
}
return true;
}
/**
* 半角カナ・英数字のチェック
* @param str
* @return true:全て半角カナ・英数字 false:半角カナ・英数字以外が存在する
*/
public static boolean checkHankakuKanaAlphabetDegit(String str) {
String HANKAKU = SstyleConstants.HANKAKU_KANA_ALPHABET_DEGIT;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (-1 == HANKAKU.indexOf((int) c)) {
return false;
}
}
return true;
}
/**
* 半角文字のチェック
* @param str
* @return true:全て半角文字 false:半角文字以外が存在する
*/
public static boolean checkHankaku(String str) {
String HANKAKU = SstyleConstants.HANKAKU;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (-1 == HANKAKU.indexOf((int) c)) {
return false;
}
}
return true;
}
/**
* 全角入力チェック
* @param str
* @return true:全て全角 false:全角以外が存在する
*/
public static boolean booleancheckFullSize(String str) {
byte[] bytes;
bytes = str.getBytes();
// lengthを２倍する
int beams = str.length() * 2;
StringBuffer sb = new StringBuffer(str);
for (int i = 0; i < str.length(); i++) {
// 改行コードは対象外とする
if ('\n' == sb.charAt(i)) {
beams = beams - 2;
}
}
// lengthの２倍とバイト数が異なる場合は半角が含まれている
if (beams != bytes.length) {
return false;
}
return true;
}
/**
* 半角入力チェック
* @param str
* @return true:全て半角 false:半角以外が存在する
*/
public static boolean checkHalfSize(String str) {
byte[] bytes;
bytes = str.getBytes();
int beams = str.length();
StringBuffer sb = new StringBuffer(str);
for (int i = 0; i < str.length(); i++) {
//改行コードは対象外とする
if ('\n' == sb.charAt(i)) {
beams = beams - 2;
}
}
//lengthとバイト数が異なる場合は全角が含まれている
if (beams != bytes.length) {
return false;
}
return true;
}
/**
* 半角数字入力チェック
* @param str
* @return true:全て半角数字 false:半角数字以外が存在する
*/
public static boolean checkDigit(String str) {
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if ((c < '0' || c > '9')) {
if (c != '-' && c != '.') {
//数字でない
return false;
}
}
}
return true;
}
/**
* 半角英字チェック
* @param str
* @return true:全て半角英字 false:半角英字以外が存在する
*/
public static boolean checkAlphabet(String str) {
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if ((c < 'a' || c > 'z') && //小文字アルファベットでない
(c < 'A' || c > 'Z')) { //大文字アルファベットでない
return false;
}
}
return true;
}
/**
* 半角英数チェック
* @param str
* @return true:全て半角英数 false:半角英数以外が存在する
*/
public static boolean checkDigitAlphabet(String str) {
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if ((c < '0' || c > '9') && //数字でない
(c < 'a' || c > 'z') && //小文字アルファベットでない
(c < 'A' || c > 'Z')) { //大文字アルファベットでない
return false;
}
}
return true;
}
/**
* 文字列のチェック（許可されている文字のチェック）
* @param checkType:チェックタイプ
* @param str:チェックする文字列
* @return true:全て許可文字 false:許可されていない文字を含む
*/
public static boolean checkCharacter(int checkType, String str) {
boolean ret = true;
String CHECK_CHARACTER = "";
if (checkType==0) {
// ロケーションコード
CHECK_CHARACTER = SstyleConstants.PERMITTED_CHARACTER_01;
} else {
// 機種依存文字チェック
CHECK_CHARACTER = SstyleConstants.PLATFORM_DEPENDENT_CHARACTER;
}
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (CHECK_CHARACTER.indexOf((int) c) == -1) {
// 許可されている文字と一致しなかった
ret = false;
break;
}
}
return ret;
}
/**
* 機種依存文字チェック
* @param str
* @return true:機種依存文字なし false:機種依存文字あり
*/
public static boolean checkPlatformDependentCharacter(String str) {
String CHECK_CHARACTER = SstyleConstants.PLATFORM_DEPENDENT_CHARACTER;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (CHECK_CHARACTER.indexOf((int) c) != -1) {
return false;
}
}
return true;
}
/**
* 郵便番号チェック
* @param zipCd
* @return true:正常 false:異常
*/
public static boolean checkZipCd(String zipCd) {
if (isEmpty(zipCd) || zipCd.length() != 8) {
// 空、8文字以外
return false;
}
String zipCd1 = zipCd.substring(0, 3); // 前3桁
String zipCd2 = zipCd.substring(3, 4); // ハイフン
String zipCd3 = zipCd.substring(4); // 後4桁
if (checkNumeric(zipCd1, 3, false) != 0
|| !"-".equals(zipCd2)
|| checkNumeric(zipCd3, 4, false) != 0) {
// 前3桁が数値じゃない
// ハイフンじゃない
// 後4桁が数値じゃない
return false;
}
return true;
}
/**
* 機種依存文字チェック(SM1800「お知らせ内容」専用)
* @param str
* @return true:機種依存文字なし false:機種依存文字あり
*/
public static boolean checkPlatformDependentCharacter2(String str) {
String CHECK_CHARACTER = SstyleConstants.PLATFORM_DEPENDENT_CHARACTER2;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (CHECK_CHARACTER.indexOf((int) c) != -1) {
return false;
}
}
return true;
}
/**
*
* @param str
* @param maxBytes
* @return
* @throws UnsupportedEncodingException
*/
public static String spaceSuppress(String str, int maxBytes) {
String retStr = "";
String tmpStr = "";
try {
byte[] bytes = str.getBytes("windows-31j");
int len = bytes.length;
if (maxBytes < len) {
for (int i = 0; i < str.length(); i++) {
tmpStr += str.charAt(i);
if (maxBytes < tmpStr.getBytes("windows-31j").length) {
break;
} else {
retStr = tmpStr;
}
}
} else {
retStr = str;
}
bytes = retStr.getBytes("windows-31j");
len = bytes.length;
while (maxBytes != len) {
retStr += "&nbsp;";
bytes = retStr.getBytes("windows-31j");
len += 1;
}
return retStr;
} catch (UnsupportedEncodingException ex) {
return str;
}
}
/**
* 引数で渡されてた文字列の左トリムを行います
* @param target 置換対象となる文字列
* @return 変換後の文字列
*/
public static String trimLeftCharacter(String target) {
if (target == null) {
return "";
}
return target.replaceAll("^ +", "");
}
/**
* 引数で渡されてた文字列の右トリムを行います
* @param target 置換対象となる文字列
* @return 変換後の文字列
*/
public static String trimRightCharacter(String target) {
if (target == null) {
return "";
}
return target.replaceAll(" +$", "");
}
/**
* check format of number
* ex. check 9999.99 except [9999.], [9,999], [9,999.99], [.99]<br>
* [notes] in case .99. or 999.. is not support now, count '.' for check
* @param inNum
* @param pos
* @param scale
* @return true if valid format, false otherwise
*/
public static boolean checkNumberFormat(String inNum, int pos, int scale) {
boolean isValid = false;
if (isEmpty(inNum)) {
return isValid;
}
inNum = replaceString(inNum, ",", "");
int dotPos = inNum.indexOf(".");
if (dotPos != -1) {
String[] nums = split(inNum, ".");
if (nums.length == 2) {
if (checkDigit(nums[0]) && checkDigit(nums[1])) {
isValid = (nums[0].length() <= pos) && (nums[1].length() <= scale);
}
} else if ((nums.length == 1)) {
// case .99
if ((dotPos == 0)) {
isValid = checkDigit(nums[0]) && nums[0].length() <= scale;
}
// case 9999.
else if (dotPos == nums[0].length()) {
isValid = checkDigit(nums[0]) && nums[0].length() <= pos;
}
}
} else {
isValid = (checkDigit(inNum) && inNum.length() <= pos);
}
return isValid;
}
/*
* HTML特殊文字の修飾
*/
public static String stringModifi(String inStr) {
if (inStr != null) {
if (inStr.indexOf("&nbsp;") == -1) {
inStr = inStr.replaceAll("&", "&#38;");
inStr = inStr.replaceAll("\"", "&#34;");
inStr = inStr.replaceAll("<", "&#60;");
inStr = inStr.replaceAll(">", "&#62;");
}
}
return inStr;
}
/**
* CSV文字列の分割
* @param inStr
* @return String[]
*/
public static String[] csvStringCut(String inStr) {
String retstr[] = { "" };
boolean conmaFlag = false;
if (inStr != null) {
int findcnt = 0;
char ch[] = inStr.toCharArray();
StringBuffer dmy = new StringBuffer();
for (int idx = 0; idx < ch.length; idx++) {
if (ch[idx] == '\"') {
findcnt++;
if (findcnt > 1) {
findcnt = 0;
}
}
if (ch[idx] == ',') {
if (findcnt > 0) {
dmy.append("@@DMY@@");
} else {
if (conmaFlag) {
dmy.append("\"\"" + ch[idx]);
} else {
dmy.append(ch[idx]);
}
}
conmaFlag = true;
} else {
dmy.append(ch[idx]);
conmaFlag = false;
}
}
if (inStr.length() == inStr.lastIndexOf(",")+1) {
dmy.append("\"\"");
}
retstr = dmy.toString().split(",");
for (int idx = 0; idx < retstr.length; idx++) {
retstr[idx] = retstr[idx].trim();
retstr[idx] = retstr[idx].replaceAll("\"", "");
retstr[idx] = retstr[idx].replaceAll("@@DMY@@", ",");
}
}
return retstr;
}
/**
* CSV文字列の分割(Tab区切り)
* @param inStr
* @return String[]
*/
public static String[] csvStringCut_Tab(String inStr) {
String retstr[] = { "" };
boolean conmaFlag = false;
if (inStr != null) {
int findcnt = 0;
char ch[] = inStr.toCharArray();
StringBuffer dmy = new StringBuffer();
for (int idx = 0; idx < ch.length; idx++) {
if (ch[idx] == '\"') {
findcnt++;
if (findcnt > 1) {
findcnt = 0;
}
}
if (ch[idx] == ',') {
if (findcnt > 0) {
dmy.append("@@DMY@@");
} else {
if (conmaFlag) {
dmy.append("\"\"" + ch[idx]);
} else {
dmy.append(ch[idx]);
}
}
conmaFlag = true;
} else {
dmy.append(ch[idx]);
conmaFlag = false;
}
}
if (inStr.length() == inStr.lastIndexOf(",")+1) {
dmy.append("\"\"");
}
retstr = dmy.toString().split("\t");
for (int idx = 0; idx < retstr.length; idx++) {
retstr[idx] = retstr[idx].trim();
retstr[idx] = retstr[idx].replaceAll("\"", "");
retstr[idx] = retstr[idx].replaceAll("@@DMY@@", ",");
}
}
return retstr;
}
/**
* 数値チェック
* @param num : 対象数値（文字列）
* @param maxLength : 最大入力可能文字数（整数部分・マイナス記号は含まない）
* @param acceptMinus : マイナス入力可否（true:可　false:不可）
* @return 0:正常値
* @return -1:入力形式エラー
* @return -2:桁数オーバー（整数部分）
* @return -3:桁数オーバー（整数部分または小数部分）
*/
public static int checkNumeric(String num, int maxLength, boolean acceptMinus) {
return checkNumeric(num, maxLength, acceptMinus, false, 0);
}
/**
* 数値チェック
* @param num : 対象数値（文字列）
* @param maxLength : 最大入力可能文字数（整数部分・マイナス記号は含まない）
* @param acceptMinus : マイナス入力可否（true:可　false:不可）
* @param acceptDecimal : 小数点以下入力可否（true:可　false:不可）
* @param maxDecimalLength : 最大入力可能文字数（小数部分・小数点記号は含まない）
* @return 0:正常値
* @return -1:入力形式エラー
* @return -2:桁数オーバー（整数部分）
* @return -3:桁数オーバー（整数部分または小数部分）
*/
public static int checkNumeric(String num, int maxLength, boolean acceptMinus, boolean acceptDecimal, int maxDecimalLength) {
int errorNo = 0;
int checkMaxLength = maxLength; // チェック用
String checkInteger = ""; // チェック用（整数部分）
String checkDecimal = ""; // チェック用（小数点以下部分）
int minusPos = 0; // マイナス記号の位置
int dotPos = 0; // 小数点の位置
if (isNotEmpty(num)) {
String wNum = num.replaceAll(",", "");
if (isEmpty(wNum))
return -1;
checkInteger = wNum;
// 半角の数値かどうか
for (int i = 0; i < wNum.length(); i++) {
char c = wNum.charAt(i);
if ((c < '0' || c > '9')) {
if (c != '-' && c != '.') {
// 半角の数値以外が含まれる（入力形式エラー）
return -1;
}
}
}
// マイナス記号の位置
minusPos = wNum.indexOf("-");
// 小数点の位置
dotPos = wNum.indexOf(".");
// マイナスのチェック
if (minusPos != -1) {
// マイナスあり
if (acceptMinus) {
// マイナス入力可
if (wNum.length() == 1) {
// マイナス記号だけ（入力形式エラー）
return -1;
}
if (minusPos != 0) {
// 先頭にマイナスがない（入力形式エラー）
return -1;
} else {
int minusCnt = 0;
for (int i = 0; i < wNum.length(); i++) {
char c = wNum.charAt(i);
if (c == '-') {
minusCnt += 1;
}
}
// マイナス記号が複数存在（入力形式エラー）
if (minusCnt > 1) {
return -1;
}
// マイナス分最大入力数（整数部分）を増やす
checkMaxLength += 1;
}
} else {
// マイナス入力不可（入力形式エラー）
return -1;
}
}
// 小数点のチェック
if (dotPos != -1) {
// 小数点あり
if (acceptDecimal) {
// 小数点入力可
if (wNum.length() == 1) {
// "."のみ入力の場合（入力形式エラー）
return -1;
} else if (dotPos == 0) {
// 先頭に小数点があったら入力形式エラー
return -1;
} else if (dotPos == 1 && minusPos == 0) {
// "-."という入力の場合、入力形式エラー
return -1;
} else if (dotPos == wNum.length()) {
// 最後に小数点があったら入力形式エラー
return -1;
} else {
int dotCnt = 0;
for (int i = 0; i < wNum.length(); i++) {
char c = wNum.charAt(i);
if (c == '.') {
dotCnt += 1;
}
}
//　dot記号が複数存在（入力形式エラー）
if (dotCnt > 1) {
return -1;
}
}
String[] wNums = split(wNum, ".");
if (wNums.length == 1) {
// .99、99.の場合（上でひっかかるけど）
return -1;
} else if (wNums.length == 2) {
checkInteger = wNums[0];
checkDecimal = wNums[1];
} else {
// 小数点が複数存在（入力形式エラー）
return -1;
}
} else {
// 小数点入力不可（入力形式エラー）
return -1;
}
}
// 桁数のチェック
if (!acceptDecimal) {
// 整数とマイナスあり整数値
if (checkInteger.length() > checkMaxLength) {
return -2; // 整数値の桁数エラー
}
} else {
// 小数を含む数値
if (checkInteger.length() > checkMaxLength || checkDecimal.length() > maxDecimalLength) {
return -3; // 整数値、少数点以下の桁数エラー
}
}
}
return errorNo;
}
/**
* 文字列の小文字を大文字に変換する
* @param str : 変換対象文字列
* @return 大文字変換された文字列
*/
public static String getToUpperCase(String str) {
if (isEmpty(str)) {
return str;
}
return str.toUpperCase();
}
/**
* オブジェクトのディープコピーを行います
* （但しオブジェクトがSerializable インターフェースを実装している場合のみ）
* @param targetObject
* @return コピーされたオブジェクト
*/
public static Object deepCopyObject(Object targetObject) {
if (targetObject == null) {
return targetObject;
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(targetObject);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
Object copyObject = ois.readObject();
return copyObject;
} catch (IOException ex) {
return null;
} catch (ClassNotFoundException ex) {
return null;
}
}
/**
* 指定文字長まで前0を詰めます。
* @param str:文字列
* @param paddingLength:指定文字長(対象文字列含む)
* @return
*/
public static String zeroPadding(String str, int paddingLength) {
int strLength = str.length();
for (int i = strLength; i < paddingLength; i++) {
str = "0" + str;
}
return str;
}
/**
* 文字列に指定の文字を指定バイト数まで詰めます。
* @param str:挿入対象の文字列
* @param insertStr:挿入する文字
* @param maxBytes:挿入後のバイト数
* @param position:挿入位置(P:前 B:後)
* @return
*/
public static String strPadding(String str, String insertStr, int maxBytes, String position) {
String retStr = "";
String tmpStr = "";
try {
byte[] bytes = str.getBytes("windows-31j");
int len = bytes.length;
if (maxBytes < len) {
for (int i = 0; i < str.length(); i++) {
tmpStr += str.charAt(i);
if (maxBytes < tmpStr.getBytes("windows-31j").length) {
break;
} else {
retStr = tmpStr;
}
}
} else {
retStr = str;
}
bytes = retStr.getBytes("windows-31j");
len = bytes.length;
while (maxBytes != len) {
if ("P".equals(position)) {
retStr = insertStr + retStr;
} else {
retStr += insertStr;
}
bytes = retStr.getBytes("windows-31j");
len += 1;
}
return retStr;
} catch (UnsupportedEncodingException ex) {
return str;
}
}
/**
* 指定バイト数での文字列抜き出し
* 半全角混在で、抜き出しポイントが指定バイト数を超える場合は、
* 指定バイト未満で抜き出します。
* @param str : 対象文字列
* @param len : 抜き出す長さ（バイト）
* @return 文字列
*/
public static String getSubStringBytes(String str, int len) {
char wStr;
String tmpStr = "";
if (str==null) {
return str;
}
try {
for (int i = 0; i < str.length(); i++) {
wStr = str.charAt(i);
if ((tmpStr+wStr).getBytes("Windows-31J").length == len) {
return tmpStr+wStr;
} else if ((tmpStr+wStr).getBytes("Windows-31J").length > len) {
return tmpStr;
}
tmpStr += wStr;
}
} catch (UnsupportedEncodingException ex) {
}
return tmpStr;
}
/**
* 指定バイト数での文字列抜き出し、配列で返す
* 半全角混在で、抜き出しポイントが指定バイト数を超える場合は、
* 指定バイト未満で抜き出します。
* @param str : 対象文字列
* @param len : 抜き出す長さ（バイト）
* @return 文字列
*/
public static List getSubStringList(String str, int len) {
String wStr;
String tmpStr = "";
List<String> retList = new ArrayList<String>();
if (str==null) {
retList.add(str);
return retList;
}
try {
for (int i = 0; i < str.length(); i++) {
wStr = String.valueOf(str.charAt(i));
if ((tmpStr+wStr).getBytes("Windows-31J").length == len) {
retList.add(tmpStr+wStr);
tmpStr = "";
wStr = "";
} else if ((tmpStr+wStr).getBytes("Windows-31J").length > len) {
retList.add(tmpStr);
tmpStr = "";
wStr = "";
} else {
if ((i+1) == str.length()) {
if ((tmpStr+wStr).getBytes("Windows-31J").length <= len) {
retList.add(tmpStr+wStr);
} else {
retList.add(tmpStr);
retList.add(String.valueOf(wStr));
}
}
}
tmpStr += wStr;
}
} catch (UnsupportedEncodingException ex) {
}
return retList;
}
/**
* チェックデジットの生成(モジュラス10ウエイト3(M10W3)
* @param pCode:コード(8～12桁)
* @return チェックデジット
*/
public static String getCheckDegitM10W3(String pCode) {
String wCode = strPadding(pCode, "0", 12, "P");
List codeList = getSubStringList(wCode, 1);
long checkDegit = 0;
for (int i = 0; i < codeList.size(); i++) {
if (i % 2 == 1) {
checkDegit += Long.valueOf((String)codeList.get(i)) * 3;
} else {
checkDegit += Long.valueOf((String)codeList.get(i));
}
}
checkDegit = 10 - (checkDegit % 10);
if (checkDegit == 10) {
checkDegit = 0;
}
return String.valueOf(checkDegit);
}
/**
* 端数処理
* @param fractionFlag:端数処理区分
* @param value:値
* @param digit:端数処理位置
* @return
*/
public static double fractionProcessing(String fractionFlag, double value, int digit) {
double ret = value;
if (SstyleConstants.FRACTION_FLAG_HARF_ADJUST.equals(fractionFlag)) {
// 四捨五入
ret = round(value, digit);
} else if (SstyleConstants.FRACTION_FLAG_HARF_OMISSION.equals(fractionFlag)) {
// 切捨て
ret = floor(value, digit);
} else if (SstyleConstants.FRACTION_FLAG_HARF_ROUND_UP.equals(fractionFlag)) {
// 切り上げ
ret = ceil(value, digit);
}
return ret;
}
/**
* 四捨五入
* @param value
* @param roundDigit
* @return round(10.1234,2)---> 10.12
*/
public static double round(double value, int roundDigit) {
double roundMultiple = 1;
for (int i = 0; i < roundDigit; i++) {
roundMultiple *= 10;
}
long longVal = (Math.round(value * roundMultiple));
double retval = longVal / roundMultiple;
return retval;
}
/**
* 四捨五入
* @param value
* @param roundDigit
* @return round(10.1234,2)---> 10.12
*/
public static double round(double value, long roundDigit) {
BigDecimal bValue = new BigDecimal(String.valueOf(value));
double roundMultiple = 1;
for (int i = 0; i < roundDigit; i++) {
roundMultiple *= 10;
}
BigDecimal bRoundMultiple = new BigDecimal(roundMultiple);
long longVal = (Math.round(bValue.multiply(bRoundMultiple).doubleValue()));
double retval = longVal / roundMultiple;
return retval;
}
/**
* 切り上げ
* @param value
* @param ceilDigit
* @return
*/
public static double ceil(double value, int ceilDigit) {
BigDecimal bValue = new BigDecimal(String.valueOf(value));
double ceilMultiple = 1;
for (int i = 0; i < ceilDigit; i++) {
ceilMultiple *= 10;
}
BigDecimal bCeilMultiple = new BigDecimal(ceilMultiple);
double longVal = (Math.ceil(bValue.multiply(bCeilMultiple).doubleValue()));
double retVal = longVal / ceilMultiple;
return retVal;
}
/**
* 切捨て
* @param value
* @param floorDigit
* @return
*/
public static double floor(double value, int floorDigit) {
BigDecimal bValue = new BigDecimal(String.valueOf(value));
double floorMultiple = 1;
for (int i = 0; i < floorDigit; i++) {
floorMultiple *= 10;
}
BigDecimal bFloorMultiple = new BigDecimal(floorMultiple);
double longVal = (Math.floor(bValue.multiply(bFloorMultiple).doubleValue()));
double retVal = longVal /floorMultiple;
return retVal;
}
// 日付時間初期値（アプリ共通マスタ検索時用）
public static final String DATE_RECORD_DATE_TIME = "|00:00:00";
// 日付フォーマット（yyyyMMdd）
public static final String DATE_FORMAT_SHORT = "yyyyMMdd";
// 年月フォーマット
public static final String YEAR_MONTH_FORMAT_SHORT = "yyyyMM";
// 日付フォーマット（yyyy/MM/dd）
public static final String DATE_FORMAT_LONG = "yyyy/MM/dd";
// 日付フォーマット（MM/dd）
public static final String DATE_FORMAT_SHORT_MD = "MM/dd";
// 日フォーマット
public static final String DATE_FORMAT_SHORT_DD = "dd";
// 日付チェック区分（YYYYMMDD)
public static final String DATE_CHECK_DIV_YYYYMMDD = "yyyyMMdd";
// 日付チェック区分（YYYYMM)
public static final String DATE_CHECK_DIV_YYYYMM = "yyyyMM";
// 日付チェック区分（MMDD)
public static final String DATE_CHECK_DIV_MMDD = "MMDD";
// 日付チェック区分（MM)
public static final String DATE_CHECK_DIV_MM = "MM";
// 日付チェック区分（DD)
public static final String DATE_CHECK_DIV_DD = "DD";
// 日付フォーマット（最終更新日）
public static final String DATE_FORMAT_RECORD_DATE = "yyyy/MM/dd|HH:mm:ss";
// 日付フォーマット（ログ出力）
public static final String DATE_FORMAT_RECORD_DATE_S = "yyyy/MM/dd|HH:mm:ss.SSS";
// 年月フォーマット
public static final String YEAR_MONTH_FORMAT = "yyyy/MM";
// クラス変数宣言//
private static Calendar calObject = null; // Calendarクラスデータ型変数
//日付フォーマット（yyyy年MM月dd日）
public static final String TIME_FORMAT_JAPAN = "yyyy年MM月dd日";
//日付フォーマット（yyyy年MM）
public static final String TIME_FORMAT_MONTH = "yyyy年MM月";
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment