java处理timestamp以及和date转换关系的总结

Java中Date及Timestamp时间相关内容（基本上看这一份就可以了）java.util.date java.sql.date java.sql.timestamp

整理一：

这里的一片文章，我个人认为讲解的很详细，有对 java.sql.Date的使用还有困惑的请看。

java.sql.Date 只存储日期数据不存储时间数据

// 会丢失时间数据

preparedStatement.setDate(1, new java.sql.Date(date.getTime()));

//可以这样来处理

preparedStatement.setTimestamp(1, new java.sql.Timestamp(new

java.util.Date().getTime()));

//想要得到完整的数据，包括日期和时间，可以这样

java.util.Date d = resultSet.getTimestamp(1);

//这样处理更合适一些，可以避免一些潜在Timestamp 问题

java.util.Date d = new

java.util.Date(resultSet.getTimestamp(1).getTime());

自己补的话

这样的话：

往数据库存储的时候可以接收 java.util.Date类型再用getTime()

方法得到代表那个Date对象的long值，再以这个long值构造一个Timestamp 对象存进数据库中。

从存数据库里取的时候，可以先得到Timestamp用他的getTime()方法得到long值，再以这个long值构造一个 java.util.Date对象，这样就可以对这个Date对象操作了。不如说 new SimpleTimeFormat("yyyyy-MM-dd

HH:mm:ss").format()等等

整理二：

用Timestamp来记录日期时间还是很方便的，但有时候显示的时候是不需要小数位后面的毫秒的，这样就需要在转换为String时重新定义格式。

Timestamp转化为String:SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//定义格式，不显示毫秒Timestamp now = new Timestamp(System.currentTimeMillis());//获取系统当前时间 String str = df.format(now); String转化为Timestamp: SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String time = df.format(new Date()); Timestamp ts =

Timestamp.valueOf(time);

整理三：在 ResultSet中我们经常使用的setDate或getDate的数据类型是java.sql.Date，而在平时java程序中我们一般习惯使用 java.util.Date。因此在DAO层我们经常会碰到这俩种数据类型的相互转换，经过了一个下午的折腾，鄙人对两者的转换方法做出了小小总结，希望大家不吝指教。

两者的关系

https://www.360docs.net/doc/7d14040151.html,ng.Object

|

+---java.util.Date

|

+----java.sql.Date

从这个图中我们可以知道java.sql.Date是从java.util.Date继承过来的。

相互转换

1. 使用getTime()函数

这两个类都提供了getTime()函数，用于返回对应的毫秒数（long类型）。利用这个函数可以实现转换：

java.util.Date utilDate = new

java.util.Date(sqlDate.getTime()); // sql -> util

java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime()); // util -> sql

2. 使用SimpleDateFormat类实现转换

SimpleDateFormat 是一个以国别敏感的方式格式化和分析数据的具体类。它允许格式化 (date -> text)、语法分析 (text -> date)和标准化。SimpleDateFormat dateFormat = new SimpleDateFormate("yyyy-MM-dd

HH:mm:ss");

java.util.Date utilDate = dateFormat.parse(sqlDate.toString());

3. 直接转换

由于java.sql.Date是从java.util.Date中继承过来的，所以可以直接用：utilDate = sqlDate;

4. 另类获得日期的方法：

SimpleDateFormat sy=new SimpleDateFormat("yyyy");

SimpleDateFormat sm=new SimpleDateFormat("MM");

SimpleDateFormat sd=new SimpleDateFormat("dd");

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);

ps： java.util.Date类中的getYear()要加上1900才可得到实际值，getMonth()则要加上1

有关java中的Date,String,Timestamp之间的转化问题

一.获取系统当前时间:

1．System.out.println(new Timestamp(new java.util.Date().getTime)); //包含时分

秒

2．System.out.println(new java.sql.Date(new java.util.Date().getTime)); //不包含时分秒

3.通过格式化类获取任意格式的时间

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss SSS"); String time = sdf.format(Calendar.getInstance().getTime());

System.out.println(time);

