//一天秒數
public final static long MILLISECONDS_OF_DAY = 1000 * 60 * 60 * 24;
public final static long MINUTES_OF_DAY = 1000 * 60 * 60 * 24;
public final static int days[] = {31,29,31,30,31,30,31,31,30,31,30,31};

public final static int WEEK_LENGTH=7;
public final static int YEAR_LENGTH=12;
public final static int NULL_DATE = 19000101;
public final static String NULLDATE="1900-01-01";

public final static int DATETIME_LENGTH = 14;
public final static int DATE_LENGTH = 8;
public final static int TIME_LENGTH = 6;
/**
* 將YYYY-MM-DD HH:NN:SS型別的字串轉化為Date型別
* @param date
* @return Date型別
* @throws ParseException 
*/
public static Date parse(String date) throws ParseException {
boolean isDate = date.indexOf('-') > 0;
boolean isTime = date.indexOf(':') > 0;


if (isDate && isTime) { //日期時間
SimpleDateFormat dateTimeF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return dateTimeF.parse(date);
} else if (isDate) {
SimpleDateFormat dateF = new SimpleDateFormat("yyyy-MM-dd");
return dateF.parse(date);
} else if (isTime) {
SimpleDateFormat timeF = new SimpleDateFormat("HH:mm:ss");
return timeF.parse(date);
}
return new Date(0);
}
/**
* 將YYYY-MM-DD HH:NN:SS.SSS型別的字串轉化為Date型別
* @param date
* @return Date型別
* @throws ParseException 
*/
public static Date parseMinSec(String date) throws ParseException {
boolean isDate = date.indexOf('-') > 0;
boolean isTime = date.indexOf(':') > 0;


if (isDate && isTime) { //日期時間
SimpleDateFormat dateTimeF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
return dateTimeF.parse(date);
} else if (isDate) {
SimpleDateFormat dateF = new SimpleDateFormat("yyyy-MM-dd");
return dateF.parse(date);
} else if (isTime) {
SimpleDateFormat timeF = new SimpleDateFormat("HH:mm:ss.SSS");
return timeF.parse(date);
}
return new Date(0);
}
/**
* 轉化為整型
* @param dateTime
* @return 整型的日期值
* @throws ParseException
*/
public static int toInteger(String dateTime)throws ParseException {
Calendar cal = Calendar.getInstance();
cal.setTime(parse(dateTime));
return cal.get(Calendar.YEAR) * 10000
+ (cal.get(Calendar.MONTH)+1) * 100 
+ cal.get(Calendar.DAY_OF_MONTH);
}

public static String mulFreq(String freq, int muls){
int num = Integer.parseInt(freq.substring(0, freq.length() - 1));
return Integer.toString(num) + freq.substring(freq.length() - 1, 1);
}

public static int toInteger(Date dateTime) {
Calendar cal = Calendar.getInstance();
cal.setTime(dateTime);
return cal.get(Calendar.YEAR) * 10000
+ (cal.get(Calendar.MONTH)+1) * 100 
+ cal.get(Calendar.DAY_OF_MONTH);
}
/**
* 返回某一頻率下的兩個日期間的次數
* @param start
* @param end
* @param freq
* @return int 次數
* @throws ParseException
*/
public static int indexOf(String start, String end, String freq) throws ParseException{
Date date1 = GenernalDate.parse(start);
Date date2 = GenernalDate.parse(end);
for(int i = 0;;i++) {
if( date1.getTime() >= date2.getTime() ) {
return i;
}
date1 = GenernalDate.add(date1, freq);
}
}
/**
* 返回兩個日期相差年數
* @param start
* @param end
* @return 相差年數
* @throws ParseException
*/
public static int yearsOf(String start, String end)throws ParseException{
Calendar cal1 = Calendar.getInstance();
cal1.setTime(parse(start));
Calendar cal2 = Calendar.getInstance();
cal2.setTime(parse(end));
return cal2.get(Calendar.YEAR) - cal1.get(Calendar.YEAR) + 1;
}


/**
* 從日期時間字串拆出日期
* @param dateTime
* @return 日期
* @throws ParseException
*/
public static String splitDate(String dateTime) throws ParseException {
return formatDate(parse(dateTime));
}


/**
* 從日期時間字串拆出時間
* @param dateTime
* @return 時間
* @throws ParseException
*/
public static String splitTime(String dateTime) throws ParseException {
return formatTime(parse(dateTime));
}


