日期格式定制

public class DateUtil {
private static final int[] dayArray = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
private static SimpleDateFormat sdf = new SimpleDateFormat();


// 系统默认日期格式 
    public   static   final  String DATE_FORMAT_String =   "yyyy-MM-dd" ;
  
   // 系统默认日起时间格式 
    public   static   final  String DATE_TIME_FORMAT_String  = "yyyy-MM-dd HH:mm:ss" ;
  
   // 8位日期格式 
    public   static   final  String DATE_FORMAT_8  =   "yyyyMMdd" ;
  
   // 14为日期时间格式 
    public   static   final  String DATE_TIME_FORMAT_14  =   "yyyyMMddHHmmss" ;
  
   public   final   static  String YEAR  =   " year " ;


   public   final   static  String MONTH  =   " month " ;


   public   final   static  String DAY  =   " day " ;
  
   public   final   static  String WEEK  =   " week " ;


   public   final   static  String HOUR  =   " hour " ;


   public   final   static  String MINUTE  =   " minute " ;


   public   final   static  String SECOND  =   " second " ;




  


   /** */ /** 
   * 判断参数是否等于null或者空
   *  @param  para
   *  @return 
    */ 
    private   static   boolean  checkPara(Object para)  {
       if ( null   ==  para  ||   "" .equals(para))  {
           return   true ;
      } else  {
           return   false ;
      } 
  } 
  
   /** */ /** 
   * 获得系统的当前时间，毫秒.
   *  @return 
    */ 
    public   static   long  getCurrentTimeMillis()  {
       return  System.currentTimeMillis();
  } 
  
   /** */ /** 
   * 获得系统的当前时间    
   *  @return 
   *         e.g.Thu Oct 12 10:25:14 CST 2006
    */ 
    public   static  Date getCurrentDate()  {
       // return new Date(System.currentTimeMillis()); 
        return   new  Date(getCurrentTimeMillis()); 
  } 
  
   /** */ /** 
   * 获得系统当前日期，以默认格式显示
   *  @return 
   *         e.g.2006-10-12
    */ 
    public   static  String getCurrentFormatDate()  {
      Date currentDate  =  getCurrentDate();
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_FORMAT_String);
      
