java时间日期

Date 类

Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

1. 构造方法

Date 类有如下两个构造方法。

• Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
• Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

这两个构造方法的使用示例如下：

1. Date date1 = new Date(); // 调用无参数构造函数
2. System.out.println(date1.toString()); // 输出：Wed May 18 21:24:40 CST 2016
3. Date date2 = new Date(60000); // 调用含有一个long类型参数的构造函数
4. System.out.println(date2); // 输出：Thu Jan 0108:01:00 CST 1970

Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。 因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。

2. 常用方法

Date 类提供了许多与日期和事件相关的方法，其中常见的方法如表 1 所示。
 

例 1

下面使用一个实例来具体演示 Date 类的使用。假设，某一天特定时间要去做一件事，而且那个时间已经过去一分钟之后才想起来这件事还没有办，这时系统将会提示已经过去了多 长时间。具体的代码如下：

1. import java.util.Date;
2. import java.util.Scanner;
4. public class Test11 {
5. public static void main(String[] args) {
6. Scanner input = new Scanner(System.in);
7. System.out.println("请输入要做的事情：");
8. String title = input.next();
9. Date date1 = new Date(); // 获取当前日期
10. System.out.println("[" + title + "] 这件事发生时间为：" + date1);
11. try {
12. Thread.sleep(60000);// 暂停 1 分钟
13. } catch (InterruptedException e) {
14. e.printStackTrace();
15. }
16. Date date2 = new Date();
17. System.out.println("现在时间为：" + date2);
18. if (date2.before(date1)) {
19. System.out.println("你还有 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒需要去完成【" + title + "】这件事！");
20. } else {
21. System.out.println("【" + title + "】事情已经过去了 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒");
22. }
23. }
24. }

在该程序中，分别使用 Date 类的无参数构造方法创建了两个 Date 对象。在创建完第一个 Date 对象后，使用 Thread.sleep() 方法让程序休眠 60 秒，然后再创建第二个 Date 对象，这样第二个 Date 对象所表示的时间将会在第一个 Date 对象所表示时间之后，因此“date2.before(date1)”条件表达式不成立，从而执行 else 块中的代码，表示事情已经发生过。

运行该程序，执行结果如下所示。

请输入要做的事情：
收快递
【收快递】这件事发生时间为：Fri Oct 12 11:11:07 CST 2018
现在时间为：Fri Oct 12 11:12:07 CST 2018
【收快递】事情已经过去了 60 秒

Calendar 类

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

1. Calendar c = Calendar.getInstance();

当创建了一个 Calendar 对象后，就可以通过 Calendar 对象中的一些方法来处理日期、时间。Calendar 类的常用方法如表 2 所示。
 

Calendar 对象可以调用 set() 方法将日历翻到任何一个时间，当参数 year 取负数时表示公元前。Calendar 对象调用 get() 方法可以获取有关年、月、日等时间信息，参数 field 的有效值由 Calendar 静态常量指定。

Calendar 类中定义了许多常量，分别表示不同的意义。

• Calendar.YEAR：年份。
• Calendar.MONTH：月份。
• Calendar.DATE：日期。
• Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。
• Calendar.HOUR：12小时制的小时。
• Calendar.HOUR_OF_DAY：24 小时制的小时。
• Calendar.MINUTE：分钟。
• Calendar.SECOND：秒。
• Calendar.DAY_OF_WEEK：星期几。

例如，要获取当前月份可用如下代码：

1. int month = Calendar.getInstance().get(Calendar.MONTH);

如果整型变量 month 的值是 0，表示当前日历是在 1 月份；如果值是 11，则表示当前日历在 12 月份。

使用 Calendar 类处理日期时间的实例如下：

