java中对日期的操作：DATE，DateFormat，SimpleDateFormat的方法的使用

import java.text.*; //导入包
import java.util.*; //导入包
{
/**
*获取当前时间

 * @author  【轰隆隆】

*不熟悉的朋友看看API和下面的实例就会慢慢明白使用方法了
*/
public static void main(String[] args)
{  

  System.out.println("01："+new Date());
  
  System.out.println("02："+new Date().toLocaleString()); //过期！最简单，但是不推荐使用
  
  
  System.out.println("03："+DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(new Date()));
  
  System.out.println("04："+DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM).format(new Date()));
  
  System.out.println("05："+DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG).format(new Date()));
  
  System.out.println("06："+DateFormat.getDateInstance(DateFormat.FULL).format(new Date()));
  
  System.out.println("07："+DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL).format(new Date()));
  

  
//    y,yy:用2位数字表示的"年"替换。
//    yyyy:用4位数字表示的"年"替换。
//    M,MM:用2位数字表示的"月"替换。
//    MMM:用汉字表示的"月"替换。
//    d,dd:用2位数字表示的"日"替换。
//    H,HH:用2位数字表示的"时"替换。
//    m,mm:用2位数字表示的"分"替换。
//    s,ss:用2位数字表示的"秒"替换。
//    E:用"星期"替换
//   pattern中的普通ASCII字符，必须用单引号“'”字符括起来，如：
//    pattern="'time':yyyy-MM-dd";
//
//   用SimpleDateFormat对象调用如下方法可以定制某时间输出格式：
//   实例：
   SimpleDateFormat sdf = new SimpleDateFormat("'中华人民共和国时间':yyyy年MM月dd日 HH点mm分ss秒 E",Locale.CHINA);
   System.out.println("08："+sdf.format(new Date()));

  System.out.println("09："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E").format(new Date()));  //这种方式比较灵活，格式完全可以自己定
  
    
  Calendar obj=Calendar.getInstance();
  System.out.println("10："+
             
              obj.get(Calendar.YEAR)+"年"+
             (obj.get(Calendar.MONTH)+1)+"月"+   //一月用0表示，所以得到的月份要加1，
              obj.get(Calendar.DATE)+"日"+
              obj.get(Calendar.HOUR_OF_DAY)+"时"+
              obj.get(Calendar.MINUTE)+"分"+
              obj.get(Calendar.SECOND)+"秒"
      );
  System.out.print("11："+obj.getTime());

  obj.add(Calendar.MINUTE,30);
  System.out.println(" → 再过30分钟时刻："+obj.getTime());

}
}

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

执行结果：

01：Thu Aug 06 18:55:30 CST 2009
02：2009-8-6 18:55:30
03：09-8-6 下午6:55
04：2009-8-6 18:55:30
05：2009年8月6日 下午06时55分30秒
06：2009年8月6日 星期四
07：2009年8月6日 星期四 下午06时55分30秒 CST
08：中华人民共和国时间:2009年08月06日 18点55分30秒 星期四
09：2009-08-06 18:55:30 星期四
10：2009年8月6日18时55分30秒
11：Thu Aug 06 18:55:30 CST 2009 → 再过30分钟时刻：Thu Aug 06 19:25:30 CST 2009

扫描二维码关注公众号，回复： 802105 查看本文章

******************************************************************************************

 

 

在Java中最常用的日期时间操作类有四个：

java.util.Date
java.sql.Date
java.sql.Time
java.sql.Timestamp

为了精确表达业务逻辑，应尽量避免使用父类（java.util.Date）的方法。java.sql包下的三个子类中特有的valueOf()静态方法与toString()方法可以精确表达业务逻辑。

系统时间与本地时间

在中国地区，如果调用以下代码，我们会得到“1970-01-01 08:00:00”的结果

1. // 例1   
2. java.util.Date obj1 = new java.util.Date(0L);   
3. DateFormat dateFormat =    
4.     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");   
5. System.out.println(dateFormat.format(obj1));   
6. // 打印结果：1970-01-01 08:00:00  

 