       return  dateFormator.format(currentDate);
  } 


   /*
    * 把8位日期转换为10位日期
    * 如 20080809 => 2008-08-09
    */
   public static String date8to10(String str)
   {

return formatDate(parseStrToCustomPatternDate(str,DATE_FORMAT_8),DATE_FORMAT_String);
   }
  
   /** */ /** 
   * 获得系统当前日期时间，以默认格式显示
   *  @return 
   *         e.g.2006-10-12 10:55:06
    */ 
    public   static  String getCurrentFormatDateTime()  {
      Date currentDate  =  getCurrentDate();
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_TIME_FORMAT_String);
      
       return  dateFormator.format(currentDate);
  } 
  
   /** */ /** 
   * 获得系统当前日期时间，按照指定格式返回
   *  @param  pattern
   *         e.g.DATE_FORMAT_8 = "yyyyMMdd";
   *             DATE_TIME_FORMAT_14 = "yyyyMMddHHmmss";
   *             或者介于二者之间的格式,e.g."yyyyMMddHH"
   *  @return 
   *         e.g.200610121115
    */ 
    public   static  String getCurrentCustomFormatDateTime(String pattern)  {
       if (checkPara(pattern))  {
           return   "" ;
      } 
      Date currentDate  =  getCurrentDate();
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(pattern);
      
       return  dateFormator.format(currentDate);
  } 
  
   /** */ /** 
   * 输入日期，按照指定格式返回
   *  @param  date
   *  @param  pattern
   *         e.g.DATE_FORMAT_8 = "yyyyMMdd";
   *             DATE_TIME_FORMAT_14 = "yyyyMMddHHmmss";
   *             或者类似于二者的格式,e.g."yyyyMMddHH"，"yyyyMM"
   *  @return 
    */ 
    public   static  String formatDate(Date date, String pattern)  {
       if (checkPara(pattern)  ||  checkPara(date))  {
           return   "" ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(pattern);
      
       return  dateFormator.format(date);
  } 
  
   /** */ /** 
   * 输入日期，按照指定格式返回
   *  @param  date
   *  @param  pattern
   *         e.g.DATE_FORMAT_8 = "yyyyMMdd";
   *             DATE_TIME_FORMAT_14 = "yyyyMMddHHmmss";
   *             或者类似于二者的格式,e.g."yyyyMMddHH"，"yyyyMM"
   *  @param  loc    国家地区，
   *         e.g.new Locale("zh","CN","") 中国
   *             Locale.getDefault();
   *  @return 
    */ 
    public   static  String formatDate(Date date, String pattern, Locale locale)  {
       if (checkPara(pattern)  ||  checkPara(date))  {
           return   "" ;
      } 
        if (checkPara(locale))  {
          locale  =  Locale.getDefault();
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(pattern, locale);
      String customFormatDate  =  dateFormator.format(date);
      
       return  customFormatDate;
  } 
  
   /** */ /** 
   * 将时间字符串按照默认格式DATE_FORMAT = "yyyy-MM-dd"，转换为Date
   *  @param  dateStr
   *  @return 
    */ 
    public   static  Date parseStrToDate(String dateStr)  {
       if (checkPara(dateStr))  {
           return   null ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_FORMAT_String);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
       return  resDate;
  } 
  
   /** */ /** 
   * 将时间字符串按照默认格式DATE_TIME_FORMAT ="yyyy-MM-dd HH:mm:ss",转换为Date
   *  @param  dateStr
   *  @return 
    */ 
    public   static  Date parseStrToDateTime(String dateStr)  {
       if (checkPara(dateStr))  {
           return   null ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_TIME_FORMAT_String);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
       return  resDate;
  } 
  
   /** */ /** 
   * 将时间字符串按照默认格式DATE_FORMAT = "yyyy-MM-dd"，转换为Calender
   *  @param  dateStr
   *  @return 
    */ 
    public   static  Calendar parseStrToCalendar(String dateStr)  {
       if (checkPara(dateStr))  {
           return   null ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_FORMAT_String);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
      Locale locale  =  Locale.getDefault();
      Calendar cal  =   new  GregorianCalendar(locale);
      cal.setTime(resDate);
      
       return  cal;
  } 
  
   /** */ /** 
   * 将日期字符串转换成日期时间字符串
   *  @param  dateStr
   *  @return 
    */ 
    public   static  String parseDateStrToDateTimeStr(String dateStr)  {
       if (checkPara(dateStr))  {
           return   "" ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              DateUtil.DATE_FORMAT_String);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
       return  formatDate(resDate,DateUtil.DATE_TIME_FORMAT_String);
  } 
  
   /** */ /** 
   * 将时间或者时间日期字符串按照指定格式转换为Date
   *  @param  dateStr
   *  @param  pattern
   *  @return 
    */ 
    public   static  Date parseStrToCustomPatternDate(String dateStr, String pattern)  {
       if (checkPara(pattern)  ||  checkPara(dateStr))  {
           return   null ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              pattern);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
       return  resDate;
  } 
  
   /** */ /** 
   * 将时间字符串从一种格式转换成另一种格式.
   *  @param  dateStr
   *         e.g. String dateStr = "2006-10-12 16:23:06";
   *  @param  patternFrom
   *         e.g. DatePattern.DATE_TIME_FORMAT
   *  @param  patternTo
   *         e.g. DatePattern.DATE_TIME_FORMAT_14
   *  @return 
    */ 
   public   static  String convertDatePattern(String dateStr,
          String patternFrom, String patternTo)  {
       if (checkPara(patternFrom)  ||  checkPara(patternTo)  ||  checkPara(dateStr))  {
           return   "" ;
      } 
      SimpleDateFormat dateFormator  =   new  SimpleDateFormat(
              patternFrom);
      Date resDate  =  dateFormator.parse(dateStr, new  ParsePosition( 0 ));
      
       return  formatDate(resDate,patternTo);
  } 
  
   /** */ /** 
   * 日期天数增加
   *  @param  date
   *  @param  days
   *  @return 
    */ 
    public   static  Date addDays(Date date,  int  days)  {
       if (checkPara(date))  {
           return   null ;
      } 
        if ( 0   ==  days)  {
           return  date;
      } 
      Locale loc  =  Locale.getDefault();
      Calendar cal  =   new  GregorianCalendar(loc);
      cal.setTime(date);
      cal.add(Calendar.DAY_OF_MONTH,days);
      
       return  cal.getTime();
  } 
  
   /** */ /** 
   * 日期天数减少
   *  @param  date
   *  @param  days
   *  @return 
    */ 
    public   static  Date minusDays(Date date,  int  days)  {
       return  addDays(date,( 0 - days));
  } 
  
   /** */ /** 
   * 按时间格式相加
   *  @param  dateStr    原来的时间
   *  @param  pattern    时间格式
   *  @param  type        
   *                     "year"年、"month"月、"day"日、"week"周、
   *                     "hour"时、"minute"分、"second"秒
   *                     通过常量来设置,e.g.DateUtil.YEAR
   *  @param  count        相加数量
   *  @return 
    */ 
   public   static  String addDate(String dateStr, String pattern,
          String type,  int  count)  {
       if (checkPara(dateStr)  ||  checkPara(pattern)  ||  checkPara(type))  {
           return   "" ;
      } 
        if ( 0   ==  count)  {
           return  dateStr;
      } 
      Date date  =  parseStrToCustomPatternDate(dateStr,pattern);
      Locale loc  =  Locale.getDefault();
      Calendar cal  =   new  GregorianCalendar(loc);
      cal.setTime(date);
      
       if (DateUtil.YEAR.equals(type))  {
          cal.add(Calendar.YEAR,count);
      } else   if (DateUtil.MONTH.equals(type))  {
          cal.add(Calendar.MONTH,count);
      } else   if (DateUtil.DAY.equals(type))  {
          cal.add(Calendar.DAY_OF_MONTH,count);
      } else   if (DateUtil.WEEK.equals(type))  {
          cal.add(Calendar.WEEK_OF_MONTH,count);
      } else   if (DateUtil.HOUR.equals(type))  {
          cal.add(Calendar.HOUR,count);
      } else   if (DateUtil.MINUTE.equals(type))  {
          cal.add(Calendar.MINUTE,count);
      } else   if (DateUtil.SECOND.equals(type))  {
          cal.add(Calendar.SECOND,count);
      } else  {
           return   "" ;
      } 
      
       return  formatDate(cal.getTime(),pattern);
  } 
  
   /** */ /** 
   * 那时间格式相减
   *  @param  dateStr
   *  @param  pattern
   *  @param  type
   *  @param  count
   *  @return 
    */ 
   public   static  String minusDate(String dateStr, String pattern,
          String type,  int  count)  {
       return  addDate(dateStr,pattern,type,( 0 - count));
  } 
  
   /** */ /** 
   * 日期大小比较
   *  @param  dateStr1
   *  @param  dateStr2
   *  @param  pattern
   *  @return 
    */ 
    public   static   int  compareDate(String dateStr1, String dateStr2, String pattern)  {
       if (checkPara(dateStr1)  ||  checkPara(dateStr2)  ||  checkPara(pattern))  {
           return   888 ;
      } 
      Date date1  =  DateUtil.parseStrToCustomPatternDate(dateStr1,pattern);
      Date date2  =  DateUtil.parseStrToCustomPatternDate(dateStr2,pattern);
      
       return  date1.compareTo(date2);
  } 
  
   /** */ /** 
   * 获得这个月的第一天
   *  @param  dateStr
   *  @return 
    */ 
    public   static  String getFirstDayInMonth(String dateStr)  {
       if (checkPara(dateStr))  {
           return   "" ;
      } 
      Calendar cal  =  DateUtil.parseStrToCalendar(dateStr);
       int  firstDay  =  cal.getActualMinimum(Calendar.DAY_OF_MONTH);
      cal.set(Calendar.DAY_OF_MONTH,firstDay);
      
       return  DateUtil.formatDate(cal.getTime(),DateUtil.DATE_FORMAT_String);
  } 
  
   /** */ /** 
   * 获得这个月的最后一天
   *  @param  dateStr
   *  @return 
    */ 
    public   static  String getLastDayInMonth(String dateStr)  {
       if (checkPara(dateStr))  {
           return   "" ;
      } 
      Calendar cal  =  DateUtil.parseStrToCalendar(dateStr);
       int  lastDay  =  cal.getActualMaximum(Calendar.DAY_OF_MONTH);
      cal.set(Calendar.DAY_OF_MONTH,lastDay);
      
       return  DateUtil.formatDate(cal.getTime(),DateUtil.DATE_FORMAT_String);
  } 
  
   /** */ /** 
   * 获得这周的第一天
   *  @param  dateStr
   *  @return 
    */ 
    public   static  String getFirstDayInWeek(String dateStr)  {
       if (checkPara(dateStr))  {
           return   "" ;
      } 
      Calendar cal  =  DateUtil.parseStrToCalendar(dateStr);
       int  firstDay  =  cal.getActualMinimum(Calendar.DAY_OF_WEEK);
      cal.set(Calendar.DAY_OF_WEEK,firstDay);
      
       return  DateUtil.formatDate(cal.getTime(),DateUtil.DATE_FORMAT_String);
  } 
  
   /** */ /** 
   * 获得这周的最后一天
   *  @param  dateStr
   *  @return 
    */ 
    public   static  String getLastDayInWeek(String dateStr)  {
       if (checkPara(dateStr))  {
           return   "" ;
      } 
      Calendar cal  =  DateUtil.parseStrToCalendar(dateStr);
       int  lastDay  =  cal.getActualMaximum(Calendar.DAY_OF_WEEK);
      cal.set(Calendar.DAY_OF_WEEK,lastDay);
      
       return  DateUtil.formatDate(cal.getTime(),DateUtil.DATE_FORMAT_String);
  } 


public static synchronized Calendar getCalendar() {
return GregorianCalendar.getInstance();
}


/**
@return String
*/
public static synchronized String getDateMilliFormat() {
Calendar cal = Calendar.getInstance();
return getDateMilliFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateMilliFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd HH:mm:ss,SSS";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateMilliFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd HH:mm:ss,SSS";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarMilliFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss,SSS";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateMilliFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss,SSS";
return parseDateFormat(strDate, pattern);
}


/**
@return String
*/
public static synchronized String getDateSecondFormat() {
Calendar cal = Calendar.getInstance();
return getDateSecondFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateSecondFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateSecondFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarSecondFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateSecondFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseDateFormat(strDate, pattern);
}


/**
@return String
*/
public static synchronized String getDateMinuteFormat() {
Calendar cal = Calendar.getInstance();
return getDateMinuteFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateMinuteFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd HH:mm";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateMinuteFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd HH:mm";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarMinuteFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateMinuteFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm";
return parseDateFormat(strDate, pattern);
}


/**
@return String
*/
public static synchronized String getDateDayFormat() {
Calendar cal = Calendar.getInstance();
return getDateDayFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateDayFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateDayFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarDayFormat(String strDate) {
String pattern = "yyyy-MM-dd";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateDayFormat(String strDate) {
String pattern = "yyyy-MM-dd";
return parseDateFormat(strDate, pattern);
}


/**
@return String
*/
public static synchronized String getDateFileFormat() {
Calendar cal = Calendar.getInstance();
return getDateFileFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateFileFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd_HH-mm-ss";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateFileFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd_HH-mm-ss";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarFileFormat(String strDate) {
String pattern = "yyyy-MM-dd_HH-mm-ss";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateFileFormat(String strDate) {
String pattern = "yyyy-MM-dd_HH-mm-ss";
return parseDateFormat(strDate, pattern);
}


/**
@return String
*/
public static synchronized String getDateW3CFormat() {
Calendar cal = Calendar.getInstance();
return getDateW3CFormat(cal);
}


/**
@param cal
@return String
*/
public static synchronized String getDateW3CFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateW3CFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarW3CFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateW3CFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseDateFormat(strDate, pattern);
}


/**
@param cal
@return String
*/
public static synchronized String getDateFormat(java.util.Calendar cal) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(cal, pattern);
}


/**
@param date
@return String
*/
public static synchronized String getDateFormat(java.util.Date date) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return getDateFormat(date, pattern);
}


/**
@param strDate
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseCalendarFormat(strDate, pattern);
}


/**
@param strDate
@return java.util.Date
*/
public static synchronized Date parseDateFormat(String strDate) {
String pattern = "yyyy-MM-dd HH:mm:ss";
return parseDateFormat(strDate, pattern);
}


/**
@param cal
@param pattern
@return String
*/
public static synchronized String getDateFormat(java.util.Calendar cal, String pattern) {
return getDateFormat(cal.getTime(), pattern);
}


/**
@param date
@param pattern
@return String
*/
public static synchronized String getDateFormat(java.util.Date date, String pattern) {
synchronized (sdf) {
String str = null;
sdf.applyPattern(pattern);
str = sdf.format(date);
return str;
}
}


/**
@param strDate
@param pattern
@return java.util.Calendar
*/
public static synchronized Calendar parseCalendarFormat(String strDate, String pattern) {
synchronized (sdf) {
Calendar cal = null;
sdf.applyPattern(pattern);
try {
sdf.parse(strDate);
cal = sdf.getCalendar();
} catch (Exception e) {
}
return cal;
}
}


/**
@param strDate
@param pattern
@return java.util.Date
*/
public static synchronized Date parseDateFormat(String strDate, String pattern) {
synchronized (sdf) {
Date date = null;
sdf.applyPattern(pattern);
try {
date = sdf.parse(strDate);
} catch (Exception e) {
}
return date;
}
}


public static synchronized int getLastDayOfMonth(int month) {
if (month < 1 || month > 12) {
return -1;
}
int retn = 0;
if (month == 2) {
if (isLeapYear()) {
retn = 29;
} else {
retn = dayArray[month - 1];
}
} else {
retn = dayArray[month - 1];
}
return retn;
}


public static synchronized int getLastDayOfMonth(int year, int month) {
if (month < 1 || month > 12) {
return -1;
}
int retn = 0;
if (month == 2) {
if (isLeapYear(year)) {
retn = 29;
} else {
retn = dayArray[month - 1];
}
} else {
retn = dayArray[month - 1];
}
return retn;
}


public static synchronized boolean isLeapYear() {
Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
return isLeapYear(year);
}


public static synchronized boolean isLeapYear(int year) {
/**
* 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
* 3.能被4整除同时能被100整除则不是闰年
*/
if ((year % 400) == 0)
return true;
else if ((year % 4) == 0) {
if ((year % 100) == 0)
return false;
else
return true;
} else
return false;
}


/**
* 判断指定日期的年份是否是闰年
* 
* @param date
*            指定日期。
* @return 是否闰年
*/
public static synchronized boolean isLeapYear(java.util.Date date) {
/**
* 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
* 3.能被4整除同时能被100整除则不是闰年
*/
// int year = date.getYear();
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
int year = gc.get(Calendar.YEAR);
return isLeapYear(year);
}


public static synchronized boolean isLeapYear(java.util.Calendar gc) {
/**
* 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
* 3.能被4整除同时能被100整除则不是闰年
*/
int year = gc.get(Calendar.YEAR);
return isLeapYear(year);
}


/**
* 得到指定日期的前一个工作日
* 
* @param date
*            指定日期。
* @return 指定日期的前一个工作日
*/
public static synchronized java.util.Date getPreviousWeekDay(java.util.Date date) {
{
/**
* 详细设计： 
* 1.如果date是星期日，则减3天 
* 2.如果date是星期六，则减2天 
* 3.否则减1天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
return getPreviousWeekDay(gc);
// switch ( gc.get( Calendar.DAY_OF_WEEK ) )
// {
//  case ( Calendar.MONDAY    ):
//   gc.add( Calendar.DATE, -3 );
//   break;
//  case ( Calendar.SUNDAY    ):
//   gc.add( Calendar.DATE, -2 );
//   break;
//  default:
//   gc.add( Calendar.DATE, -1 );
//   break;
// }
// return gc.getTime();
}
}


public static synchronized java.util.Date getPreviousWeekDay(java.util.Calendar gc) {
{
/**
* 详细设计： 
* 1.如果date是星期日，则减3天 
* 2.如果date是星期六，则减2天 
* 3.否则减1天
*/
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.MONDAY) :
gc.add(Calendar.DATE, -3);
break;
case (Calendar.SUNDAY) :
gc.add(Calendar.DATE, -2);
break;
default :
gc.add(Calendar.DATE, -1);
break;
}
return gc.getTime();
}
}


public static synchronized String getPreviousDay(String date,int days){
return DateUtil.getDateDayFormat(DateUtil.addDays(DateUtil.parseStrToDate(date),days));
}


/**
* 得到指定日期的后一个工作日
* 
* @param date
*            指定日期。
* @return 指定日期的后一个工作日
*/
public static synchronized java.util.Date getNextWeekDay(java.util.Date date) {
/**
* 详细设计： 
* 1.如果date是星期五，则加3天 
* 2.如果date是星期六，则加2天
* 3.否则加1天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.FRIDAY) :
gc.add(Calendar.DATE, 3);
break;
case (Calendar.SATURDAY) :
gc.add(Calendar.DATE, 2);
break;
default :
gc.add(Calendar.DATE, 1);
break;
}
return gc.getTime();
}


public static synchronized java.util.Calendar getNextWeekDay(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.如果date是星期五，则加3天 
* 2.如果date是星期六，则加2天
* 3.否则加1天
*/
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.FRIDAY) :
gc.add(Calendar.DATE, 3);
break;
case (Calendar.SATURDAY) :
gc.add(Calendar.DATE, 2);
break;
default :
gc.add(Calendar.DATE, 1);
break;
}
return gc;
}