1. Calendar calendar = Calendar.getInstance(); // 如果不设置时间，则默认为当前时间
2. calendar.setTime(new Date()); // 将系统当前时间赋值给 Calendar 对象
3. System.out.println("现在时刻：" + calendar.getTime()); // 获取当前时间
4. int year = calendar.get(Calendar.YEAR); // 获取当前年份
5. System.out.println("现在是" + year + "年");
6. int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份（月份从 0 开始，所以加 1）
7. System.out.print(month + "月");
8. int day = calendar.get(Calendar.DATE); // 获取日
9. System.out.print(day + "日");
10. int week = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 获取今天星期几（以星期日为第一天）
11. System.out.print("星期" + week);
12. int hour = calendar.get(Calendar.HOUR_OF_DAY); // 获取当前小时数（24 小时制）
13. System.out.print(hour + "时");
14. int minute = calendar.get(Calendar.MINUTE); // 获取当前分钟
15. System.out.print(minute + "分");
16. int second = calendar.get(Calendar.SECOND); // 获取当前秒数
17. System.out.print(second + "秒");
18. int millisecond = calendar.get(Calendar.MILLISECOND); // 获取毫秒数
19. System.out.print(millisecond + "毫秒");
20. int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // 获取今天是本月第几天
21. System.out.println("今天是本月的第 " + dayOfMonth + " 天");
22. int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); // 获取今天是本月第几周
23. System.out.println("今天是本月第 " + dayOfWeekInMonth + " 周");
24. int many = calendar.get(Calendar.DAY_OF_YEAR); // 获取今天是今年第几天
25. System.out.println("今天是今年第 " + many + " 天");
26. Calendar c = Calendar.getInstance();
27. c.set(2012, 8, 8); // 设置年月日，时分秒将默认采用当前值
28. System.out.println("设置日期为 2012-8-8 后的时间：" + c.getTime()); // 输出时间

上面的示例代码演示了 Calendar 类中的方法与常量的结合使用，从而完成处理日期的操作。

例 2

下面使用 Calendar 类来实现日历的打印功能，代码实现如下：

1. import java.util.Calendar;
3. public class CalendarDemo {
4. public static void main(String[] args) {
5. Calendar calendar = Calendar.getInstance();
6. calendar.set(2016, 5, 1); // 实际的calendar对象所表示的日期为2016年6月1日
8. // 判断2016年6月1日为一周中的第几天
9. int index = calendar.get(Calendar.DAY_OF_WEEK) - 1;
10. char[] title = { '日', '一', '二', '三', '四', '五', '六' }; // 存放曰历的头部
11. int daysArray[][] = new int[6][7];// 存放日历的数据
12. int daysInMonth = 31; // 该月的天数
13. int day = 1; // 自动增长
14. for (int i = index; i < 7; i++) {
15. // 填充第一周的日期数据，即日历中的第一行
16. daysArray[0][i] = day++;
17. }
18. for (int i = 1; i < 6; i++) {
19. // 填充其他周的日历数据，控制行
20. for (int j = 0; j < 7; j++) {
21. // 如果当前day表示的是本月最后一天，则停止向数组中继续赋值
22. if (day > daysInMonth) {
23. i = 6;
24. break;
25. }
26. daysArray[i][j] = day++;
27. }
28. }
29. System.out.println("------------------2016 年 6 月--------------------\n");
30. for (int i = 0; i < title.length; i++) {
31. System.out.print(title[i] + "\t");
32. }
33. System.out.print("\n");
34. // 输出二元数组daysArray中的元素
35. for (int i = 0; i < 6; i++) {
36. for (int j = 0; j < 7; j++) {
37. if (daysArray[i][j] == 0) {
38. if (i != 0) {
39. // 如果到月末，则完成显示日历的任务，停止该方法的执行
40. return;
41. }
42. System.out.print("\t");
43. continue;
44. }
45. System.out.print(daysArray[i][j] + "\t");
46. }
47. System.out.print("\n");
48. }
49. }
50. }

该程序看似复杂其实很简单。因为 Calendar 类所表示的时间月份是 set() 方法中表示月份的参数值 +1，因此 Calendar 类的实际时间为 2016 年 6 月 1 日。在下面的代码中分别获取 6 月 1 日为本周中的第几天，以便在相应的星期下开始输出 6 月份的日历。程序中的 daysArray 是一个二元数组，该二元数组控制了日历的格式输出，第一个子数组控制日历的行，第二个子数组控制曰历的列，即可输出二元数组中的每一个元素。

运行程序，执行结果如下所示。

------------------2016 年 6 月--------------------