看了JDK API之后，您可能会有这样的疑问，为什么 new java.util.Date(0L) 得到的时间不是“1970-01-01 00:00:00”而是“1970-01-01 08:00:00”呢？难到JDK API写错了？
JDK API没有错，关键是创建java.util.Date对象所使用的毫秒数是计算机系统时间，该毫秒数指的是自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数，即格林尼治标准时间（GMT）的1970-01-01 00:00:00。但是当计算机以字符串方式展示给我们看的时候，这个时间已经成为本地时间了，例如中国地区使用GMT+8时区，所以我们看到的是“1970-01-01 08:00:00”的结果！
将上述代码修改一下，我们就可以得到一个更清晰的概念。如：

1. // 例2   
2. java.util.Date obj1 = new java.util.Date(0L);   
3. DateFormat dateFormat =    
4.     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss 'GMT'Z");   
5. System.out.println(dateFormat.format(obj1));   
6. // 打印结果：1970-01-01 08:00:00 GMT+0800  

 

上面的代码我们可以看到“1970-01-01 08:00:00 GMT+0800”的结果，证明我们所处的时区在GMT+8区。当我们改变时区时，相同的系统时间将显示不同的结果。如：

1. // 例3   
2. java.util.Date obj1 = new java.util.Date(0L);   
3. TimeZone.setDefault(TimeZone.getTimeZone("GMT+0:00"));   
4. DateFormat dateFormat =    
5.     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss 'GMT'Z");   
6. System.out.println(dateFormat.format(obj1));   
7. // 打印结果：1970-01-01 00:00:00 GMT+0000  

 

上面的代码我们可以看到“1970-01-01 00:00:00 GMT+0000”的结果，证明现在所处的时区在GMT+0区。 

总之，通过以上的描述，我们可以得出这样几个结论：

1. 所有计算机的系统时间概念上是统一的；
2. 相同的系统时间会根据不同的时区产生不同的本地时间；
3. 当时区为GMT+0时，系统时间与本地时间相同。

精确的业务逻辑

在Java中最常用的日期时间操作类中java.util.Date是其它三个类的父类。因为有这样的继承关系，所有四个类均可以通过系统时间生成对象。例如： 

java.util.Date obj = new java.sql.Date(0L);

这种使用系统时间作为数据产生的日时对象在业务逻辑上可能存在问题。例如在时区GMT+0环境下运行如下代码：

1. // 例4   
2. // 将时区设置为GMT+0   
3. TimeZone.setDefault(TimeZone.getTimeZone("GMT+0:00"));   
4.   
5. // 使用传统构造方法生成日时对象   
6. java.util.Date obj1 = new java.sql.Date(0L);   
7. java.util.Date obj2 = new java.sql.Date(3600000L);   
8.   
9. // 业务逻辑相同   
10. System.out.println(obj1.toString()); // "1970-01-01"   
11. System.out.println(obj2.toString()); // "1970-01-01"   
12.   
13. // 语法比较不相同   
14. System.out.println(obj1.equals(obj2)); // false   
15. System.out.println(obj1.compareTo(obj2)); // -1  
    

上述代码产生的两个对象在业务逻辑上都表示格林尼治标准时间1970-01-01(00:00:00)，但在语法上二者时间却相差1小时。出现这种现象的根本原因在于使用了不精确的系统时间来反映日时对象的业务逻辑。

所谓日时对象的业务逻辑，就是以本地时间作为标准的日时信息。例如描述格林尼治标准时间（GMT+0）1970-01-01 00:00:00的精确系统时间是0L毫秒；描述北京时间（GMT+8）1970-01-01 00:00:00的精确系统时间则是-28800000L毫秒。

除java.util.Date外，其它三个类均有属于自己的业务范围，例如：
java.sql.Date的有效成份包括年、月、日
java.sql.Time的有效成份包括时、分、秒
java.sql.Timestamp的有效成份包括年、月、日、时、分、秒、纳秒（毫微秒）
由于四种日时对象内部均使用细化到毫秒的系统时间作为标准数据，势必会造成使用不同的系统时间可以表达相同业务逻辑的现象。那么通过什么方式可以将一个不精确的系统时间转换成能够准确表达业务逻辑的精确系统时间呢？

1. 使用toString()来获得日时对象的业务逻辑
在继承自java.util.Date的三个子类中，传统的构造方法以及getTime()和setTime()两个方法均使用系统时间来实现，也就注定了它们在业务逻辑上的不精确性。如果已经使用了不精确的系统时间创建java.sql包中的日时对象，则toString()是唯一个可以获取精确业务逻辑的方法。例4的代码可以说明这一点。

