Last active
December 24, 2015 06:59
-
-
Save kaku87/6760980 to your computer and use it in GitHub Desktop.
一些公用方法
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| 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 += " "; | |
| 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(" ") == -1) { | |
| inStr = inStr.replaceAll("&", "&"); | |
| inStr = inStr.replaceAll("\"", """); | |
| inStr = inStr.replaceAll("<", "<"); | |
| inStr = inStr.replaceAll(">", ">"); | |
| } | |
| } | |
| 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