`

java日期操作 大全

    博客分类：
  • java
 
阅读更多
先来一个：  
取得指定月份的第一天与取得指定月份的最后一天  
http://iamin.blogdriver.com/iamin/847990.html  
/**  
         *  取得指定月份的第一天  
         *  
         *  @param  strdate  String  
         *  @return  String  
         */  
       public  String  getMonthBegin(String  strdate)  
       {  
               java.util.Date  date  =  parseFormatDate(strdate);  
               return  formatDateByFormat(date,"yyyy-MM")  +  "-01";  
       }  
 
       /**  
         *  取得指定月份的最后一天  
         *  
         *  @param  strdate  String  
         *  @return  String  
         */  
       public  String  getMonthEnd(String  strdate)  
       {  
               java.util.Date  date  =  parseFormatDate(getMonthBegin(strdate));  
               Calendar  calendar  =  Calendar.getInstance();  
               calendar.setTime(date);  
               calendar.add(Calendar.MONTH,1);  
               calendar.add(Calendar.DAY_OF_YEAR,  -1);  
               return  formatDate(calendar.getTime());  
       }  
 
       /**  
         *  常用的格式化日期  
         *  
         *  @param  date  Date  
         *  @return  String  
         */  
       public  String  formatDate(java.util.Date  date)  
       {  
               return  formatDateByFormat(date,"yyyy-MM-dd");  
       }  
 
       /**  
         *  以指定的格式来格式化日期  
         *  
         *  @param  date  Date  
         *  @param  format  String  
         *  @return  String  
         */  
       public  String  formatDateByFormat(java.util.Date  date,String  format)  
       {  
               String  result  =  "";  
               if(date  !=  null)  
               {  
                       try  
                       {  
                               SimpleDateFormat  sdf  =  new  SimpleDateFormat(format);  
                               result  =  sdf.format(date);  
                       }  
                       catch(Exception  ex)  
                       {  
                               LOGGER.info("date:"  +  date);  
                               ex.printStackTrace();  
                       }  
               }  
               return  result;  
       }  
//---------------------------------------------------------------  
 
package  com.app.util;  
 
/**  
 *  日期操作  
 *    
 *  @author  xxx  
 *  @version  2.0  jdk1.4.0  tomcat5.1.0  *  Updated  Date:2005/03/10  
 */  
public  class  DateUtil  {  
           /**  
             *  格式化日期  
             *    
             *  @param  dateStr  
             *                        字符型日期  
             *  @param  format  
             *                        格式  
             *  @return  返回日期  
             */  
           public  static  java.util.Date  parseDate(String  dateStr,  String  format)  {  
                       java.util.Date  date  =  null;  
                       try  {  
                                   java.text.DateFormat  df  =  new  java.text.SimpleDateFormat(format);  
                                   String  dt=Normal.parse(dateStr).replaceAll(  
                                                           "-",  "/");  
                                   if((!dt.equals(""))&&(dt.length()<format.length())){  
                                               dt+=format.substring(dt.length()).replaceAll("[YyMmDdHhSs]","0");  
                                   }  
                                   date  =  (java.util.Date)  df.parse(dt);  
                       }  catch  (Exception  e)  {  
                       }  
                       return  date;  
           }  
 
           public  static  java.util.Date  parseDate(String  dateStr)  {  
                       return  parseDate(dateStr,  "yyyy/MM/dd");  
           }  
 
           public  static  java.util.Date  parseDate(java.sql.Date  date)  {  
                       return  date;  
           }  
             
           public  static  java.sql.Date  parseSqlDate(java.util.Date  date)  {  
                       if  (date  !=  null)  
                                   return  new  java.sql.Date(date.getTime());  
                       else  
                                   return  null;  
           }  
 
           public  static  java.sql.Date  parseSqlDate(String  dateStr,  String  format)  {  
                       java.util.Date  date  =  parseDate(dateStr,  format);  
                       return  parseSqlDate(date);  
           }  
 
           public  static  java.sql.Date  parseSqlDate(String  dateStr)  {  
                       return  parseSqlDate(dateStr,  "yyyy/MM/dd");  
           }  
 
             
           public  static  java.sql.Timestamp  parseTimestamp(String  dateStr,  
                                   String  format)  {  
                       java.util.Date  date  =  parseDate(dateStr,  format);  
                       if  (date  !=  null)  {  
                                   long  t  =  date.getTime();  
                                   return  new  java.sql.Timestamp(t);  
                       }  else  
                                   return  null;  
           }  
 
           public  static  java.sql.Timestamp  parseTimestamp(String  dateStr)  {  
                       return  parseTimestamp(dateStr,  "yyyy/MM/dd  HH:mm:ss");  
           }  
 
           /**  
             *  格式化输出日期  
             *    
             *  @param  date  
             *                        日期  
             *  @param  format  
             *                        格式  
             *  @return  返回字符型日期  
             */  
           public  static  String  format(java.util.Date  date,  String  format)  {  
                       String  result  =  "";  
                       try  {  
                                   if  (date  !=  null)  {  
                                               java.text.DateFormat  df  =  new  java.text.SimpleDateFormat(format);  
                                               result  =  df.format(date);  
                                   }  
                       }  catch  (Exception  e)  {  
                       }  
                       return  result;  
           }  
 
           public  static  String  format(java.util.Date  date)  {  
                       return  format(date,  "yyyy/MM/dd");  
           }  
 
           /**  
             *  返回年份  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回年份  
             */  
           public  static  int  getYear(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.YEAR);  
           }  
 
           /**  
             *  返回月份  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回月份  
             */  
           public  static  int  getMonth(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.MONTH)  +  1;  
           }  
 
           /**  
             *  返回日份  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回日份  
             */  
           public  static  int  getDay(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.DAY_OF_MONTH);  
           }  
 
           /**  
             *  返回小时  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回小时  
             */  
           public  static  int  getHour(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.HOUR_OF_DAY);  
           }  
 
           /**  
             *  返回分钟  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回分钟  
             */  
           public  static  int  getMinute(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.MINUTE);  
           }  
 
           /**  
             *  返回秒钟  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回秒钟  
             */  
           public  static  int  getSecond(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.get(java.util.Calendar.SECOND);  
           }  
 
           /**  
             *  返回毫秒  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回毫秒  
             */  
           public  static  long  getMillis(java.util.Date  date)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTime(date);  
                       return  c.getTimeInMillis();  
           }  
 
           /**  
             *  返回字符型日期  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回字符型日期  
             */  
           public  static  String  getDate(java.util.Date  date)  {  
                       return  format(date,  "yyyy/MM/dd");  
           }  
 
           /**  
             *  返回字符型时间  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回字符型时间  
             */  
           public  static  String  getTime(java.util.Date  date)  {  
                       return  format(date,  "HH:mm:ss");  
           }  
 
           /**  
             *  返回字符型日期时间  
             *    
             *  @param  date  
             *                        日期  
             *  @return  返回字符型日期时间  
             */  
           public  static  String  getDateTime(java.util.Date  date)  {  
                       return  format(date,  "yyyy/MM/dd  HH:mm:ss");  
           }  
 
           /**  
             *  日期相加  
             *    
             *  @param  date  
             *                        日期  
             *  @param  day  
             *                        天数  
             *  @return  返回相加后的日期  
             */  
           public  static  java.util.Date  addDate(java.util.Date  date,  int  day)  {  
                       java.util.Calendar  c  =  java.util.Calendar.getInstance();  
                       c.setTimeInMillis(getMillis(date)  +  ((long)  day)  *  24  *  3600  *  1000);  
                       return  c.getTime();  
           }  
 
           /**  
             *  日期相减  
             *    
             *  @param  date  
             *                        日期  
             *  @param  date1  
             *                        日期  
             *  @return  返回相减后的日期  
             */  
           public  static  int  diffDate(java.util.Date  date,  java.util.Date  date1)  {  
                       return  (int)  ((getMillis(date)  -  getMillis(date1))  /  (24  *  3600  *  1000));  
           }              
}  
我来个简单点的,也许有点用  
Calendar  now  =  Calendar.getInstance();  
int  year  =  now.get(Calendar.YEAR);  
int  date  =  now.get(Calendar.DAY_OF_MONTH);  
int  month  =  now.get(Calendar.MONTH)  +  1;  
int  hour  =  now.get(Calendar.HOUR);  
int  min  =  now.get(Calendar.MINUTE);  
int  sec  =  now.get(Calendar.SECOND);  

在最近的一个OA中，我需要判断两个日期是否是同一周，根据一个给定的日期获得所属周的周一和周五的日期。  
 
在完成以上任务时，我发现Calendar  的确是一个功能强大的class。

 

package com.elink.util;

/**//*
 * <p>Company: 凌科软件 www.elinksoft.com </p>
 * @author liubaojun
 * @version 1.0
 * Created on 2004-11-29
 * 来源于 elinkBSP (业务架构平台) 部分源代码
 */

import java.text.*;
import java.util.*;

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 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();
  }
 }

 /** *//**
  * 得到指定日期的后一个工作日
  * 
  * @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();
 }
 
 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 );
 }
}

 

java日期操作 及 Timer定时器
2006-11-15 17:17

 

作者:罗代均，ldj_work#126.com ,转载请保持完整性.

转自:http://hi.baidu.com/luodaijun/blog/item/304d19174ecefb014a90a79b.html

1.基础

    Date,这个大家都认识了，用于保存日期信息，但不推荐进行日期操作及初始化特定日期

     Calendar及其子类GregorianCalendar:日历类，日期操作，初始化特定日期。

    DateFormat及其子类SimpleDateformat: 日期格式化，日期的默认显示方式不适合中国人，所以需要格式化为中国人常用的格式来显示。

    取得当期日期,  Date date=new Date();

    初始化特定日期:假设我们要得到日期为2006-10-27日的对象，需要按如下方式获得。

         Calendar cal = new  GregorianCalendar(2006, 9, 27,0,0,0);
         Date date = cal.getTime();

     注意:date,getTime()取得的是当期时间的毫秒数,月份比实际的减1

      GregorianCalendar构造方法参数依次为：年，月-1，日，小时，分，秒     

    格式化为我们熟悉的方式显示：

          DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH;mm:ss");
          String chinesedate = format.format(date);

   日期 年，月，日，分，秒的取得

          Calendar cal = Calendar.getInstance();

          int year = cal.get(Calendar.YEAR);

          int month=cal.get(Calendar.MONTH)+1;

          int day = cal.get(Calendar.DAY_OF_MONTH);

           int hour = cal.get(Calendar.HOUR_OF_DAY);

          int  minute = cal.get(Calendar.MINUTE);

           int second = cal.get(Calendar.SECOND);

           注意：月份，实际的月份要比Clendar得到的加1，因为java月份是从0~11 

2.日期基本操作

   得到两个日期相差的天数

    Date endDate=..

    Date startDate = ...

   相差天数 int days=(int) ((endDate.getTime()-startDate.getTime())/(1000*24*60*60)+0.5);

   得到某个月的天数

    Calendar cal = Calendar.getInstance();

   int month=cal.getActualMaximum(Calendar.DAY_OF_MONTH);

   日期加1天

    cal.add(Calendar.DATE, 1)；//日期加1天

    Calendar.YEAR,Calendar.MONTH,Calendar.WEEK_OF_YEAR),分别是年，月，周

3，java.sql,Date()和java.util.Date();

    前面我们说的都是java.util.Date类，java.sql.Date类是操作数据库用的日期类型

   java.util.Date date=....

    java.sql.Date sqldate=new java.sql.Date(date.getTime());

   也可以这样：String date="2005-11-10";

    java.sql.Date sqlDate=java.sql.Date.valueOf(date);

4,定时器

   a,编写类,实现TimeTask接口，定时执行的代码写入run()方法中

   b.  timer.schedule(TimeTask子类对象, 开始执行的日期, 周期);

   周期为毫秒数

  例子:

  类MyTask:

import java.util.*;

public class MyTask extends TimerTask {
    public void run() {
        System.out.println("MyTask 正在执行...");
    }
}

  类TimerDemo:

import java.util.Timer;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Date;

public class TimerDemo {
    public static void main(String[] args) {
        Timer timer = new Timer();
        MyTask task = new MyTask();
        Calendar cal = new GregorianCalendar(2006, 9, 28, 12, 49, 0);
        Date date = cal.getTime();
        System.out.println("date :" + date.toLocaleString());
        timer.schedule(task, date, 1000);
    }
}
===================================

将Date类型写入数据库的两种方法
先了解几个类:
1、具体类(和抽象类相对)java.util.Date 
2、抽象类java.text.DateFormat 和它的一个具体子类,java.text.SimpleDateFormat 
3、抽象类java.util.Calendar 和它的一个具体子类,java.util.GregorianCalendar 
具体类可以被实例化, 但是抽象类却不能. 你首先必须实现抽象类的一个具体子类.

************************************
一种将java的日期类型直接转换为SQL的日期类型的方法，比较简单但适用性狭窄,
注意一下例子在jdk下编译没有时间，但在jb和Eclipse下就有时间，不知怎么回事

——————————————
public class a {

public static void main(String[] args) {
 
  java.util.Date now = new Date();
  //PreparedStatement类型的setDate方法只接受sql.date类型，所有必须先转换
  java.sql.Date sqlnow = new java.sql.Date(now.getTime());
   try {
    //froName必须放在try中，否则编译不通过，可能froName方法抛出编译时异常了
    //经查阅 public static Class forName(String className) throws     ClassNotFoundException {...}
    Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
    Connection connection = DriverManager.getConnection("jdbc:microsoft:sqlserver://192.168.0.2:1433;DatabaseName=pubs","sa","");
    PreparedStatement ps=connection.prepareStatement("update test set f1=?");
    ps.setDate(1,sqlnow);
    int i = ps.executeUpdate();
   }
    catch (Exception ex) {}

 }
}
**********************************************************
另一种是将java的date类型通过SimpleDateFormat转换为字符串，再写到sql语句中
-----------------------------------------------------------
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class a{
  public static void main(String[] args) {
  //之所以用kk而不用hh是因为kk是24进制的而不虽操作系统设置变动
  SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd kk:mm:ss");
  Date now = new Date();
  //format()方法的返回值是String型
  System.out.println(sdf.format(date));
 }}

-----------------------------------------------------
一下是逆操作，将String转换为Date，parse（）方法能抛出ParseException异常，所以你必须使用适当的异常处理技术
try{
    SimpleDateFormat sbf =new SimpleDateFormat("yyyy-MM-dd kk:mm:ss");
    String sdate="2004-05-14 21:29:51";
    Date ddate = sbf.parse(sdate);
    System.out.println(ddate);
    }
catch (Exception ex) { }
**************************************************************
以下是副产品，我们用到的情况比较少
util.date类型
----------------------------------------------
   //1年前日期
   java.util.Date myDate=new java.util.Date(); 
   long myTime=(myDate.getTime()/1000)-60*60*24*365;
   myDate.setTime(myTime*1000);
   //明天日期
   myDate=new java.util.Date();
   myTime=(myDate.getTime()/1000)+60*60*24;
   myDate.setTime(myTime*1000);
  //两个时间之间的天数
   SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
   java.util.Date date= myFormatter.parse("2003-05-1");
   java.util.Date mydate= myFormatter.parse("1899-12-30");
   long  day=(date.getTime()-mydate.getTime())/(24*60*60*1000);
   //加半小时
   SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
   java.util.Date date1 = format.parse("2002-02-28 23:16:00");
   long Time=(date1.getTime()/1000)+60*30;
   date1.setTime(Time*1000);
   String mydate1=formatter.format(date1);
   //年月周求日期
   SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM F E");
   java.util.Date date2= formatter2.parse("2003-05 5 星期五");
   SimpleDateFormat formatter3 = new SimpleDateFormat("yyyy-MM-dd");
   String mydate2=formatter3.format(date2);
   //求是星期几
   mydate= myFormatter.parse("2001-1-1");
   SimpleDateFormat formatter4 = new SimpleDateFormat("E");
   String mydate3=formatter4.format(mydate);
-----------------------------------------------
 now.getYear()；//实际年份减去1900,如果构造函数为Date(2008,2,25)则不减1900，如果构造函数为Date(17009456745)或者setTime(17009456745)还减1900
 now.getMonth();//实际月份减去1,如果构造函数为Date(2008,2,25)则不减1，如果构造函数为Date(17009456745)或者setTime(17009456745)还减1900
 now.getDay();//*，原来是取星期，不知sun公司是咋想的，脑袋进水了。
 now.getDate();//这才是取1～31之间的日
 now.getHours();//24进制的小时
 now.getMinutes();//分
 now.getSeconds();//秒
 now.getTime();//返回1970年1月1日00:00:00起至今的毫秒数
 now.setTime(long time);//真实日期为1970年1月1日午夜+time毫秒

*************************************
日历类型的子类GregorianCalendar类型
构造函数GregorianCalendar(int year, int month, int date) ，无参数为但前时间
注意月份的表示，一月是0，二月是1，以此类推。因此最好使用单词而不是使用数字来表示月份。父类Calendar使用常量来表示月份：JANUARY, FEBRUARY...
所以1903年12月17日可以写为
GregorianCalendar aaa = new GregorianCalendar(1903, Calendar.DECEMBER, 17)
GregorianCalendar aaa = new GregorianCalendar(1903, 11, 17);
---------------------------------------
import java.util.Date;
import java.text.DateFormat;
import java.util.GregorianCalendar;
public class a {
public static void main(String[] args) {
  DateFormat df =  DateFormat.getDateInstance(DateFormat.FULL);
  GregorianCalendar gca = new GregorianCalendar();
  //getTime()方法是将GregorianCalendar对象转换为Date对象
  gca.setTime(new Date());
  System.out.println("系统时间: " +df.format(gca.getTime()));
  //set 方法能够让我们通过简单的设置星期中的哪一天这个域来将我们的时间调整为星期五.注意到这里我们使用了常量 DAY_OF_WEEK 和 FRIDAY来增强代码的可读性.
  //如果当前为星期五时间不变
  gca.set(GregorianCalendar.DAY_OF_WEEK, GregorianCalendar.FRIDAY);
  System.out.println("下一个星期五: " +  df.format(gca.getTime()));
  //add 方法让我们能够在日期上加上数值.
  gca.add(GregorianCalendar.DAY_OF_MONTH, 8);
  System.out.println("再加8天: " +  df.format(gca.getTime()));
  //get方法取对象中的一部分
  int i =  gca.get(GregorianCalendar.DAY_OF_MONTH);
  System.out.println(i);
}}



***************************************
Locale类：（java.util.Locale）
-----------------------------------
import java.util.Locale;
public class a {
 public static void main(String[] args) {
  Locale localeEN = new Locale("en", "US");
  //另一实例化方法=locale.ENGLISH;
  System.out.println("Display Name: " +localeEN.getDisplayName());
  System.out.println("Country: " + localeEN.getCountry());
  System.out.println("Language: " + localeEN.getLanguage());

  Locale localeFR = new Locale("fr", "FR");
  System.out.println("\nDisplay Name: " +localeFR.getDisplayName());
  System.out.println("Country: " + localeFR.getCountry());
  System.out.println("Language: " + localeFR.getLanguage());

  // 用三种语言显示本机语言、英语、法语
  System.out.println("用本语显示DisplayName: "+ localeEN.getDisplayName());
  System.out.println("用英语显示DisplayName："+   localeEN.getDisplayName(localeEN ));
  System.out.println("用法语显示DisplayName："+   localeEN.getDisplayName(localeFR ));
 }
}
*****************************************************

把Date以不同地域的格式显示：java.text.DateFormat
getDateTimeInstance()的前两个参数分别代表日期风格和时间风格，取值为SHORT, MEDIUM, LONG, 和 FULL
getDateInstance()方法：Java还提供了几个选择日期格式，你可以通过使用重载的getDateInstance(int style)获得。出于方便的原因，DateFormat提供了几种预置的常量，你可以使用这些常量参数SHORT, MEDIUM, LONG, 和FULL
-----------------------------------------------
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;
public class a {
  public static void main(String[] args) {    
    Date now=new Date();
    Locale localeCN=Locale.CHINA;
    DateFormat df=DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL,localeCN);
    System.out.println(df.format(now));
   //结果为2004年5月17日 星期一 下午16时38分32秒 CST 
}}
******************************************************
时区 java.util.TimeZone
--------------------------------------------------------
import java.util.TimeZone;
public class a {
  public static void main(String[] args) {
  // 系统时区
  TimeZone timeZoneFL = TimeZone.getDefault();
  System.out.println("\n" + timeZoneFL.getDisplayName());
  System.out.println("与GMT相差的微秒数: " + timeZoneFL.getRawOffset());
  System.out.println("Uses daylight saving: " + timeZoneFL.useDaylightTime());
  //通过“时区字符串ID”指定时区
  TimeZone timeZoneLondon = TimeZone.getTimeZone("Europe/London");
  System.out.println("\n" + timeZoneLondon.getDisplayName());
  System.out.println("与GMT相差的微秒数: " + timeZoneLondon.getRawOffset());
  System.out.println("采用夏令时: " + timeZoneLondon.useDaylightTime());
  }}
-------------------------------------------------------
显示结果：
中国标准时间
与GMT相差的微秒数:
Uses daylight saving：false;

格林威治时间
与GMT相差的微秒数:
采用夏令时: true

********************************************************
显示不同时区的时间  df.setTimeZone(TimeZone kkk)
----------------------------------------------------
public class a {
  public static void main(String[] args) {

    Date now=new Date();
    DateFormat df=DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);
    TimeZone timezoneCH=TimeZone.getTimeZone("China/BeiJing");
    df.setTimeZone(timezoneCH);
    System.out.println("北京时间"+df.format(now));
    TimeZone timezoneFR=TimeZone.getTimeZone("Europe/Paris");
    df.setTimeZone(timezoneFR);
    System.out.println("巴黎时间"+df.format(now));   
  }}
-----------------------------------------------------
结果如下:
北京时间2004年5月17日 星期一 上午09时31分34秒 GMT
巴黎时间2004年5月17日 星期一 上午11时31分34秒 CEST
*******************************************************
分享到：
| SSO单点登录解决方案[转载]
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java日期操作大全

    以下是对给定内容中涉及的Java日期操作进行的详细说明： 1. **获取指定月份的第一天**： 使用`java.util.Calendar`类可以方便地获取指定日期所在月份的第一天。首先，将输入的日期字符串转换为`java.util.Date`...

    java 日期操作汇总

    java 日期操作汇总包含date calendar 相互转换

    java日期转化操作大全

    在Java编程语言中，日期和时间的处理是常见的任务，涉及到日期的创建、格式化、解析、比较以及各种转换操作。本篇文章将深入探讨Java中日期转换的各种方法和技巧。 一、日期对象的创建 在Java中，日期对象可以通过...

    Java日期操作接口

    本篇文章将详细探讨Java中的日期操作接口，特别是围绕"Java日期操作接口"这个主题，以及与之相关的`DateFilter.java`文件。 首先，Java中最基础的日期类是`java.util.Date`。这个类自Java 1.0起就存在，但它的设计...

    java日期处理大全

    ### Java日期处理大全：掌握时间的艺术 在Java编程中，日期和时间的处理是不可或缺的一部分，尤其是在涉及到数据记录、时间戳、定时任务等场景时。本文将深入探讨Java中的日期处理技术，涵盖从基础到进阶的各种技巧...

    JAVA日期操作汇总

    ### JAVA日期操作汇总 本文将对Java中的日期操作进行详细解析，主要涵盖以下几个方面： 1. 计算某个月份的最大天数； 2. `Calendar`与`Date`之间的转换； 3. 日期格式化； 4. 获取指定日期所在的周序号及设置某...

    java日期操作类

    java日期操作类 操作java日期 替换simplatedateformate

    java日期类型操作工具类

    java日期类型操作工具类

    java日期时间操作函数代码

    如果这个文件包含了代码示例，你可以打开查看具体实现，进一步学习和理解Java日期时间操作的细节。 总之，理解和熟练掌握Java的日期时间操作对于开发人员来说至关重要，无论是在处理用户输入、记录日志还是进行复杂...

    java操作日期大全

    ### Java操作日期大全 在Java开发中，对日期时间的操作是一项基本且重要的任务。本文将详细介绍如何使用Java处理各种日期类型及其转换、提取指定日期的各个组成部分、获取当前日期及指定格式、计算指定月份的天数...

    JAVA时间操作大全

    ### Java时间操作大全 #### 概述 在Java编程语言中，处理日期与时间是非常常见的需求之一。无论是开发Web应用还是桌面应用，掌握时间相关的类及其用法都至关重要。本篇文章将涵盖Java中与时间操作有关的所有基本...

    JAVA日期操作类详细讲解

    本篇内容将深入讲解Java中的日期操作类，这对于Java初学者来说是非常重要的知识点。 首先，我们要了解Java中的基础日期类`java.util.Date`。这个类在早期的Java版本中被广泛使用，但其API设计存在一些问题，例如不...

    Java Date操作大全

    Java Date操作大全 例举了所有java 日期操作

    操作日期的java包

    "操作日期的java包"即指的是Joda-Time这个第三方库。 Joda-Time是Java领域广泛使用的日期时间处理库，它的设计目标是替代Java标准库中的日期和时间API，因为后者在设计上存在一些问题，如可读性差、易用性不足等。...

    java日期时间转换大全

    ### Java日期时间转换大全 在Java编程中，处理日期和时间是常见的需求，尤其是在涉及到数据库操作、文件命名、日志记录等场景时。本文将详细解析如何在Java中进行日期和时间的转换，涵盖从字符串到日期对象的转换，...

    java对日期的加减操作

    Java 日期加减操作详解 Java 中对日期的加减操作是指对日期的加减、年、月、日、天等操作。Java 提供了多种方式来实现日期的加减操作，本文将详细介绍其中的两种方法。 使用 java.util.Calender 实现日期加减 ...

    java日期类函数方法整理

    根据给定的文件信息，...以上就是对Java日期类函数方法的整理和解释，涵盖了基本的日期操作，包括日期的格式化、解析、转换以及年份和月份的获取等。掌握这些函数和方法，能够帮助开发者更高效地处理日期相关的任务。

    java实现的日期操作类

    标题提到的"java实现的日期操作类"通常指的是使用这些类来完成特定的日期计算任务，如获取星期几或计算未来的日期。 `java.util.Date`是Java早期用来表示日期和时间的类，但它的API设计并不理想，易用性较差。因此...

    java语言日期处理大全

    以下是一些关于Java日期处理的关键知识点，这些知识点在给定的文件中有所提及： 1. **获取当前日期**： Java通过`java.util.Date`类可以获取服务器上的当前日期。创建一个Date对象即会返回当前系统时间，如`Date ...

Magicbox
Global site tag (gtag.js) - Google Analytics