2. 使用valueOf()构造精确的日时对象
为了能够从本质上使用精确系统时间来准确表达日时对象中的业务逻辑，除java.util.Date外，其它三个类均提供了第二个生成对象的方法，那就是valueOf()静态方法。例如：

java.util.Date obj1 = java.sql.Date.valueOf("2000-01-01");

通过传递一个准确表达日时信息的字符串，valueOf()将产生一个由精确系统时间构成的可以反映准确业务逻辑的日时对象。同样，这种精确的日时对象也可以在语法上进行精确的比较判断，例如：

1. // 例5   
2. // 使用valueOf()生成日时对象   
3. java.util.Date obj1 = java.sql.Date.valueOf("2000-01-01");   
4. // 使用精确系统时间生成日时对象   
5. java.util.Date obj2 = new java.sql.Date(obj1.getTime());   
6.   
7. // 业务逻辑准确   
8. System.out.println(obj1.toString()); // "2000-01-01"   
9. System.out.println(obj2.toString()); // "2000-01-01"   
10.   
11. // 语法比较准确   
12. System.out.println(obj1.equals(obj2)); // true   
13. System.out.println(obj1.compareTo(obj2)); // 0  

 

通过对valueOf()和toString()的了解，我们自然会想到一种转换方式，可以将不精确的系统时间转换成可以准确表达业务逻辑的精确系统时间。如下面的工具类：

1. public class DateTimeUtils {   
2.     /**  
3.      * 取得可以精确表达业务逻辑的日时对象  
4.      *   
5.      * @param obj  
6.      *            不精确的日时对象  
7.      * @return 精确的日时对象  
8.      */  
9.     public static java.sql.Date getLocalDate(java.util.Date obj) {   
10.         if (obj == null)   
11.             return null;   
12.   
13.         java.sql.Date tmp = null;   
14.         if (java.sql.Date.class.equals(obj.getClass())) {   
15.             // 如果原始日时对象的类型是java.sql.Date   
16.             // 则转换过程分两步：   
17.             // 第一步，取得java.sql.Date对象的精确业务逻辑值   
18.             String tmpString = obj.toString();   
19.             // 第二步，生成能够精确反映业务逻辑的日时对象   
20.             tmp = java.sql.Date.valueOf(tmpString);   
21.         } else {   
22.             // 如果原始日时对象的类型不是java.sql.Date   
23.             // 则转换过程分三步：   
24.             // 第一步，生成一个不能精确表达业务逻辑的java.sql.Date对象   
25.             obj = new java.sql.Date(obj.getTime());   
26.             // 第二步和第三步与处理java.sql.Date类型的原始日时对象相同   
27.             // 第二步，取得java.sql.Date对象的精确业务逻辑值   
28.             String tmpString = obj.toString();   
29.             // 第三步，生成能够精确反映业务逻辑的日时对象   
30.             tmp = java.sql.Date.valueOf(tmpString);   
31.         }   
32.         return tmp;   
33.     }   
34. }  

 

上述方法可以简化为：

1. public static java.sql.Date getLocalDate(java.util.Date obj) {   
2.     if (obj == null)   
3.         return null;   
4.   
5.     java.sql.Date tmp = null;   
6.     if (java.sql.Date.class.equals(obj.getClass())) {   
7.         tmp = java.sql.Date.valueOf(obj.toString());   
8.     } else {   
9.         tmp = getLocalDate(new java.sql.Date(obj.getTime()));   
10.     }   
11.     return tmp;   
12. }  

 

根据相同道理，也可以得到转换java.sql.Time与java.sql.Timestamp日时对象的方法。最后的版本如下：