/**
* 返回日期
* @param date
* @return Date
* @throws ParseException
*/
public static Date parseDate(String date) throws ParseException {
SimpleDateFormat dateF = new SimpleDateFormat("yyyy-MM-dd");
return dateF.parse(date);
}

public static Calendar parseCalendar(String date){
Calendar cal = Calendar.getInstance();
SimpleDateFormat dateF = new SimpleDateFormat("yyyy-MM-dd");
try{
cal.setTime(dateF.parse(date));
}catch(ParseException e){
throw new RuntimeException(e);
}
return cal;
}

/**
* 返回時間
* @param time
* @return Date 時間
* @throws ParseException
*/
public static Date parseTime(String time) throws ParseException {
SimpleDateFormat timeF = new SimpleDateFormat("HH:mm:ss");
return timeF.parse(time);
}


/**
* 兩個日期相減，引數為String型
* @param startDate
* @param endDate
* @return int
*/
public static int offset(String startDate, String endDate) throws ParseException {
return offset(parse(startDate), parse(endDate));
}


/**
* 兩個日期相減，引數為Date型
* @param startDate
* @param endDate
* @return int 日期差
*/
public static int offset(Date startDate, Date endDate) {
return (int) ((endDate.getTime() - startDate.getTime()) / MINUTES_OF_DAY);
}

/**
* 兩個日期相減，引數為Date型
* @param startDate
* @param endDate
* @return int 日期差
*/
public static int offsetDay(Date startDate, Date endDate)throws ParseException {
  return offset(parse(formatDate(startDate)),parse(formatDate(endDate)));
}


/**
* 日期加天數
* @return 日期加天數後的Date日期
*/
public static Date addDays(Date date, int days) {
return new Date(date.getTime() + days * MINUTES_OF_DAY);
}


/**
* 日期加天數
* @param date
* @param days
* @return 日期加天數後的String日期
*/
public static String addDays(String date, int days) throws ParseException {
return formatDate(addDays(parse(date), days));
}


/**
* +月
* @param date 起始日期
* @param months 月數
* @return 日期加月數後的Date日期
* @throws ParseException
*/
public static Date addMonths(Date date, int months) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH, months);
return cal.getTime();
}


/**
* +月
* @param date 起始日期
* @param months 月數
* @return 日期加月數後的String日期
* @throws ParseException
*/
public static String addMonths(String date, int months) throws ParseException {
return formatDate(addMonths(parseDate(date), months));
}


/**
* +年
* @param date 起始日期
* @param years 年數
* @return 日期加年數後的Date日期
* @throws ParseException
*/
public static Date addYears(Date date, int years) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.YEAR, years);
return cal.getTime();


}


/**
* +年
* @param date 起始日期
* @param years 年數
* @return 日期加年數後的String日期
* @throws ParseException
*/
public static String addYears(String date, int years) throws ParseException {
return formatDate(addYears(parseDate(date), years));


}


/**
* +秒
* @param date 起始日期
* @param second 秒
* @return 日期加秒數後的Date日期
* @throws ParseException
*/
public static Date addSecond(Date date, int second) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.SECOND, second);
return cal.getTime();


}


public static Date addHour(Date date, int hours) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR, hours);
return cal.getTime();
}



public static Date addMinutes(Date date, int minutes) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MINUTE, minutes);
return cal.getTime();
}
/**
* + 表示式 d,w,m,y
* @param date 起始日期
* @param exp 表示式型別:d/D 天; w/W 周; m/M 月; y/Y 年
* @param mul 乘數，一般是第mul期，如exp:7d,mul:2，則為加7*2d 
* @param monthEnd 月末是否對齊
* @return 計算後的Date日期
* @throws ParseException 
* @throws NumberFormatException 
*/
public static Date add(Date date,String exp, int mul, boolean monthEnd){
if( exp.length() <= 1 ) {
throw new RuntimeException("payFreq is null!");
}

int len = exp.length();
int num = Integer.parseInt(exp.substring(0, len - 1)) * mul;
Date ndate = null;
switch (exp.charAt(len - 1)) {
case 'd':
case 'D':
return addDays(date, num);
case 'w':
case 'W':
return addDays(date, num * 7);
case 'm':
case 'M':
ndate =  addMonths(date, num);
break;
case 'y':
case 'Y':
ndate =   addYears(date, num);
break;
}
if( monthEnd && ndate != null  ) {//&& isMonthEnd(date)
return getMonthEnd(ndate);
} else {
return ndate;
}
}