sql包的Date类没有无参的构造函数，而util的Date类有无参的构造函数java.util.Date date = new java.util.Date();是正确的 //Tue Jun 15

09:04:23 CST 2010

java.sql.Date date = new java.sql.Date();是错误的

但是sql包的Date有一个带long型参数的构造函数，因此可以使用以下方式

java.sql.Date date = new java.sql.Date(new

java.util.Date().getTime()); //2010-6-17

new java.util.Date():构造函数没有接受任何参数. 而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期. 下面是util包的Date的构造方法:

public Date() { this(System.currentTimeMillis()); }

还发现一件怪异的事情:

// String转化成date String str = "9-29-2001";

System.out.println(java.sql.Date.valueOf(str));

输出:

0016-10-21

真是奇怪.

三. Date转化成String

//Date转化成String: SimpleDateFormat sdf = new

SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(sdf.format(new Date()));

输出:

2010-06-17 16:30:21 781

四. Timestamp转化成String

SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//定义格式，不显示毫秒

Timestamp now = new Timestamp(System.currentTimeMillis());//获取系统当前时间

String str = df.format(now);

System.out.println(str);

输出:

2010-06-17 16:46:34

五. String转化成Timestamp

SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); java.util.Date date11 = df1.parse("2010-6-2 16:10:38.00");

String time = df1.format(date11);

Timestamp ts = Timestamp.valueOf(time);

System.out.println(ts);

输出:

2010-06-02 16:10:38.0

引用

还发现一件怪异的事情:

// String转化成date String str = "9-29-2001";

System.out.println(java.sql.Date.valueOf(str));

Date#valueOf(String)的String格式都是yyyy-mm-dd.

引用

五. String转化成Timestamp

SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); java.util.Date date11 = df1.parse("2010-6-2 16:10:38.00");

String time = df1.format(date11);

Timestamp ts = Timestamp.valueOf(time);

System.out.println(ts);

这样的构造是没有效率的，Timestamp 是 java.util.Date的子类，可以这么做：new Timestamp(java.util.Date#getTime());

段箭*残箫写道

还发现一件怪异的事情:

// String转化成date String str = "9-29-2001";

System.out.println(java.sql.Date.valueOf(str));

输出:

0016-10-21

真是奇怪.

你从公元 9年1月1日算起,加上2001天,和29个月,时间就是公元 16年10月21日

Timestamp是由java.util.Date和单独的毫微秒值组成。只有整数秒才会存储在java.util.Date组件中。小数秒（毫微秒）是独立存在的。传递java.util.Date类型的值时，Timestamp.equals(Object)方法永远不会返回true，因为日期的毫微秒组件是未知的。鉴于Timestamp类和上述java.util.Date类之间的不同，建议代码一般不要将Timestamp值视为java.util.Date的实例。Timestamp和

java.util.Date之间的继承关系实际上指的是实现继承，而不是类型继承。

Timestamp的解释1：

timestamp 这个类的构造函数是

Java代码

1.Timestamp(Date timestamp, CertPath signerCertPath)

date对象是不需要制定格式的。。。我不明白有什么地方需要用到这个类，你完全可以通过long来表示时间。。。

虽然不理解你的做法，但是如果你要yyyy-mm-dd hh:mm:ss

Java代码

1.Date d1 = new Date();

2.SimpleDateFormat smf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"

);

3.String s1=smf.format(d1);

4.System.out.println(s1);

beneo (架构师) 2010-12-31

呵，兄弟，你描述得真的是很难理解：

1、timestamp到底是指数据库的字段类型，还是java中的java.sql.Timestamp 类

2、如果你是指数据库查询的比较的话, 跟""、null这种值比较是没问题的

3、

构造函数1：

// 已不建议使用

@Deprecated

public Timestamp(int year, int month, int date,

int hour, int minute, int second, int nano)

构造函数2:

// time时间对应的毫秒数

public Timestamp(long time)

如：Timestamp ts = new Timestamp(1293804215328);

