Java中对日期和时间的操作文档集锦
Java中对日期和时间的操作文档集锦
目录：
JAVA中的时间操作
选择自 leshui 的 Blog
经常看见jsp版里有人问时间操作的问题，这些问题一般包括：取当前时间，把一个指定的字符串时间转化成时间类型，求两个时间之间的天数，求一段时间以前的时间，求一段时间以后的时间，在这里就把这些问题汇总一下。
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.text.*"%>
<%@ page import="java.util.*"%>
<%
//字符串转化成时间类型（字符串可以是任意类型，只要和SimpleDateFormat中的格式一致即可）
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("M/dd/yyyy hh:mm:ss a",java.util.Locale.US);
java.util.Date d = sdf.parse("5/13/2003 10:31:37 AM");
out.println(d);
out.println("<br>");
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mDateTime1=formatter.format(d);
out.println(mDateTime1);
out.println("<br>");
out.println(d.getTime());
out.println("<br>");
//当前时间
Calendar cal = Calendar.getInstance();
// SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss G E D F w W a E F");
String mDateTime=formatter.format(cal.getTime());
out.println(mDateTime);
out.println("<br>");
//1年前日期
java.util.Date myDate=new java.util.Date();
long myTime=(myDate.getTime()/1000)-60*60*24*365;
myDate.setTime(myTime*1000);
String mDate=formatter.format(myDate);
out.println(mDate);
out.println("<br>");
//明天日期
myDate=new java.util.Date();
myTime=(myDate.getTime()/1000)+60*60*24;
myDate.setTime(myTime*1000);
mDate=formatter.format(myDate);
out.println(mDate);
out.println("<br>");
//两个时间之间的天数
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);
out.println(day);
out.println("<br>");
//加半小时
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);
out.println(mydate1);
out.println("<br>");
//年月周求日期
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);
out.println(mydate2);
out.println("<br>");
//求是星期几
mydate= myFormatter.parse("2001-1-1");
SimpleDateFormat formatter4 = new SimpleDateFormat("E");
String mydate3=formatter4.format(mydate);
out.println(mydate3);
out.println("<br>");
%>
作者Blog：http://blog.csdn.net/leshui/
happyegg ( 2003-09-06)
其实求几天几月几年前/后的方法，应该用Calendar类比较好的。
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH,1);
cal.add(Calendar.YEAR,2000);
date = cal.getTime();
数据库查询问题
作 者： xinfudepangbian ()
我想查询指定时间段的数据 比如 2006-4-4 到 2006-7-7 的数据
日期是number 可数据库里是date ，我用什么方法转换阿 ，谢谢了，
SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date dt1 = sf.parse("2005-11-11");
java.sql.Date qishiriqi = new java.sql.Date(dt1.getTime());
java.util.Date dt2 = sf.parse("2006-07-14");
java.sql.Date zhongzhiriqi = new java.sql.Date(dt2.getTime());
源码发上 大家帮我看看 qishiriqi 和 zhongzhiriqi 入库比较的
--
Calendar cals = Calendar.getInstance();
cals.set(Calendar.YEAR,年);
cals.set(Calenar.MONTH,月);
cals.set(Calenar.DAY_OF_MONTH,日);
String secondDate = (new Timestamp(cals.getTimeInMillis())).toString();
然后把firstDate和secondDate传到SQL语句中,执行它
--
String sql = "select * from TM_BUS_SPECIAL where LINE_NO = '" + request.getParameter("RiZhi_line_no") + "'" + "and CREATE_TIME between '" +qishiriqi + "'" + " and '" + zhongzhiriqi + "'";
这样传日期和你用字符串传日期是一个效果，sql.Date被转成字符串了
可以使用PreparedStatement,之前的日期转换仍然可用
String sql = "select * from TM_BUS_SPECIAL where LINE_NO=? and CREATE_TIME between ? and ? " ;
PreparedStatement pst = conn.preparedStatement(sql);
pst.setString(1, request.getParameter("RiZhi_line_no"));
pst.setDate(2, qishiriqi);
pst.setDate(3, zhongzhiriqi);
ResultSet rs = pst.executeQuery();
1. parse要抛异常
try{
java.util.Date dt1 = sf.parse("2005-11-11");
}catch(ParseException e){
}
2. 在（ between '" +qishiriqi + "'" + " and '" + zhongzhiriqi ）里 又把日期型以字串型传给了SQL 这里就不要再用字串了 直接 between " +qishiriqi + " and " + zhongzhiriqi 就可以了
try{
java.util.Date dt1 = sf.parse("2005-11-11");
}catch(ParseException e){
}
2. 在（ between '" +qishiriqi + "'" + " and '" + zhongzhiriqi ）里又把日期型以字串型传给了SQL 这里就不要再用字串了 直接 between " +qishiriqi + " and " + zhongzhiriqi 就可以了
没抛异常 而且是以字串传 的
改了 就可以了
如果是oracle,就用下面这一句:
String sql = "select * from TM_BUS_SPECIAL where LINE_NO = '" + request.getParameter("RiZhi_line_no") + "'" + "and CREATE_TIME between to_date('"+qishiriqi+"','yyyy-mm-dd') and to_date('"+zhongzhiriqi+"','yyyy-mm-dd')'" ;
其中qishiriqi,zhongzhiriqi是形如yyyy-mm-dd的日期字符串,如"2006-07-29"
日期格式、日期的解析和日期的计算
Friday, 23. June 2006, 04:45:48
Java 语言的Calendar(日历),Date(日期), 和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分. 日期是商业逻辑计算一个关键的部分. 所有的开发者都应该能够计算未来的日期, 定制日期的显示格式, 并将文本数据解析成日期对象. 我们写了两篇文章, 这是第一篇, 我们将大概的学习日期, 日期格式, 日期的解析和日期的计算.
我们将讨论下面的类:
1、具体类(和抽象类相对)java.util.Date
2、抽象类java.text.DateFormat 和它的一个具体子类,java.text.SimpleDateFormat
3、抽象类java.util.Calendar 和它的一个具体子类,java.util.GregorianCalendar
具体类可以被实例化, 但是抽象类却不能. 你首先必须实现抽象类的一个具体子类.
Date 类从Java 开发包(JDK) 1.0 就开始进化, 当时它只包含了几个取得或者设置一个日期数据的各个部分的方法, 比如说月, 日, 和年. 这些方法现在遭到了批评并且已经被转移到了Calendar类里去了, 我们将在本文中进一步讨论它. 这种改进旨在更好的处理日期数据的国际化格式. 就象在JDK 1.1中一样, Date 类实际上只是一个包裹类, 它包含的是一个长整型数据, 表示的是从GMT(格林尼治标准时间)1970年, 1 月 1日00:00:00这一刻之前或者是之后经历的毫秒数.
一、创建一个日期对象
让我们看一个使用系统的当前日期和时间创建一个日期对象并返回一个长整数的简单例子. 这个时间通常被称为Java 虚拟机(JVM)主机环境的系统时间.
import java.util.Date;
public class DateExample1 {
public static void main(String[] args) {
// Get the system date/time
Date date = new Date();
System.out.println(date.getTime());
}
}
在星期六, 2001年9月29日, 下午大约是6:50的样子, 上面的例子在系统输出设备上显示的结果是 1001803809710. 在这个例子中,值得注意的是我们使用了Date 构造函数创建一个日期对象, 这个构造函数没有接受任何参数. 而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期.
那么, 现在我们已经知道了如何获取从1970年1月1日开始经历的毫秒数了. 我们如何才能以一种用户明白的格式来显示这个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基类 java.text.DateFormat 就派得上用场了.
二、日期数据?亩ㄖ聘袷?
假如我们希望定制日期数据的格式, 比方星期六-9月-29日-2001年. 下面的例子展示了如何完成这个工作:
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateExample2 {
public static void main(String[] args) {
SimpleDateFormat bartDateFormat =
new SimpleDateFormat("EEEE-MMMM-dd-yyyy");
Date date = new Date();
System.out.println(bartDateFormat.format(date));
}
}
只要通过向SimpleDateFormat 的构造函数传递格式字符串"EEE-MMMM-dd-yyyy", 我们就能够指明自己想要的格式. 你应该可以看见, 格式字符串中的ASCII 字符告诉格式化函数下面显示日期数据的哪一个部分. EEEE是星期, MMMM是月, dd是日, yyyy是年. 字符的个数决定了日期是如何格式化的.传递"EE-MM-dd-yy"会显示 Sat-09-29-01. 请察看Sun 公司的Web 站点获取日期格式化选项的完整的指示.
三、将文本数据解析成日期对象
假设我们有一个文本字符串包含了一个格式化了的日期对象, 而我们希望解析这个字符串并从文本日期数据创建一个日期对象. 我们将再次以格式化字符串"MM-dd-yyyy" 调用SimpleDateFormat类, 但是这一次, 我们使用格式化解析而不是生成一个文本日期数据. 我们的例子, 显示在下面, 将解析文本字符串"9-29-2001"并创建一个值为001736000000 的日期对象.
例子程序:
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateExample3 {
public static void main(String[] args) {
// Create a date formatter that can parse dates of
// the form MM-dd-yyyy.
SimpleDateFormat bartDateFormat =
new SimpleDateFormat("MM-dd-yyyy");
// Create a string containing a text date to be parsed.
String dateStringToParse = "9-29-2001";
try {
// Parse the text version of the date.
// We have to perform the parse method in a
// try-catch construct in case dateStringToParse
// does not contain a date in the format we are expecting.
Date date = bartDateFormat.parse(dateStringToParse);
// Now send the parsed date as a long value
// to the system output.
System.out.println(date.getTime());
}
catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
}
五、使用标准的日期格式化过程
既然我们已经可以生成和解析定制的日期格式了, 让我们来看一看如何使用内建的格式化过程. 方法 DateFormat.getDateTimeInstance() 让我们得以用几种不同的方法获得标准的日期格式化过程. 在下面的例子中, 我们获取了四个内建的日期格式化过程. 它们包括一个短的, 中等的, 长的, 和完整的日期格式.
import java.text.DateFormat;
import java.util.Date;
public class DateExample4 {
public static void main(String[] args) {
Date date = new Date();
DateFormat shortDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.SHORT,
DateFormat.SHORT);
DateFormat mediumDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.MEDIUM,
DateFormat.MEDIUM);
DateFormat longDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.LONG,
DateFormat.LONG);
DateFormat fullDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.FULL,
DateFormat.FULL);
System.out.println(shortDateFormat.format(date));
System.out.println(mediumDateFormat.format(date));
System.out.println(longDateFormat.format(date));
System.out.println(fullDateFormat.format(date));
}
}
注意我们在对 getDateTimeInstance的每次调用中都传递了两个值. 第一个参数是日期风格, 而第二个参数是时间风格. 它们都是基本数据类型int(整型). 考虑到可读性, 我们使用了DateFormat 类提供的常量: SHORT, MEDIUM, LONG, 和 FULL. 要知道获取时间和日期格式化过程的更多的方法和选项, 请看Sun 公司Web 站点上的解释.
运行我们的例子程序的时候, 它将向标准输出设备输出下面的内容:
9/29/01 8:44 PM
Sep 29, 2001 8:44:45 PM
September 29, 2001 8:44:45 PM EDT
Saturday, September 29, 2001 8:44:45 PM EDT
六、Calendar 类
我们现在已经能够格式化并创建一个日期对象了, 但是我们如何才能设置和获取日期数据的特定部分呢, 比如说小时, 日, 或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类. 就如我们前面提到的那样, Calendar 类中的方法替代了Date 类中被人唾骂的方法.
假设你想要设置, 获取, 和操纵一个日期对象的各个部分, 比方一个月的一天或者是一个星期的一天. 为了演示这个过程, 我们将使用具体的子类 java.util.GregorianCalendar. 考虑下面的例子, 它计算得到下面的第十个星期五是13号.
import java.util.GregorianCalendar;
import java.util.Date;
import java.text.DateFormat;
public class DateExample5 {
public static void main(String[] args) {
DateFormat dateFormat =
DateFormat.getDateInstance(DateFormat.FULL);
// Create our Gregorian Calendar.
GregorianCalendar cal = new GregorianCalendar();
// Set the date and time of our calendar
// to the system&s date and time
cal.setTime(new Date());
System.out.println("System Date: " +
dateFormat.format(cal.getTime()));
// Set the day of week to FRIDAY
cal.set(GregorianCalendar.DAY_OF_WEEK,
GregorianCalendar.FRIDAY);
System.out.println("After Setting Day of Week to Friday: " +
dateFormat.format(cal.getTime()));
int friday13Counter = 0;
while (friday13Counter <= 10) {
// Go to the next Friday by adding 7 days.
cal.add(GregorianCalendar.DAY_OF_MONTH, 7);
// If the day of month is 13 we have
// another Friday the 13th.
if (cal.get(GregorianCalendar.DAY_OF_MONTH) == 13) {
friday13Counter++;
System.out.println(dateFormat.format(cal.getTime()));
}
}
}
}
在这个例子中我们作了有趣的函数调用:
cal.set(GregorianCalendar.DAY_OF_WEEK,
GregorianCalendar.FRIDAY);
和:
cal.add(GregorianCalendar.DAY_OF_MONTH, 7);
set 方法能够让我们通过简单的设置星期中的哪一天这个域来将我们的时间调整为星期五. 注意到这里我们使用了常量 DAY_OF_WEEK 和 FRIDAY来增强代码的可读性. add 方法让我们能够在日期上加上数值. 润年的所有复杂的计算都由这个方法自动处理.
我们这个例子的输出结果是:
System Date: Saturday, September 29, 2001
当我们将它设置成星期五以后就成了: Friday, September 28, 2001
Friday, September 13, 2002
Friday, December 13, 2002
Friday, June 13, 2003
Friday, February 13, 2004
Friday, August 13, 2004
Friday, May 13, 2005
Friday, January 13, 2006
Friday, October 13, 2006
Friday, April 13, 2007
Friday, July 13, 2007
Friday, June 13, 2008
七、时间掌握在你的手里
有了这些Date 和Calendar 类的例子, 你应该能够使用 java.util.Date, java.text.SimpleDateFormat, 和 java.util.GregorianCalendar 创建许多方法了.
在下面的文章中, 我们将讨论更高级的Date 和 Calendar 类的使用技巧, 包括时区和国际化的格式. 我们还会考察两个日期类 java.sql.Date 和 java.util.Date 之间的区别.
原文地址: http://my.opera.com/ukinglli/blog/show.dml/311137
在java中怎样利用时间间隔计算日期
Wednesday, 28. June 2006, 05:44:01
代码内容
Date D = new Date();
System.out.println(D);
D.setDate(D.getDate()-1);
System.out.println(D);
上面的例子就可以对日期进行计算，但是因为 Date 的 getDay 等方法都已经不推荐使用了，它有很大的局限性：存在1970年问题，无法计算1970年以前的日期，原因是它以English文化为中心，起始日前为Unix的诞生时间，1970年1月1日。推荐使用Calendar类，它可以表示任何历法的日期。所以在日期需要计算的时候通常会选用 java.util.Calendar。
下面是一个取某个日期前一天的例子，用到了 java.text.SimpleDateFormat，仅仅是为了控制输出格式，对日期计算没有实际意义。
代码内容
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance(); // 当时的日期和时间
System.out.println(df.format(c.getTime()));
int d = c.get(Calendar.DAY_OF_MONTH); // 取出“日”数
--d; // 将“日”减一，即得到前一天
c.set(Calendar.DAY_OF_MONTH, d); // 将“日”数设置回去
System.out.println(df.format(c.getTime()));
c.set(Calendar.DAY_OF_MONTH, 0); // 如果当前日期是1日的情况会怎么样？
// 这里演示了这种情况(这里情况下1-1=0所以直接赋0值了)
System.out.println(df.format(c.getTime())); // 这里打印了上个月的最后一天。
以下展示Calendar类更多用法
代码内容
<%
Calendar now=Calendar.getInstance();
int year=now.get(Calendar.YEAR);
int mon=now.get(Calendar.MONTH);
int day=now.get(Calendar.DAY_OF_MONTH);
int hh=now.get(Calendar.HOUR);
int mm=now.get(Calendar.MINUTE);
int ss=now.get(Calendar.SECOND);
out.print(year+"-"+mon+"-"+day+" "+hh+":"+mm+":"+ss);
%>
上面打印出的日期根式是 2005-01-01 12:24:20
关于JAVA中时间操作的两个例子
package dateandtime;
import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class SqlDateAndUtilDate {
public static void main(String[] args) throws ParseException
{
java.sql.Date sqlDate=null;
Date utilDate=null;
utilDate= new Date(System.currentTimeMillis());
System.out.println("utileDate="+utilDate);
sqlDate=new java.sql.Date(System.currentTimeMillis());
System.out.println("sqlDate="+sqlDate);
System.out.println("sqlDateConvertoUtilDate="+((Date)sqlDate));
Time sqlTime = new java.sql.Time(utilDate.getTime());
System.out.println("sqlTime="+sqlTime);
java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(utilDate.getTime());
System.out.println("sqlTimestamp="+sqlTimestamp);
String dataTime="3/Jun/2005 02:12:10 AM";
SimpleDateFormat format = new SimpleDateFormat(
"dd/MMM/yyyy hh:mm:ss a", Locale.ENGLISH);
Date date=format.parse(dataTime);
System.out.println(date);
/*format=new SimpleDateFormat(
"yyyy-MMM-dd hh:mm:ss", Locale.ENGLISH);*/
format.applyPattern("yyyy-MMM-dd hh:mm:ss");
String dateString="2005-Aug-04 11:06:00";
date=format.parse(dateString);
System.out.println(date);
}
}
package dateandtime;
//日期和时间处理示例
import java.util.*;
import java.text.SimpleDateFormat;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
public class TestDateTime
{
public static void main(String[] argv)
{
long nCurrentTime = System.currentTimeMillis();
java.util.Date utilDate = new java.util.Date(nCurrentTime);
//以下是用于数据库操作的日期和时间类
java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime()); //java.util.Date和java.sql.Date的转换
java.sql.Time sqlTime = new java.sql.Time(utilDate.getTime());
java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(nCurrentTime);
//Calendar用于获取指定的时间项（字段）
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(nCurrentTime);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1; //注意：返回的月份是基于0的！
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
System.out.println("Current date is: " + year + "年" + month + "月" + day + "日");
System.out.println("Current time is: " + hour + "时" + minute + "分" + second + "秒");
//SimpleDateFormat用于格式化日期和时间
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String szDatetime1 = df.format(utilDate);
System.out.println("Current datetime is: " + szDatetime1);
//以下计算两个日期值之间相差的时间
java.util.Date date2 = new java.util.Date(nCurrentTime - 24600 * 1000);
long nMilliSeconds = utilDate.getTime() - date2.getTime();
long nSeconds = nMilliSeconds / 1000; //把毫秒换算成秒
double nDays = nSeconds / (24d * 60d * 60d); //把秒换算成天
String szDatetime2 = df.format(date2);
System.out.println("Time between " + szDatetime1 + " and " + szDatetime2 + " is " + nSeconds + " seconds (" + nDays + " days)");
}
}
Date实用例程
作者： 黄纯峰 来源：www.javajia.com 发布时间：Mon May 22 03:56:48 CST 2006
日期的获取与转换
import java.util.*;
import java.text.*;
import org.apache.log4j.*;
public class DateUtil{
private static Logger log4j = Logger.getLogger(DateUtil.class);
public DateUtil(){
}
public static Date parse(String dateString,String dateFormat){
try{
return new SimpleDateFormat(dateFormat).parse(dateString);
}
catch (ParseException ex){
return null;
}
}
public static String format(Calendar calendar,String dateFormat){
return new SimpleDateFormat(dateFormat).format(calendar.getTime());
}
public static String format(Date date,String dateFormat){
return new SimpleDateFormat(dateFormat).format(date);
}
/**
* util.Date转换sql.Date
* @param date: java.util.Date
* @return 返回java.sql.Date
*/
public static java.sql.Date sqlDate(Date date){
java.sql.Date sqlDate=null;
sqlDate=new java.sql.Date(date.getTime());
return sqlDate;
}
/**
* sql.Date转换util.Date
* @param date: java.sql.Date
* @return 返回java.util.Date
*/
public static java.util.Date utilDate(java.sql.Date date){
java.util.Date utilDate=null;
//utilDate= new java.util.Date(date.getTime());
utilDate=parse(format(date),"yyyy-MM-dd HH:mm");
return utilDate;
}
/**
* java.sql.Date转换称String型
* @param sqlDate
* @return
*/
public static String format(java.sql.Date sqlDate){
return sqlDate.toString();
}
/**
* 获取当前的系统日期
* @param dateFormat
* @return 返回字符串
*/
public static String nowDate(String dateFormat){
return new SimpleDateFormat(dateFormat).format(new Date());
}
/**
public static Date toDate(Calendar calendar){
return calendar==null?null:calendar.getTime();
}
public static Calendar toCalendar(Date date){
Calendar cl = null;
if ( date!=null){
cl.getInstance();
cl.setTime(date);
}
return cl;
}
*/
/**
* 日期比较大小
* @param date1
* @param date2
* @return 返回比较结果
* =0 date1=date2;
* >0 date1>date2;
* <0 date1<date2;
*/
public static int dateCompare(Date date1,Date date2){
return date1.compareTo(date2);
}
/***
* 日期型转换成字符串，固定日期格式为getDateFormat()
*/
//把一个java.sql.Date类型的时间转换成一个格式化的字符串，以为getDateFormat()时间格式
//出库时使用，从数据库中出来到界面，从数据库中读出时，调用。
public static String afterOpenCheck(java.sql.Timestamp date){
if(date==null)
return "";
log4j.debug("begin afterOpenCheck");
String ret=format(date,getDateFormat());
if(ret.equals(getStrNullDate()))
ret="";
log4j.debug("end afterOpenCheck:date="+ret);
return ret;
}
//时间保存前的检验2004-05-06 12:30
public static java.sql.Timestamp beforeSaveCheck(String strDate){
log4j.debug("时间保存前的检验");
if(strDate==null){
return null;
}
if(strDate.length()==0){
return null;
} //utilDate= new java.util.Date(date.getTime());
log4j.debug("时间保存前的检验的值:"+strDate);
Date temp=parse(strDate,getDateFormat());
java.sql.Timestamp ret=new java.sql.Timestamp (temp.getTime());
log4j.debug("时间保存前的检验,返回值:"+ret);
//java.sql.Timestamp temp=new java.sql.Timestamp();
return ret;
}
//返回系统默认空时间的表示时间
public static String getNullSqlDateFormat(){
return "";
}
public static String getStrNullDate(){
return "";
}
//返回系统使用的默认时间格式
public static String getDateFormat(){
return "yyyy-MM-dd HH:mm";
}
//返回系统使用的时间格式oracle sql语句
public static String getSqlDateFormat(){
return "yyyy-MM-dd HH24:mi";
}
//返回系统默认格式的当前时间
public static String nowDate(){
return nowDate(getDateFormat());
}
/**
* 获取某一日期的前后N天的日期
* @param sDate
* @param n
* @param dateFormat
* @return
*/
public static String getNewDateByDay(String sDate,int n,String dateFormat) {
SimpleDateFormat df=new SimpleDateFormat(dateFormat);
Calendar calendar=Calendar.getInstance();
calendar.setTime(parse(sDate,dateFormat));
calendar.add(Calendar.DAY_OF_WEEK,n);
return df.format(calendar.getTime());
}
}
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