1. public class DateTimeUtils {   
2.     /**  
3.      * 取得可以精确表达业务逻辑的日期对象<br>  
4.      *   
5.      * 如果原始日时对象的类型是java.sql.Date <br>  
6.      * 则转换过程分两步：<br>  
7.      * 第一步，取得java.sql.Date对象的精确业务逻辑值 <br>  
8.      * 第二步，生成能够精确反映业务逻辑的日时对象<br>  
9.      *   
10.      * 如果原始日时对象的类型不是java.sql.Date<br>  
11.      * 则转换过程分三步：<br>  
12.      * 第一步，生成一个不能精确表达业务逻辑的java.sql.Date对象<br>  
13.      * 第二步和第三步与处理java.sql.Date类型的原始日时对象相同  
14.      *   
15.      * @param obj  
16.      *            不精确的日期对象  
17.      * @return 精确的日时对象  
18.      */  
19.     public static java.sql.Date getLocalDate(java.util.Date obj) {   
20.         if (obj == null)   
21.             return null;   
22.   
23.         java.sql.Date tmp = null;   
24.         if (java.sql.Date.class.equals(obj.getClass())) {   
25.             tmp = java.sql.Date.valueOf(obj.toString());   
26.         } else {   
27.             tmp = getLocalDate(new java.sql.Date(obj.getTime()));   
28.         }   
29.         return tmp;   
30.     }   
31.   
32.     public static java.sql.Time getLocalTime(java.util.Date obj) {   
33.         if (obj == null)   
34.             return null;   
35.   
36.         java.sql.Time tmp = null;   
37.         if (java.sql.Time.class.equals(obj.getClass())) {   
38.             tmp = java.sql.Time.valueOf(obj.toString());   
39.         } else {   
40.             tmp = getLocalTime(new java.sql.Time(obj.getTime()));   
41.         }   
42.         return tmp;   
43.     }   
44.   
45.     public static java.sql.Timestamp getLocalTimestamp(java.util.Date obj) {   
46.         if (obj == null)   
47.             return null;   
48.   
49.         java.sql.Timestamp tmp = null;   
50.         if (java.sql.Timestamp.class.equals(obj.getClass())) {   
51.             tmp = java.sql.Timestamp.valueOf(obj.toString());   
52.         } else {   
53.             tmp = getLocalTimestamp(new java.sql.Timestamp(obj.getTime()));   
54.         }   
55.         return tmp;   
56.     }   
57. }  

 

我们可以这样使用：

1. TimeZone.setDefault(TimeZone.getTimeZone("GMT+8:00"));   
2. // 使用三种方法产生的日时对象   
3. java.util.Date obj1 = java.sql.Date.valueOf("1970-01-01");   
4. java.util.Date obj2 = new java.util.Date(0L);   
5. java.util.Date obj3 = new java.sql.Date(0L);   
6.   
7. // 通过相同的方式转换   
8. obj1 = DateTimeUtils.getLocalDate(obj1);   
9. obj2 = DateTimeUtils.getLocalDate(obj2);   
10. obj3 = DateTimeUtils.getLocalDate(obj3);   
11.   
12. // 得到了相同的精确业务逻辑   
13. System.out.println(obj1.getTime());// -28800000   
14. System.out.println(obj2.getTime());// -28800000   
15. System.out.println(obj3.getTime());// -28800000   
16.   
17. // 业务逻辑相同   
18. System.out.println(obj1.toString()); // 1970-01-01   
19. System.out.println(obj2.toString()); // 1970-01-01   
20.   
21. // 语法比较准确   
22. System.out.println(obj1.equals(obj2)); // true   
23. System.out.println(obj1.compareTo(obj2)); // 0  

 

也可以在不同类型的日时对象之间转换，如：

1. TimeZone.setDefault(TimeZone.getTimeZone("GMT+8:00"));   
2. java.util.Date obj1 =    
3.     java.sql.Timestamp.valueOf("2000-01-01 01:00:00");   
4.   
5. // 将java.sql.Timestamp转换成java.sql.Time   
6. // 日期信息变成 1970-01-01   
7. // 时间信息保留   
8. java.util.Date obj2 = DateTimeUtils.getLocalTime(obj1);   
9. System.out.println(obj2.toString());// 01:00:00   
10. System.out.println(obj2.getTime());// -25200000   
11.   
12. // 将java.sql.Time转换成java.sql.Date   
13. // 日期信息保留   
14. // 时间信息变成 00:00:00   
15. java.util.Date obj3 = DateTimeUtils.getLocalDate(obj2);   
16. System.out.println(obj3.toString());// 1970-01-01   
17. System.out.println(obj3.getTime());// -28800000