/**
* 
* @param date
* @param j
* @return Date
*/
public static Date rollMonth(Date date ,int j){
Date tmp = addMonths(date, j - 1);
return getMonthEnd(tmp);
}
/**
* 是否月末
* @param date
* @return boolean 是否月末
*/
public static boolean isMonthEnd(Date date) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
if( cal.get(GregorianCalendar.DAY_OF_MONTH) == 
cal.getActualMaximum(GregorianCalendar.DAY_OF_MONTH)){
return true;
}
return false;
}
/**
* 返回日期的月末時間
* @param date
* @return Date 
*/
public static Date getMonthEnd(Date date) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(GregorianCalendar.DAY_OF_MONTH));
return cal.getTime();
}

/**
* 返回日期的月初時間
* @param date
* @return Date 
*/
public static Date getMonthStart(Date date) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(GregorianCalendar.DAY_OF_MONTH));
return cal.getTime();
}
/**
* 比較表示式的大小
* @param exp1
* @param exp2
* @return 表示式(折算成天）相減後的值
*/
public static int compare(String exp1, String exp2){
return getDays(exp1) - getDays(exp2);
}

private static int getDays(String exp) {
int len = exp.length();
int num = Integer.parseInt(exp.substring(0, len - 1));
int days = 0;
char c = exp.charAt(len - 1);
if( c == 'd' || c == 'D'){
days = num;
} else if( c == 'w' || c == 'W'){
days = num * 7;
}else if( c == 'm' || c == 'M'){
days = num * 30;
}else if( c == 'y' || c == 'Y'){
days = num * 365;
}
return days;
}
public static Date add(Date date, String exp) {
return add(date,exp,1, false);
}



/**
* +表示式，d,w,m,y
* @param date
* @param exp
* @return String型別的日期
* @throws ParseException
*/
public static String add(String date, String exp) throws ParseException {
return formatDate(add(parseDate(date), exp));
}


/** 
* 日期+時間
* @param date
* @param time
* @return 包含日期、時間的Date日期
*/
public static Date add(Date date, Date time) {
Calendar cal0 = Calendar.getInstance();
Calendar cal1 = Calendar.getInstance();
cal0.setTime(date);
cal1.setTime(time);
cal0.set(Calendar.HOUR_OF_DAY, cal1.get(Calendar.HOUR_OF_DAY));
cal0.set(Calendar.MINUTE, cal1.get(Calendar.MINUTE));
cal0.set(Calendar.SECOND, cal1.get(Calendar.SECOND));
return cal0.getTime();
}


/**
* String日期+時間
* @param date 日期
* @param time 時間
* @return Date型別的日期
* @throws ParseException
*/
public static Date addTime(String date, String time) throws ParseException {
return add(parseDate(date), parseTime(time));
}


/**
* 返回當前日期時間
* @return 當前日期時間的Date型別
*/
public static Date getDateTime() {
return Calendar.getInstance().getTime();
}


/**
* 返回String型當前時間
* @return 當前日期時間的String型別
*/
public static String getDateTimeStr() {
return format(getDateTime());
}


/**
* 返回String型當前日期的長型別：日期、時間
* @return 返回String型當前日期的長型別：日期、時間
* @throws ParseException
*/
public static String getLongDateTimeStr() {
return formatDateTime(getDateTime());
}


/**
* 返回給定日期的日期時間
* @param date
* @return 給定日期的日期、當前時間Date型別的值
*/
public static Date getDateTime(String date) throws ParseException {
return add(parse(date), getTime());
}


/**
* 返回String型給定日期的日期時間
* @param date
* @return String型別的日期值
* @throws ParseException
*/
public static String getDateTimeStr(String date) throws ParseException {
return format(getDateTime(date));
}
/**
* 返回String型給定日期的日期時間用於DB2的日期
* @param date
* @return String型別的日期值1970 00：00：00
* @throws ParseException
*/
public static String getDateTimeForTimeStamp(String date) throws ParseException {
return format(getDateTime(date))+" 00:00:00";
}
/**
* 返回String型給定日期的日期時間用於DB2的日期
* @param date
* @return String型別的日期值1970 00：00：00
* @throws ParseException
*/
public static String getDateForTimeStamp(String date) throws ParseException {
return format(parse(date))+" 00:00:00";
}




/**
* 返回當前日期
* @return 當前日期Date型別
*/
public static Date getDate() {
Calendar cal = Calendar.getInstance();
cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DATE));
return new Date(cal.getTimeInMillis());
}