日 一 二 三 四 五 六
   1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31 

DateFormat 类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期→文本）、解析（文本→日期）和标准化日期。

在创建 DateFormat 对象时不能使用 new 关键字，而应该使用 DateFormat 类中的静态方法 getDateInstance()，示例代码如下：

DateFormat df = DateFormat.getDatelnstance();

在创建了一个 DateFormat 对象后，可以调用该对象中的方法来对日期/时间进行格式化。DateFormat 类中常用方法如表 1 所示。
 

格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到表 1 所示的方法中，以控制结果的长度。DateFormat 类的常量如下。

• SHORT：完全为数字，如 12.5.10 或 5:30pm。
• MEDIUM：较长，如 May 10，2016。
• LONG：更长，如 May 12，2016 或 11:15:32am。
• FULL：是完全指定，如 Tuesday、May 10、2012 AD 或 11:l5:42am CST。

使用 DateFormat 类格式化曰期/时间的示例如下：

1. // 获取不同格式化风格和中国环境的日期
2. DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT, Locale.CHINA);
3. DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL, Locale.CHINA);
4. DateFormat df3 = DateFormat.getDateInstance(DateFormat.MEDIUM, Locale.CHINA);
5. DateFormat df4 = DateFormat.getDateInstance(DateFormat.LONG, Locale.CHINA);
7. // 获取不同格式化风格和中国环境的时间
8. DateFormat df5 = DateFormat.getTimeInstance(DateFormat.SHORT, Locale.CHINA);
9. DateFormat df6 = DateFormat.getTimeInstance(DateFormat.FULL, Locale.CHINA);
10. DateFormat df7 = DateFormat.getTimeInstance(DateFormat.MEDIUM, Locale.CHINA);
11. DateFormat df8 = DateFormat.getTimeInstance(DateFormat.LONG, Locale.CHINA);
13. // 将不同格式化风格的日期格式化为日期字符串
14. String date1 = df1.format(new Date());
15. String date2 = df2.format(new Date());
16. String date3 = df3.format(new Date());
17. String date4 = df4.format(new Date());
19. // 将不同格式化风格的时间格式化为时间字符串
20. String time1 = df5.format(new Date());
21. String time2 = df6.format(new Date());
22. String time3 = df7.format(new Date());
23. String time4 = df8.format(new Date());
25. // 输出日期
26. System.out.println("SHORT：" + date1 + " " + time1);
27. System.out.println("FULL：" + date2 + " " + time2);
28. System.out.println("MEDIUM：" + date3 + " " + time3);
29. System.out.println("LONG：" + date4 + " " + time4);

运行该段代码，输出的结果如下：

SHORT：18-10-15 上午9:30
FULL：2018年10月15日 星期一 上午09时30分43秒 CST
MEDIUM：2018-10-15 9:30:43
LONG：2018年10月15日 上午09时30分43秒

该示例主要介绍了 DateFormat 类中方法与常量的结合使用，通过使用 DateFomat 类可以对日期进行不同风格的格式化。

SimpleDateFormat 类

如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。

SimpleDateFormat 类主要有如下 3 种构造方法。

• SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
• SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateF ormat。
• SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateF ormat。

SimpleDateFormat 自定义格式中常用的字母及含义如表 2 所示。
 

例 1

编写 Java 程序，使用 SimpleDateFormat 类格式化当前日期并打印，日期格式为“xxxx 年 xx 月 xx 日星期 xxx 点 xx 分 xx 秒”，具体的实现代码如下：

1. import java.text.SimpleDateFormat;
2. import java.util.Date;
4. public class Test13 {
5. public static void main(String[] args) {
6. Date now = new Date(); // 创建一个Date对象，获取当前时间
7. // 指定格式化格式
8. SimpleDateFormat f = new SimpleDateFormat("今天是 " + "yyyy 年 MM 月 dd 日 E HH 点 mm 分 ss 秒");
9. System.out.println(f.format(now)); // 将当前时间袼式化为指定的格式
10. }
11. }

该程序的运行结果如下：

今天是 2018 年 10 月 15 日 星期一 09 点 26 分 23 秒