/**
* 取得指定日期的下一个月的最后一天
* 
* @param date
*            指定日期。
* @return 指定日期的下一个月的最后一天
*/
public static synchronized java.util.Date getLastDayOfNextMonth(java.util.Date date) {
/**
* 详细设计： 
* 1.调用getNextMonth设置当前时间 
* 2.以1为基础，调用getLastDayOfMonth
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.setTime(DateUtil.getNextMonth(gc.getTime()));
gc.setTime(DateUtil.getLastDayOfMonth(gc.getTime()));
return gc.getTime();
}


/**
* 取得指定日期的下一个星期的最后一天
* 
* @param date
*            指定日期。
* @return 指定日期的下一个星期的最后一天
*/
public static synchronized java.util.Date getLastDayOfNextWeek(java.util.Date date) {
/**
* 详细设计： 
* 1.调用getNextWeek设置当前时间 
* 2.以1为基础，调用getLastDayOfWeek
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.setTime(DateUtil.getNextWeek(gc.getTime()));
gc.setTime(DateUtil.getLastDayOfWeek(gc.getTime()));
return gc.getTime();
}


/**
* 取得指定日期的下一个月的第一天
* 
* @param date
*            指定日期。
* @return 指定日期的下一个月的第一天
*/
public static synchronized java.util.Date getFirstDayOfNextMonth(java.util.Date date) {
/**
* 详细设计： 
* 1.调用getNextMonth设置当前时间 
* 2.以1为基础，调用getFirstDayOfMonth
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.setTime(DateUtil.getNextMonth(gc.getTime()));
gc.setTime(DateUtil.getFirstDayOfMonth(gc.getTime()));
return gc.getTime();
}


public static synchronized java.util.Calendar getFirstDayOfNextMonth(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.调用getNextMonth设置当前时间 
* 2.以1为基础，调用getFirstDayOfMonth
*/
gc.setTime(DateUtil.getNextMonth(gc.getTime()));
gc.setTime(DateUtil.getFirstDayOfMonth(gc.getTime()));
return gc;
}


/**
* 取得指定日期的下一个星期的第一天
* 
* @param date
*            指定日期。
* @return 指定日期的下一个星期的第一天
*/
public static synchronized java.util.Date getFirstDayOfNextWeek(java.util.Date date) {
/**
* 详细设计： 
* 1.调用getNextWeek设置当前时间 
* 2.以1为基础，调用getFirstDayOfWeek
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.setTime(DateUtil.getNextWeek(gc.getTime()));
gc.setTime(DateUtil.getFirstDayOfWeek(gc.getTime()));
return gc.getTime();
}


public static synchronized java.util.Calendar getFirstDayOfNextWeek(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.调用getNextWeek设置当前时间 
* 2.以1为基础，调用getFirstDayOfWeek
*/
gc.setTime(DateUtil.getNextWeek(gc.getTime()));
gc.setTime(DateUtil.getFirstDayOfWeek(gc.getTime()));
return gc;
}


/**
* 取得指定日期的下一个月
* 
* @param date
*            指定日期。
* @return 指定日期的下一个月
*/
public static synchronized java.util.Date getNextMonth(java.util.Date date) {
/**
* 详细设计： 
* 1.指定日期的月份加1
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.add(Calendar.MONTH, 1);
return gc.getTime();
}


/**
* 取得指定日期的上一个月
* 
* @param date
*            指定日期。
* @return 指定日期的上一个月
*/
public static synchronized String getPreviousMonth(String date) {
/**
* 详细设计： 
* 1.指定日期的月份加1
*/
Date date1 = parseDateDayFormat(date);
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date1);
gc.add(Calendar.MONTH, -1);
return getDateDayFormat(gc.getTime());
}




public static synchronized java.util.Calendar getNextMonth(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.指定日期的月份加1
*/
gc.add(Calendar.MONTH, 1);
return gc;
}


/**
* 取得指定日期的下一天
* 
* @param date
*            指定日期。
* @return 指定日期的下一天
*/
public static synchronized java.util.Date getNextDay(java.util.Date date) {
/**
* 详细设计： 1.指定日期加1天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.add(Calendar.DATE, 1);
return gc.getTime();
}


public static synchronized java.util.Calendar getNextDay(java.util.Calendar gc) {
/**
* 详细设计： 1.指定日期加1天
*/
gc.add(Calendar.DATE, 1);
return gc;
}


/**
* 取得指定日期的下一个星期
* 
* @param date
*            指定日期。
* @return 指定日期的下一个星期
*/
public static synchronized java.util.Date getNextWeek(java.util.Date date) {
/**
* 详细设计： 
* 1.指定日期加7天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.add(Calendar.DATE, 7);
return gc.getTime();
}


public static synchronized java.util.Calendar getNextWeek(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.指定日期加7天
*/
gc.add(Calendar.DATE, 7);
return gc;
}


/**
* 取得指定日期的所处星期的最后一天
* 
* @param date
*            指定日期。
* @return 指定日期的所处星期的最后一天
*/
public static synchronized java.util.Date getLastDayOfWeek(java.util.Date date) {
/**
* 详细设计： 
* 1.如果date是星期日，则加6天 
* 2.如果date是星期一，则加5天 
* 3.如果date是星期二，则加4天
* 4.如果date是星期三，则加3天 
* 5.如果date是星期四，则加2天 
* 6.如果date是星期五，则加1天
* 7.如果date是星期六，则加0天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.SUNDAY) :
gc.add(Calendar.DATE, 6);
break;
case (Calendar.MONDAY) :
gc.add(Calendar.DATE, 5);
break;
case (Calendar.TUESDAY) :
gc.add(Calendar.DATE, 4);
break;
case (Calendar.WEDNESDAY) :
gc.add(Calendar.DATE, 3);
break;
case (Calendar.THURSDAY) :
gc.add(Calendar.DATE, 2);
break;
case (Calendar.FRIDAY) :
gc.add(Calendar.DATE, 1);
break;
case (Calendar.SATURDAY) :
gc.add(Calendar.DATE, 0);
break;
}
return gc.getTime();
}


/**
* 取得指定日期的所处星期的第一天
* 
* @param date
*            指定日期。
* @return 指定日期的所处星期的第一天
*/
public static synchronized java.util.Date getFirstDayOfWeek(java.util.Date date) {
/**
* 详细设计： 
* 1.如果date是星期日，则减0天 
* 2.如果date是星期一，则减1天 
* 3.如果date是星期二，则减2天
* 4.如果date是星期三，则减3天 
* 5.如果date是星期四，则减4天 
* 6.如果date是星期五，则减5天
* 7.如果date是星期六，则减6天
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.SUNDAY) :
gc.add(Calendar.DATE, 0);
break;
case (Calendar.MONDAY) :
gc.add(Calendar.DATE, -1);
break;
case (Calendar.TUESDAY) :
gc.add(Calendar.DATE, -2);
break;
case (Calendar.WEDNESDAY) :
gc.add(Calendar.DATE, -3);
break;
case (Calendar.THURSDAY) :
gc.add(Calendar.DATE, -4);
break;
case (Calendar.FRIDAY) :
gc.add(Calendar.DATE, -5);
break;
case (Calendar.SATURDAY) :
gc.add(Calendar.DATE, -6);
break;
}
return gc.getTime();
}


public static synchronized java.util.Calendar getFirstDayOfWeek(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.如果date是星期日，则减0天 
* 2.如果date是星期一，则减1天 
* 3.如果date是星期二，则减2天
* 4.如果date是星期三，则减3天 
* 5.如果date是星期四，则减4天 
* 6.如果date是星期五，则减5天
* 7.如果date是星期六，则减6天
*/
switch (gc.get(Calendar.DAY_OF_WEEK)) {
case (Calendar.SUNDAY) :
gc.add(Calendar.DATE, 0);
break;
case (Calendar.MONDAY) :
gc.add(Calendar.DATE, -1);
break;
case (Calendar.TUESDAY) :
gc.add(Calendar.DATE, -2);
break;
case (Calendar.WEDNESDAY) :
gc.add(Calendar.DATE, -3);
break;
case (Calendar.THURSDAY) :
gc.add(Calendar.DATE, -4);
break;
case (Calendar.FRIDAY) :
gc.add(Calendar.DATE, -5);
break;
case (Calendar.SATURDAY) :
gc.add(Calendar.DATE, -6);
break;
}
return gc;
}


/**
* 取得指定日期的所处月份的最后一天
* 
* @param date
*            指定日期。
* @return 指定日期的所处月份的最后一天
*/
public static synchronized java.util.Date getLastDayOfMonth(java.util.Date date) {
/**
* 详细设计： 
* 1.如果date在1月，则为31日 
* 2.如果date在2月，则为28日 
* 3.如果date在3月，则为31日
* 4.如果date在4月，则为30日 
* 5.如果date在5月，则为31日 
* 6.如果date在6月，则为30日
* 7.如果date在7月，则为31日 
* 8.如果date在8月，则为31日 
* 9.如果date在9月，则为30日
* 10.如果date在10月，则为31日 
* 11.如果date在11月，则为30日 
* 12.如果date在12月，则为31日
* 1.如果date在闰年的2月，则为29日
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
switch (gc.get(Calendar.MONTH)) {
case 0 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 1 :
gc.set(Calendar.DAY_OF_MONTH, 28);
break;
case 2 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 3 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 4 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 5 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 6 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 7 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 8 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 9 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 10 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 11 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
}
//检查闰年
if ((gc.get(Calendar.MONTH) == Calendar.FEBRUARY) && (isLeapYear(gc.get(Calendar.YEAR)))) {
gc.set(Calendar.DAY_OF_MONTH, 29);
}
return gc.getTime();
}


public static synchronized java.util.Calendar getLastDayOfMonth(java.util.Calendar gc) {
/**
* 详细设计： 
* 1.如果date在1月，则为31日 
* 2.如果date在2月，则为28日 
* 3.如果date在3月，则为31日
* 4.如果date在4月，则为30日 
* 5.如果date在5月，则为31日 
* 6.如果date在6月，则为30日
* 7.如果date在7月，则为31日 
* 8.如果date在8月，则为31日 
* 9.如果date在9月，则为30日
* 10.如果date在10月，则为31日 
* 11.如果date在11月，则为30日 
* 12.如果date在12月，则为31日
* 1.如果date在闰年的2月，则为29日
*/
switch (gc.get(Calendar.MONTH)) {
case 0 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 1 :
gc.set(Calendar.DAY_OF_MONTH, 28);
break;
case 2 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 3 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 4 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 5 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 6 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 7 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 8 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 9 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
case 10 :
gc.set(Calendar.DAY_OF_MONTH, 30);
break;
case 11 :
gc.set(Calendar.DAY_OF_MONTH, 31);
break;
}
//检查闰年
if ((gc.get(Calendar.MONTH) == Calendar.FEBRUARY) && (isLeapYear(gc.get(Calendar.YEAR)))) {
gc.set(Calendar.DAY_OF_MONTH, 29);
}
return gc;
}

/**
* 取得指定日期的所处月份的第一天
* 
* @param date
*            指定日期。
* @return 指定日期的所处月份的第一天
*/
public static synchronized java.util.Date getFirstDayOfMonth(java.util.Date date) {
/**
* 详细设计： 1.设置为1号
*/
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(date);
gc.set(Calendar.DAY_OF_MONTH, 1);
return gc.getTime();
}


public static synchronized java.util.Calendar getFirstDayOfMonth(java.util.Calendar gc) {
/**
* 详细设计： 1.设置为1号
*/
gc.set(Calendar.DAY_OF_MONTH, 1);
return gc;
}


/**
* 将日期对象转换成为指定ORA日期、时间格式的字符串形式。如果日期对象为空，返回 一个空字符串对象，而不是一个空对象。
* 
* @param theDate
*            将要转换为字符串的日期对象。
* @param hasTime
*            如果返回的字符串带时间则为true
* @return 转换的结果
*/
public static synchronized String toOraString(Date theDate, boolean hasTime) {
/**
* 详细设计： 
* 1.如果有时间，则设置格式为getOraDateTimeFormat()的返回值
* 2.否则设置格式为getOraDateFormat()的返回值 
* 3.调用toString(Date theDate, DateFormat
* theDateFormat)
*/
DateFormat theFormat;
if (hasTime) {
theFormat = getOraDateTimeFormat();
} else {
theFormat = getOraDateFormat();
}
return toString(theDate, theFormat);
}


/**
* 将日期对象转换成为指定日期、时间格式的字符串形式。如果日期对象为空，返回 一个空字符串对象，而不是一个空对象。
* 
* @param theDate
*            将要转换为字符串的日期对象。
* @param hasTime
*            如果返回的字符串带时间则为true
* @return 转换的结果
*/
public static synchronized String toString(Date theDate, boolean hasTime) {
/**
* 详细设计： 
* 1.如果有时间，则设置格式为getDateTimeFormat的返回值 
* 2.否则设置格式为getDateFormat的返回值
* 3.调用toString(Date theDate, DateFormat theDateFormat)
*/
DateFormat theFormat;
if (hasTime) {
theFormat = getDateTimeFormat();
} else {
theFormat = getDateFormat();
}
return toString(theDate, theFormat);
}


/**
* 标准日期格式
*/
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MM/dd/yyyy");
/**
* 标准时间格式
*/
private static final SimpleDateFormat DATE_TIME_FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mm");
/**
* 带时分秒的标准时间格式
*/
private static final SimpleDateFormat DATE_TIME_EXTENDED_FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
/**
* ORA标准日期格式
*/
private static final SimpleDateFormat ORA_DATE_FORMAT = new SimpleDateFormat("yyyyMMdd");
/**
* ORA标准时间格式
*/
private static final SimpleDateFormat ORA_DATE_TIME_FORMAT = new SimpleDateFormat("yyyyMMddHHmm");
/**
* 带时分秒的ORA标准时间格式
*/
private static final SimpleDateFormat ORA_DATE_TIME_EXTENDED_FORMAT = new SimpleDateFormat("yyyyMMddHHmmss");


/**
* 创建一个标准日期格式的克隆
* 
* @return 标准日期格式的克隆
*/
public static synchronized DateFormat getDateFormat() {
/**
* 详细设计： 1.返回DATE_FORMAT
*/
SimpleDateFormat theDateFormat = (SimpleDateFormat) DATE_FORMAT.clone();
theDateFormat.setLenient(false);
return theDateFormat;
}


/**
* 创建一个标准时间格式的克隆
* 
* @return 标准时间格式的克隆
*/
public static synchronized DateFormat getDateTimeFormat() {
/**
* 详细设计： 1.返回DATE_TIME_FORMAT
*/
SimpleDateFormat theDateTimeFormat = (SimpleDateFormat) DATE_TIME_FORMAT.clone();
theDateTimeFormat.setLenient(false);
return theDateTimeFormat;
}


/**
* 创建一个标准ORA日期格式的克隆
* 
* @return 标准ORA日期格式的克隆
*/
public static synchronized DateFormat getOraDateFormat() {
/**
* 详细设计： 1.返回ORA_DATE_FORMAT
*/
SimpleDateFormat theDateFormat = (SimpleDateFormat) ORA_DATE_FORMAT.clone();
theDateFormat.setLenient(false);
return theDateFormat;
}


/**
* 创建一个标准ORA时间格式的克隆
* 
* @return 标准ORA时间格式的克隆
*/
public static synchronized DateFormat getOraDateTimeFormat() {
/**
* 详细设计： 1.返回ORA_DATE_TIME_FORMAT
*/
SimpleDateFormat theDateTimeFormat = (SimpleDateFormat) ORA_DATE_TIME_FORMAT.clone();
theDateTimeFormat.setLenient(false);
return theDateTimeFormat;
}


/**
* 将一个日期对象转换成为指定日期、时间格式的字符串。 如果日期对象为空，返回一个空字符串，而不是一个空对象。
* 
* @param theDate
*            要转换的日期对象
* @param theDateFormat
*            返回的日期字符串的格式
* @return 转换结果
*/
public static synchronized String toString(Date theDate, DateFormat theDateFormat) {
/**
* 详细设计： 
* 1.theDate为空，则返回"" 
* 2.否则使用theDateFormat格式化
*/
if (theDate == null)
return "";
return theDateFormat.format(theDate);
}

public static void main(String[] args){
//System.out.println(DateUtil.getCurrentCustomFormatDateTime(DATE_TIME_FORMAT_14));
String fileName = "aqfrase.xls";
String fileNamePre = fileName.substring(0, fileName.lastIndexOf("."));
String fileNameNext = fileName.substring(fileName.lastIndexOf(".")+1, fileName.length());
//System.out.println(fileNamePre);
System.out.println(fileNameNext);
}
}