/**
* 返回String當前日期
* @return 當前日期String型別
*/
public static String getDateStr() {
return formatDate(getDate());
}


/**
* 返回當前時間
* @return 當前時間Date型別
*/
public static Date getTime() {
Calendar cal = Calendar.getInstance();
cal.set(1970, 0, 1, cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE), cal
.get(Calendar.SECOND));
return new Date(cal.getTimeInMillis());
}


/**
* 返回String當前時間
* @return 當前時間String型別
*/
public static String getTimeStr() {
return formatTime(getTime());
}


/**
* 返回預設格式的字串日期
* @param date
* @return yyyy-MM-dd格式的字串日期
*/
public static String formatDate(Date date) {
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd");
return sf.format(date);
}


/**
* 返回預設格式的字串時間
* @param time
* @return HH:mm:ss格式的字串時間
*/
public static String formatTime(Date time) {
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getTimeInstance();
sf.applyPattern("HH:mm:ss");
return sf.format(time);
}


/**
* 返回預設格式的字串日期 時間
* @param date
* @return yyyy-MM-dd HH:mm:ss格式的字串日期 時間
*/
public static String formatDateTime(Date date){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd HH:mm:ss");
return sf.format(date);
}
/**
* 返回字串日期
* @param date
* @return yyyy-MM-dd格式的字串日期
*/
public static String format(Date date) {
SimpleDateFormat dateF = new SimpleDateFormat("yyyy-MM-dd");
return dateF.format(date);
}
/**
* 返回預設格式的字串日期 時間
* @param date
* @return yyyy-MM-dd HH:mm:ss SSS格式的字串日期 時間
*/
public static String formatDateTimeMillisByDate(Date date){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd HH:mm:ss.SSS");
return sf.format(date);
}
/**
* 返回預設格式的字串日期 時間
* @return yyyy-MM-dd HH:mm:ss SSS格式的字串日期 時間
*/
public static String formatDateTimeMillis(){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd HH:mm:ss SSS");
return sf.format(getDateTime());
}
/**
* 返回預設格式的字串日期 時間
* @return yyyyMMddHHmmssSSS格式的字串日期 時間
*/
public static String formatDateTimeMillisString(){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyyMMddHHmmssSSS");
return sf.format(getDateTime());
}
/**
* 返回預設格式的字串日期 時間
*
* @return yyyy-MM-dd HH:mm:ss 格式的字串日期 時間
*/
public static String formatDateTime(){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd HH:mm:ss");
return sf.format(getDateTime());
}
/**
* 返回預設格式的字串日期
* 
* @return yyyyMMdd格式的字串日期
*/
public static String formatDate(){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyyMMdd");
return sf.format(getDateTime());
}
/**
* 返回預設格式的字串時間
* 
* @return HHmmss格式的字串時間
*/
public static String formatTime(){
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("HHmmss");
return sf.format(getDateTime());
}

/**
* 返回年
* @param date
* @return 年
* @throws ParseException
*/
public static int getYear(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.YEAR);
}


/**
* 返回年
* @param date
* @return 年
* @throws ParseException
*/
public static int getYear(String date) throws ParseException {
return getYear(parseDate(date));
}


/**
* 判斷是否為閏年
* @param year
* @return boolean
*/
public static boolean isLeapYear(int year) {
GregorianCalendar cal = new GregorianCalendar();
return cal.isLeapYear(year);
}


/**
* 返回月
* @param date
* @return 月
* @throws ParseException
*/
public static int getMonth(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.MONTH);
}


/**
* 返回月
* @param date
* @return 月
* @throws ParseException
*/
public static int getMonth(String date) throws ParseException {
return getMonth(parseDate(date));
}


/**
* 返回日
* @param date
* @return 日
* @throws ParseException
*/
public static int getDay(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.DATE);
}


/**
* 返回日
* @param date
* @return 日
* @throws ParseException
*/
public static int getDay(String date) throws ParseException {
return getDay(parseDate(date));
}


/**
* 比較兩個時間大小
* @param date1
* @param date2
* @return true date1>=date2; false date1 < date2
* @throws ParseException
*/
public static boolean greatEqual(String date1, String date2) throws ParseException {
return parseDate(date1).getTime() >= parseDate(date2).getTime();
}
/**
* 比較兩個時間是否相等
* @param date1
* @param date2
* @return true date1>=date2; false date1 < date2
* @throws ParseException
*/
public static boolean equal(String date1, String date2) throws ParseException {
return parseDate(date1).getTime() == parseDate(date2).getTime();
}
public static boolean great(String date1, String date2) throws ParseException {
return parseDate(date1).getTime() > parseDate(date2).getTime();
}


