java日期操作

取得指定月份的第一天与取得指定月份的最后一天

/** 
* 取得指定月份的第一天 
* 
* @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
*******************************************************

来源： <http://www.blogjava.net/i369/articles/83483.html>

posted @ 2013-09-01 21:25 predy 阅读(329) 评论(0) 收藏举报

刷新页面返回顶部

predy

PRogress Every DaY

java日期操作

公告