4、如果说构建Timestamp对象的话，那么格式有限制的只有这方法了Timestamp ts1 = Timestamp.valueOf("2010-12-31 22:22:22"); Timestamp ts2 = Timestamp.valueOf("2010-12-31 22:22:22.23");

格式必须为：yyyy-mm-dd hh:mm:ss[.f...]

解释2：

一般在页面通过时间查询的时候，在后台获取到的值为字符串，要设置到Date或Timestamp 对象中时，需要将时间字符串转化为对象。

Java代码

1.import java.sql.Timestamp;

2.import java.text.DateFormat;

3.import java.text.ParseException;

4.import java.text.SimpleDateFormat;

5.import java.util.Date;

6.

7./**

8. *

9. */

10.

11./**

12. * @author qiuzj

13. *

14. */

15.public class Test {

16.

17. /**

18. * @param args

19. * @throws ParseException

20. */

21. public static void main(String[] args) throws ParseExceptio

n {

22. // 日期时间格式

23. DateFormat datetimeDf = new SimpleDateFormat("yyyy-MM-d

d HH:mm:ss");

24.

25. // 假设这个是从前台查询传过来的时间字符串

26. String dateStr = "2010-12-31 22:22:22";

27.

28. // 根据日期时间格式将时间字符串转化为对象

29. Timestamp ts = Timestamp.valueOf(dateStr);

30. Date date = datetimeDf.parse(dateStr);

31.

32.

33. // 日期

34. DateFormat dateDf = new SimpleDateFormat("yyyy-MM-dd");

35.

36. // 日期字符串

37. dateStr = "2010-12-31";

38.

39. // 根据日期格式将时间字符串转化为对象

40. date = dateDf.parse(dateStr);

41. ts = new Timestamp(date.getTime());

42.

43. }

44.

45.}

解释4：

应该仔细的阅读api的，你看在java.sql.Timestamp有个long型的构造函数Timestamp(long)，这样的话你可以输入long型的变量，long型的构造请参阅Calendar

此外，将使用 JDBC 时间戳转义格式的 String 对象转换为 Timestamp 值的话，你可以使用Timestamp#valueOf(String)

输入的字符串可以是二者之一，对应不同的精度：

* yyyy-mm-dd hh:mm:ss 格式下的字符数

* yyyy-mm-dd hh:mm:ss.[fff...] 格式下的字符数（fff表示纳秒）

以上，是回答你的问题，以下是推荐给你的

一般来说，我们可以通过js直接生成yyyy-mm-dd hh:mm:ss的字符串的，因为js的时间，我们都是通过日历点出来的，一般都有年月日还有小时分秒，你可以参考以下链接

https://www.360docs.net/doc/7d14040151.html,/yank/archive/2008/08/14/1267746.html

https://www.360docs.net/doc/7d14040151.html,/projects/calendar/

https://www.360docs.net/doc/7d14040151.html,/blodfox777/archive/2008/08/13/1266639.html

没有显示小时分秒的多试试几个

beneo (架构师) 2011-01-01

Java代码

1.public void doPost(HttpServletRequest request, HttpServletRespo

nse response)

2. throws ServletException, IOException {

3.

4. Timestamp timeUseForSearchInDatabase = null;

5.

6. //假设你前台传来的用于查询的时间字符串名称为

searchDate

7. String searchDate = request.getParameter("searchDate");

8. //假设你前台传入的日期格式为

2010-08-05 11:20:12(yyyy-MM-dd HH:mm:ss)

9. if (null != searchDate && !"".equals(searchDate)) {

10. try {

11. timeUseForSearchInDatabase = new Timestamp(new

SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(searchDate).getTi me());

12. } catch (ParseException e) {

13. e.printStackTrace();

14. }

15. }

16.

17. //这时timeUseForSearchInDatabase就可以直接放到

Hibernate的实体对应字段中去了

18. //其实，hibernate中对应数据库中的DateTime类型，实体中

可以采用java.util.Date类型，

19. //另外，Hibernate中的timestamp类型的字段是可以为null

的，但不能为"";其实""你也注入不进去，因为""是字符串类型的，你所说的前台页面表单中

20. //什么也不输时报错，是因为页面中的任何表单不输入内容，传

到后台的值将都是字符串""，而不是null，这个你要处理的，你要将""

转换成null,

21. //你用了SSH，可以使用Struts的过滤器自动过滤，但也可以

使用我上面这种方法（虽然有点笨，有点烦，但还是比较实用的）。

22.

23. /**

24. * 下面向你介绍一下我对日期类型的处理办法：

25. * 1、页面前台：①、使用日期控件，直接限制用户的输入日期

格式(html页面中的日期输入控件有很多，我常用My97DatePicker，简介方便)，这样前台用户输入的

26. * 日期要么是空字符串""，要么是我们预设好的日期格

式，传到后台后按照规则解析处理即可。②、使用js的验证功能强行用户输入指定格式的日期

27. * 2、业务逻辑层：使用我上面这中方法进行转换处理，将空字

符串""转换成null，将正确的日期字符串转换成对应的日期对象再使

用。

28. * 3、保存：①、使用Hibernate的实体直接保存，将转换成的

日期对象直接方法实体中即可(强调一下:日期字段是null是可以的，但""肯定不行)

29. * ②、使用Hql保存，也可直接将刚转换成的日期对

象作为参数传入hql

30. * ③、使用sql，sql中的日期是可以直接使用字符串

来保存的，所以不必转换，也可使用sql参入注入的方法注入到sql中后执行。

31. *

32. *

33. * 当然从数据库中取出数据用于前台展示，将是上面过程的逆

过程，首先取出数据，此时是一个日期对象，要使用SimpleDateFormat 进行格式化，转换成字符串传到

34. * 前台进行显示(如果是jsp页面可以在页面中处理，如果使用

Struts技术，可以使用Struts的标签技术，如果是使用像Ext、

Jquery Easy UI则在使用JSONObject

35. * 将数据格式化成json字符串时，为JSONObject格式化写一

个专门针对日期类型的处理器，那么在JSONObject进行格式化时，会自动按照处理器的要求将日期格式化成

36. * 你想要的字符串格式(比如：yyyy-MM-dd、

yyyy-MM-dd HH:mm:ss等等，你要做的就是为JSONObject格式化处理器传入一个日期格式表达式即可))

37. *

38. *

39. * 写的有点多了，偏了点题，不知是否能解决你的问

题！！！！！！！！！？？？？？？？？？？？？？？？？？

40. */

41. }

解释5：

数所库字段是DateTime类型，对应的是java.util.Date或java.sql.Date，java.sql.Timestamp对应的数据库类型是Timestamp。

java.util.Date或java.sql.Date是精确到毫秒的，某些数据库用Date来表示日期（精确到天）、用DateTime来表示日期和时间（精确到毫秒），如Oracle 则只有Date（精确到毫秒）。

java.sql.Timestamp是精确到纳秒的，对应数据库的Timestamp类型。

考虑到你用的是Struts，换回Date应该没问题了。

oracle 如何保存timestamp

保存时间戳问题

oracle 如何保存timestamp:

表字段设置成 TIMESTAMP类型就好了吧。

至于怎么生成 TIMESTAMP的值。这不是问题吧

oracle的timestamp类型使用

我们都知道date和timestamp都是对日期和时间的表示，只是两种类型的精确度不同，前者精确到秒，后者精确到小数秒（fractional_seconds_precision），可以是0 to 9，缺省是６。

但是对date类型的运算很简单，有很多函数可用来处理；而两个timestamp的差则是很直观地显示为多少天＋多少小时＋多少分钟＋多少秒＋多少小数秒，

SQL> create table test (T1 TIMESTAMP(6),

2 T2 TIMESTAMP(6));

表已创建。

SQL> insert into test values(

2 to_timestamp('2006-01-01 12:10:10.1','yyyy-mm-dd hh24:mi:ss.ff'),

3 to_timestamp('2006-01-01 12:20:10.2','yyyy-mm-dd hh24:mi:ss.ff'));

已创建1 行。

SQL>

SQL> insert into test values(

2 to_timestamp('2006-01-01 12:10:10.1','yyyy-mm-dd hh24:mi:ss.ff'),

3 to_timestamp('2006-01-02 12:20:10.2','yyyy-mm-dd hh24:mi:ss.ff'));

已创建1 行。

SQL>

SQL> insert into test values(

2 to_timestamp('2006-01-01 12:10:10.1','yyyy-mm-dd hh24:mi:ss.ff'),

3 to_timestamp('2006-01-02 13:40:20.2','yyyy-mm-dd hh24:mi:ss.ff'));

已创建1 行。

SQL> commit;

提交完成。

SQL>

两个timestamp的差则是很直观地显示为多少天＋多少小时＋多少分钟＋多少秒＋多少小数秒：

SQL> select t2-t1 from test;

+000000000 00:10:00.100000

+000000001 00:10:00.100000

+000000001 01:30:10.100000

SQL>

但要简单地转化为某一个精度却比较麻烦，用类似date类型的处理方法是不行的。如转化为分：

SQL> select 1440*(t2-t1) from test;

+000000010 00:02:24.000000000

+000001450 00:02:24.000000000

+000001530 04:02:24.000000000

SQL>

发现结果根本不是原先想要的，而是在原先的“多少天＋多少小时＋多少分钟＋多少秒＋多少小数秒”的每一项都乘以１４４０再进行进制处理。

最容易理解的就是用substr将两个timestamp的差进行分割转化处理：

SQL> SELECT substr((t2-t1),instr((t2-t1),' ')+7,2)

seconds,

2 substr((t2-t1),instr((t2-t1),' ')+4,2)minutes,

3 substr((t2-t1),instr((t2-t1),' ')+1,2)hours,

4 trunc(to_number(substr((t2-t1),1,instr(t2-t1,' '))))days,

5 trunc(to_number(substr((t2-t1),1,instr(t2-t1,' ')))/7) weeks

6 FROM test;

SECO MINU HOUR DAYS WEEKS

---- ---- ---- ---------- ----------

00 10 00 0 0

00 10 00 1 0

10 30 01 1 0

或者利用自定义函数来实现将天数转换成“天时分秒”格式：

CREATE OR REPLACE FUNCTION F_DAYS2STR(P_DAYS IN NUMBER DEFAULT 0)

RETURN VARCHAR2 IS

--Ver:1.0

--Created by xsb on 2005-05-26

--For: 将天数转换成天时分秒格式

DAYS NUMBER := NVL(P_DAYS, 0);

VD NUMBER; --天

VH NUMBER; --小时

VM NUMBER; --分

VS NUMBER; --秒

RESULT VARCHAR2(100); --返回值

BEGIN

VD := TRUNC(DAYS);

VH := TRUNC((DAYS - VD) * 24);

VM := TRUNC((DAYS - VD - VH / 24) * 24 * 60);

VS := TRUNC((DAYS - VD - VH / 24 - VM / 24 / 60) * 24 * 60 * 60);

SELECT DECODE(VD, 0, '', VD || '天') || DECODE(VH, 0, '', VH || '小时') ||DECODE(VM, 0, '', VM || '分') || DECODE(VS, 0, '', VS || '秒') INTO RESULT FROM DUAL;

RETURN(RESULT);

END;

SQL>

如果最后结果的精度要求不高时（在分或分以上时），就可以先将timestamp

转化为date再结算，这样就简单多了：

SQL> select (to_date(to_char(t2,'yyyy-mm-dd hh24:mi:ss'),'yyyy-mm-dd

hh24:mi:ss'

)-to_date(to_char(t1,'yyyy-mm-dd hh24:mi:ss'),'yyyy-mm-dd

hh24:mi:ss'))*24*60

2 from test;

10

1450

1530.16667

date转换为timestamp：

SELECT CAST(sysdate AS TIMESTAMP) from dual;