/**
* 比較兩個時間大小(無日期）
* @param date1
* @param date2
* @return true date1>=date2; false date1 < date2
* @throws ParseException
*/
public static boolean greatTime(String date1, String date2) throws ParseException {
return parseTime(date1).getTime() >= parseTime(date2).getTime();
}
/**
* 比較兩個時間大小
* @param date1
* @param date2
* @return true date1<date2; false date1 >= date2
* @throws ParseException
*/
public static boolean less(String date1, String date2) throws ParseException {
return parseDate(date1).getTime() < parseDate(date2).getTime();
}

public static boolean isZero(String date) throws ParseException{
if(date==null || date.trim().equals(""))return true;
return parseDate(date).getTime() <= parseDate("1901-1-1").getTime();

}

public static int getDayOfWeek(Date date){
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.DAY_OF_WEEK);
}

private static String type;
public static void setType(String type) {
GenernalDate.type = type;
}
public static Date parseDateNorm(String date) throws ParseException {
//long offsec=(Long.valueOf(date)-25569)*3600*24*1000;
//SimpleDateFormat dateF = (SimpleDateFormat)SimpleDateFormat.getDateInstance();
//dateF.format(Long.valueOf(date));
//SimpleDateFormat dateff= new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat dateff= new SimpleDateFormat("yyyy-MM-dd");
return dateff.parse(date);
//return d;
}

public static Date formatDateTimeToDate(Date date) throws ParseException {
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
sf.applyPattern("yyyy-MM-dd HH:mm:ss");
String temp=sf.format(date+" 0:00:00");
return sf.parse(temp);
}
/**
* 判斷時間date1是否在時間date2之前,不能用於日期
*/
public static boolean isDateBefore(String date1, String date2) {
if(date2.equals("")){
return false;
}else if(date1.equals("")){
return true;
}
try {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df.parse(date1).before(df.parse(date2));
} catch (ParseException e) {
return false;
}
}
 
/**
* 日期轉換
* @param date 三種格式  20100421153055|20100421|153055
* @return
* @throws ParseException
* @throws ApplicationException
*/
public static Date parse(long date)throws ApplicationException{
String dateStr = String.valueOf(date);

boolean isDate = false,isTime = false,isDateTime = false;
if(dateStr.length()==DATETIME_LENGTH){
isDateTime = true;
}else if(dateStr.length()==DATE_LENGTH){
isDate = true;
}else if(dateStr.length()==TIME_LENGTH){
isTime = true;
}else {
throw new ApplicationException("Date format is not correct["+dateStr+"]");
}
SimpleDateFormat sf = (SimpleDateFormat) DateFormat.getDateInstance();
try{
if (isDateTime) { //日期時間
sf.applyPattern("yyyyMMddHHmmss");
return sf.parse(dateStr);
} else if (isDate) {
sf.applyPattern("yyyyMMdd");
return sf.parse(dateStr);
} else if (isTime) {
sf.applyPattern("HHmmss");
return sf.parse(dateStr);
}
}catch(ParseException pe){
throw new ApplicationException(pe.getMessage());
}

return new Date(0);
}
/**
* Date型別(日期) 轉換為 int 型別
* @param dateTime
* @return long 20100421132630
*/
public static int getIntegerDate(Date dateTime){
SimpleDateFormat sf = (SimpleDateFormat)DateFormat.getInstance();
sf.applyPattern("yyyyMMdd");
return Integer.parseInt(sf.format(dateTime));
}

/**
* 返回日期
* @param date
* @return Date yyyyMMdd
* @throws ParseException
*/
public static Date parseDate(Date date) throws ParseException {
SimpleDateFormat dateF = new SimpleDateFormat("yyyyMMdd");
return dateF.parse(String.valueOf(date));
}

/**
* 讀取當前的日期+時間
* return long 20100421132630
*/
public static long getNumericDateTime(){
SimpleDateFormat sf = (SimpleDateFormat)DateFormat.getInstance();
sf.applyPattern("yyyyMMddHHmmss");
String dateTime = sf.format(Calendar.getInstance().getTime());
return Long.parseLong(dateTime);
}
}