JAVA面试题解惑系列（七）——使用日期和时间

日期和时间，不仅在考试面试题。处理的问题。似乎没有哪个项目能够避开它们。我们经常在处理用户的出生年月日、注冊日期，订单的创建时间等属性时用到，由此可见其重要性。

java.util.Date类

提到日期和时间，我想大家最先想到应该是java.util.Date类吧。Date类能够精确到毫秒数，这个毫秒数是相对于格林威治标准时间“1970-01-01 00:00:00.000 GMT”的差值。那么。什么是格林威治标准时间呢？要回答这个问题。我们须要先来了解一下世界时间标准方面的知识。

世界时间标准主要有UTC。即Coordinated Universal Time（中文名译作世界协调时间、世界统一时间或世界标准时间），以及GMT，即Greenwich Mean Time（中文名译作格林威治标准时间或格林威治平均时间）两种。严格来讲，UTC比GMT更加精确一些，只是它们的差值不会超过0.9秒。假设超过了，将会为UTC添加闰秒以与GMT。也就是地球自转周期保持一致。所以在日常使用中，我们能够把UTC和GMT一样看待。

日期和时间的表示是与我们所处的时区相关联的，假设我们不指定时区，那么它们将以系统默认的时区来显示。我们先来看看怎样创建日期对象。Date类有非常多个构造器方法。大部分已经不被赞成使用了（Deprecated），只是还剩下两个能够使用的：

Java代码 

  1. public Date() {
  2. this(System.currentTimeMillis());
  3. }
  4. public Date(long date) {
  5. //other code
  6. }

第一个是无參构造器，使用系统当前时间的毫秒数来创建Date对象，它调用了java.lang.System类的currentTimeMillis()来取得系统的当前时间的毫秒值。这是个本地方法，它的定义例如以下：

Java代码 

  1. public static native long currentTimeMillis();

第二个构造器是依据给定的毫秒数来创建一个与之相应的Date对象。这个毫秒数决定了被创建对象的年、月、日、时、分、秒属性的值。

我们来看看日期和时间在默认时区下的显示效果：

Java代码 

  1. import java.util.Date;
  2. public class DateTest {
  3. public static void main(String[] args) {
  4. Date d = new Date();
  5. // 在默认时区下输出日期和时间值
  6. System.out.println(d);
  7. }
  8. }

执行结果：

  • Tue Jul 22 10:44:47 CST 2008

大家应该注意到了年份前的“CST”标识。它是China Standard Time的缩写，指的是中国标准时间。也就是我们常说的北京时间。它与UTC的时差是UTC+8:00。就是说北京时间比世界标准时间早8个小时。假设世界标准时间是早上1点，北京时间就是早上9点。普通情况下我们不须要关心时区问题。

在创建完Date对象之后。我们能够通过调用getTime()方法来获得该对象的毫秒数值，调用setTime(long time)方法来设置它的毫秒数值。从而影响年、月、日、时、分、秒这些属性。这两个方法的定义例如以下：

Java代码 

  1. public long getTime() {
  2. //other code
  3. }
  4. public void setTime(long time) {
  5. //other code
  6. }

既然Date对象能够表示盛相对于“1970-01-01 00:00:00.000 GMT”的毫秒数。我们自然能够通过这个值来比較两个日期的大小了，只是对于日期来讲，前后的说法应该更为恰当。而Date类已经为我们提供了这个方案：

Java代码 

  1. public boolean before(Date when) {
  2. //other code
  3. }
  4. public boolean after(Date when) {
  5. //other code
  6. }
  7. public int compareTo(Date anotherDate) {
  8. //other code
  9. }

before()是推断当前日期是否在參数日期之前，即当前日期毫秒数小于參数日期毫秒数。after()是推断当前日期是否在參数日期之后。即当前日期毫秒数大于參数日期毫秒数。

而compareTo()是将当前日期与參数日期比較后，返回一个int型值，它的返回值有三种可能：-1、0和1。假设返回-1则表示当前日期在參数日期之前；假设返回0则表示两个日期是同一时刻；返回1则表示当前日期在參数日期之后。尽管我们能够用compareTo()方法来比較两个Date对象，可是它的设计实际是另实用途的，我们在后面的章节将会讲到。

以下我们就用一个演示样例来检验一下以上方法的使用方法：

Java代码 

  1. import java.util.Date;
  2. public class DateTest {
  3. public static void main(String[] args) {
  4. // 2008-08-08 20:00:00相应的毫秒数
  5. long t2008 = 1218196800000L;
  6. // 1900-01-01 20:00:00相应的毫秒数
  7. long t1900 = -2208945952000L;
  8. // 指定毫秒数创建Date对象
  9. Date d2008 = new Date(t2008);
  10. // 使用系统默认时间创建Date对象
  11. Date d1900 = new Date();
  12. // 通过设置毫秒数改变日期和时间
  13. d1900.setTime(t1900);
  14. System.out.println("调用方法：d1900.before(d2008)");
  15. System.out
  16. .print("比較结果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"");
  17. // 使用before()方法比較
  18. if (d1900.before(d2008)) {
  19. System.out.println("之前");
  20. } else {
  21. System.out.println("之后");
  22. }
  23. System.out.println();
  24. System.out.println("调用方法：d2008.after(d1900)");
  25. System.out
  26. .print("比較结果：\"2008-08-08 20:00:00\"在\"1900-01-01 20:00:00\"");
  27. // 使用after()方法比較
  28. if (d2008.after(d1900)) {
  29. System.out.println("之后");
  30. } else {
  31. System.out.println("之前");
  32. }
  33. System.out.println();
  34. System.out.println("调用方法：d1900.compareTo(d2008)");
  35. System.out
  36. .print("比較结果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"");
  37. // 使用compareTo()方法比較
  38. int i = d1900.compareTo(d2008);
  39. if (i == -1) {
  40. System.out.println("之前");
  41. } else if (i == 1) {
  42. System.out.println("之后");
  43. } else if (i == 0) {
  44. System.out.println("是同一时刻");
  45. }
  46. }
  47. }

执行结果：

  1. 调用方法：d1900.before(d2008)
  2. 比較结果："1900-01-01 20:00:00"在"2008-08-08 20:00:00"之前
  3. 调用方法：d2008.after(d1900)
  4. 比較结果："2008-08-08 20:00:00"在"1900-01-01 20:00:00"之后
  5. 调用方法：d1900.compareTo(d2008)
  6. 比較结果："1900-01-01 20:00:00"在"2008-08-08 20:00:00"之前

那么假设我们想直接获取或者改变年、月、日、时、分、秒等等这些属性的值时怎么办呢？Date类当然有完毕这些操作的方法，只是遗憾的是它们也都已经不被赞成使用了。我们必须换一个可以提供这些操作的类，这个类就是java.util.Calendar。

公历历法java.util.GregorianCalendar

Calendar是一个抽象类，我们无法直接实例化它。它有一个详细子类实体类java.util.GregorianCalendar，这个类实现的就是我们日常所用的公历历法，或者叫做阳历。

我们能够直接使用new命令创建它的实例。或者使用Calendar类的这种方法来获得它实例：

Java代码 

  1. public static Calendar getInstance(){
  2. //other code
  3. }

採用上面这种方法时，我们创建的Calendar对象的日期和时间值是对象被创建时系统日期和时间值。

当使用new命令时。我们有两种选择，一种是使用系统当前的日期和时间值初始化GregorianCalendar对象；还有一种是通过给定年、月、日、时、分、秒等属性值来对其进行初始化。请看以下的样例：

Java代码 

  1. import java.text.DateFormat;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Calendar;
  4. import java.util.GregorianCalendar;
  5. public class DateTest {
  6. /**
  7. * 以一种较为友好的方式格式化日期时间值
  8. *
  9. * @param c
  10. *            日期时间对象
  11. * @return 格式化后的日期时间字符串
  12. */
  13. public static String toFriendlyString(Calendar c) {
  14. if (c != null) {
  15. DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
  16. return df.format(c.getTime());
  17. }
  18. return null;
  19. }
  20. public static void main(String[] args) {
  21. Calendar c1 = Calendar.getInstance();
  22. System.out.println("创建方式：Calendar.getInstance()");
  23. System.out.println("日期时间：" + DateTest.toFriendlyString(c1));
  24. System.out.println();
  25. Calendar c2 = new GregorianCalendar();
  26. System.out.println("创建方式：new GregorianCalendar()");
  27. System.out.println("日期时间：" + DateTest.toFriendlyString(c2));
  28. System.out.println();
  29. // 參数含义依次为：年、月、日
  30. Calendar c3 = new GregorianCalendar(2008, 8, 8);
  31. System.out.println("创建方式：new GregorianCalendar(2008, 8, 8)");
  32. System.out.println("日期时间：" + DateTest.toFriendlyString(c3));
  33. System.out.println();
  34. // 參数含义依次为：年、月、日、时、分
  35. Calendar c4 = new GregorianCalendar(2008, 8, 8, 6, 10);
  36. System.out.println("创建方式：new GregorianCalendar(2008, 8, 8, 6, 10)");
  37. System.out.println("日期时间：" + DateTest.toFriendlyString(c4));
  38. System.out.println();
  39. // 參数含义依次为：年、月、日、时、分、秒
  40. Calendar c5 = new GregorianCalendar(2008, 8, 8, 18, 10, 5);
  41. System.out.println("创建方式：new GregorianCalendar(2008, 8, 8, 18, 10, 5)");
  42. System.out.println("日期时间：" + DateTest.toFriendlyString(c5));
  43. }
  44. }

执行结果例如以下：

  1. 创建方式：Calendar.getInstance()
  2. 日期时间：2008年07月22日 11:54:48
  3. 创建方式：new GregorianCalendar()
  4. 日期时间：2008年07月22日 11:54:48
  5. 创建方式：new GregorianCalendar(2008, 8, 8)
  6. 日期时间：2008年09月08日 00:00:00
  7. 创建方式：new GregorianCalendar(2008, 8, 8, 6, 10)
  8. 日期时间：2008年09月08日 06:10:00
  9. 创建方式：new GregorianCalendar(2008, 8, 8, 18, 10, 5)
  10. 日期时间：2008年09月08日 18:10:05

为了便于阅读。我们添加一个toFriendlyString(Calendar c)方法，它将日期时间值格式化为一种更加友好易懂的形式，我们将在接下来的内容中解说它的实现原理。分析执行结果后，我们发现有两个地方须要注意：

  1. 在创建GregorianCalendar对象时，月份值都设定为8，但打印结果都是9月份。这并非我们的代码有问题。而是由于JAVA表示的月份是从0開始的。也就是说它用来表示月份的数值总是比实际月份值小1。因此我们要表示8月份，就是应该设置8-1=7这个值。
  2. GregorianCalendar的小时数是24小时制的。

为了避免出现由于忘记处理1的差值而设置了错误的月份，也让代码看起来更加直观，推荐大家使用定义在Calendar类的的这些常量来取代直接用数字表示月份：

  • 一月：Calendar.JANUARY = 0
  • 二月：Calendar.FEBRUARY = 1
  • 三月：Calendar.MARCH = 2
  • 四月：Calendar.APRIL = 3
  • 五月：Calendar.MAY = 4
  • 六月：Calendar.JUNE = 5
  • 七月：Calendar.JULY = 6
  • 八月：Calendar.AUGUST = 7
  • 九月：Calendar.SEPTEMBER = 8
  • 十月：Calendar.OCTOBER = 9
  • 十一月：Calendar.NOVEMBER = 10
  • 十二月：Calendar.DECEMBER = 11

假设我们想要从Calendar对象获得各种属性的值。就须要调用它的get(int field)方法。这种方法接收一个int型的參数，而且依据这个给定參数的值来返回对应的属性的值。该方法的定义例如以下：

Java代码 

  1. public int get(int field){
  2. //other code
  3. }

我们以一个演示样例来说明get(int field)方法所能接受的一些经常使用參数的含义及使用方法：

Java代码 

  1. import java.text.DateFormat;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Calendar;
  4. public class DateTest {
  5. /**
  6. * 以一种较为友好的方式格式化日期时间值
  7. *
  8. * @param c
  9. *            日期时间对象
  10. * @return 格式化后的日期时间字符串
  11. */
  12. public static String toFriendlyString(Calendar c) {
  13. if (c != null) {
  14. DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss.SSS");
  15. return df.format(c.getTime());
  16. }
  17. return null;
  18. }
  19. public static void main(String[] args) {
  20. Calendar c = Calendar.getInstance();
  21. System.out.println("当前时刻：" + DateTest.toFriendlyString(c));
  22. System.out.println();
  23. System.out.println("属性名称：Calendar.AM_PM");
  24. System.out.println("代表含义：上下午标识，上午返回Calendar.AM=0，下午返回Calendar.PM=1");
  25. System.out.println("測试结果：" + c.get(Calendar.AM_PM));
  26. System.out.println();
  27. System.out.println("属性名称：Calendar.DATE");
  28. System.out.println("代表含义：一个月中的第几天。同Calendar.DAY_OF_MONTH");
  29. System.out.println("測试结果：" + c.get(Calendar.DATE));
  30. System.out.println();
  31. System.out.println("属性名称：Calendar.DAY_OF_MONTH");
  32. System.out.println("代表含义：一个月中的第几天，同Calendar.DATE");
  33. System.out.println("測试结果：" + c.get(Calendar.DAY_OF_MONTH));
  34. System.out.println();
  35. System.out.println("属性名称：Calendar.DAY_OF_WEEK");
  36. System.out.println("代表含义：一周中的第几天。相应星期几，第一天为星期日。于此类推。");
  37. System.out.println("星期日:Calendar.SUNDAY=1");
  38. System.out.println("星期一:Calendar.MONDAY=2");
  39. System.out.println("星期二:Calendar.TUESDAY=3");
  40. System.out.println("星期三:Calendar.WEDNESDAY=4");
  41. System.out.println("星期四:Calendar.THURSDAY=5");
  42. System.out.println("星期五:Calendar.FRIDAY=6");
  43. System.out.println("星期六:Calendar.SATURDAY=7");
  44. System.out.println("測试结果：" + c.get(Calendar.DAY_OF_WEEK));
  45. System.out.println();
  46. System.out.println("属性名称：Calendar.DAY_OF_WEEK_IN_MONTH");
  47. System.out.println("代表含义：这一天所相应的星期几在该月中是第几次出现");
  48. System.out.println("測试结果：" + c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
  49. System.out.println();
  50. System.out.println("属性名称：Calendar.DAY_OF_YEAR");
  51. System.out.println("代表含义：一年中的第几天");
  52. System.out.println("測试结果：" + c.get(Calendar.DAY_OF_YEAR));
  53. System.out.println();
  54. System.out.println("属性名称：Calendar.HOUR");
  55. System.out.println("代表含义：12小时制下的小时数，中午和午夜表示为0");
  56. System.out.println("測试结果：" + c.get(Calendar.HOUR));
  57. System.out.println();
  58. System.out.println("属性名称：Calendar.HOUR_OF_DAY");
  59. System.out.println("代表含义：24小时制下的小时数，午夜表示为0");
  60. System.out.println("測试结果：" + c.get(Calendar.HOUR_OF_DAY));
  61. System.out.println();
  62. System.out.println("属性名称：Calendar.MILLISECOND");
  63. System.out.println("代表含义：毫秒数");
  64. System.out.println("測试结果：" + c.get(Calendar.MILLISECOND));
  65. System.out.println();
  66. System.out.println("属性名称：Calendar.MINUTE");
  67. System.out.println("代表含义：分钟");
  68. System.out.println("測试结果：" + c.get(Calendar.MINUTE));
  69. System.out.println();
  70. System.out.println("属性名称：Calendar.MONTH");
  71. System.out.println("代表含义：月份。从0到11表示12个月份，比实际月份值小1");
  72. System.out.println("測试结果：" + c.get(Calendar.MONTH));
  73. System.out.println();
  74. System.out.println("属性名称：Calendar.SECOND");
  75. System.out.println("代表含义：秒");
  76. System.out.println("測试结果：" + c.get(Calendar.SECOND));
  77. System.out.println();
  78. System.out.println("属性名称：Calendar.WEEK_OF_MONTH");
  79. System.out.println("代表含义：一个月中的第几个星期");
  80. System.out.println("測试结果：" + c.get(Calendar.WEEK_OF_MONTH));
  81. System.out.println();
  82. System.out.println("属性名称：Calendar.WEEK_OF_YEAR");
  83. System.out.println("代表含义：一年中的第几个星期");
  84. System.out.println("測试结果：" + c.get(Calendar.WEEK_OF_YEAR));
  85. System.out.println();
  86. System.out.println("属性名称：Calendar.YEAR");
  87. System.out.println("代表含义：年份");
  88. System.out.println("測试结果：" + c.get(Calendar.YEAR));
  89. }
  90. }

执行结果例如以下：

  1. 当前时刻：2008年07月22日 13:16:07.421
  2. 属性名称：Calendar.AM_PM
  3. 代表含义：上下午标识，上午返回Calendar.AM=0。下午返回Calendar.PM=1
  4. 測试结果：1
  5. 属性名称：Calendar.DATE
  6. 代表含义：一个月中的第几天，同Calendar.DAY_OF_MONTH
  7. 測试结果：22
  8. 属性名称：Calendar.DAY_OF_MONTH
  9. 代表含义：一个月中的第几天，同Calendar.DATE
  10. 測试结果：22
  11. 属性名称：Calendar.DAY_OF_WEEK
  12. 代表含义：一周中的第几天，相应星期几，第一天为星期日。于此类推。
  13. 星期日:Calendar.SUNDAY=1
  14. 星期一:Calendar.MONDAY=2
  15. 星期二:Calendar.TUESDAY=3
  16. 星期三:Calendar.WEDNESDAY=4
  17. 星期四:Calendar.THURSDAY=5
  18. 星期五:Calendar.FRIDAY=6
  19. 星期六:Calendar.SATURDAY=7
  20. 測试结果：3
  21. 属性名称：Calendar.DAY_OF_WEEK_IN_MONTH
  22. 代表含义：这一天所相应的星期几在该月中是第几次出现
  23. 測试结果：4
  24. 属性名称：Calendar.DAY_OF_YEAR
  25. 代表含义：一年中的第几天
  26. 測试结果：204
  27. 属性名称：Calendar.HOUR
  28. 代表含义：12小时制下的小时数。中午和午夜表示为0
  29. 測试结果：1
  30. 属性名称：Calendar.HOUR_OF_DAY
  31. 代表含义：24小时制下的小时数，午夜表示为0
  32. 測试结果：13
  33. 属性名称：Calendar.MILLISECOND
  34. 代表含义：毫秒数
  35. 測试结果：421
  36. 属性名称：Calendar.MINUTE
  37. 代表含义：分钟
  38. 測试结果：16
  39. 属性名称：Calendar.MONTH
  40. 代表含义：月份，从0到11表示12个月份。比实际月份值小1
  41. 測试结果：6
  42. 属性名称：Calendar.SECOND
  43. 代表含义：秒
  44. 測试结果：7
  45. 属性名称：Calendar.WEEK_OF_MONTH
  46. 代表含义：一个月中的第几个星期
  47. 測试结果：4
  48. 属性名称：Calendar.WEEK_OF_YEAR
  49. 代表含义：一年中的第几个星期
  50. 測试结果：30
  51. 属性名称：Calendar.YEAR
  52. 代表含义：年份
  53. 測试结果：2008

当中Calendar.DAY_OF_WEEK_IN_MONTH代表的含义比較难理解一些，它表示“这一天所相应的星期几在该月中是第几次出现”。比方2008年8月8日是星期五，在它之前的8月1日也是星期五，因此它是8月份的第二个星期五。所以这时调用get(Calendar.DAY_OF_WEEK_IN_MONTH)就会返回2。这里存在一个简单易记的规律：对于每月的1-7号。它们一定占全了星期一到星期日，所以无论是它们中的哪一天，也无论这一天是星期几，它总是第一个，因此返回1；8-14号也相同占全了星期一到星期日，但因为1-7号的关系，对于它们总是返回2；以此类推。15-21号返回3，22-28号返回4，29-31号返回5。

Calendar对象和Date对象能够通过Calendar类的例如以下两个方法进行相互转换：

Java代码 

  1. public final Date getTime() {
  2. //other code
  3. }
  4. public final void setTime(Date date) {
  5. //other code
  6. }

日期格式化与解析

我们回头再来看看在上面的样例中定义的toFriendlyString(Calendar c)方法。它将一个Calendar对象的日期时间值以一种非常友好的方式来展现，使人们非常easy看懂，也符合我们中国人的习惯。这全然得益于抽象类DateFormat以及它的子类实体类SimpleDateFormat的帮助。这两个类都位于java.text包中，是专门用于日期格式化和解析的类。而这两项工作的核心就是我们为此设定的Pattern。我们能够称之为“日期格式表达式”。

理论上讲日期格式表达式包括所有26个英文字母的大写和小写，只是它们中的一些字母仅仅是被预留了，并没有确切的含义。

眼下有效的字母及它们所代表的含义例如以下：

  • G：年代标识，表示是公元前还是公元后
  • y：年份
  • M：月份
  • d：日
  • h：小时，从1到12，分上下午
  • H：小时。从0到23
  • m：分钟
  • s：秒
  • S：毫秒
  • E：一周中的第几天，相应星期几，第一天为星期日，于此类推
  • z：时区
  • D：一年中的第几天
  • F：这一天所相应的星期几在该月中是第几次出现
  • w：一年中的第几个星期
  • W：一个月中的第几个星期
  • a：上午/下午标识
  • k：小时，从1到24
  • K：小时，从0到11。区分上下午

在日期格式表达式中出现的全部字母，在进行日期格式化操作后。都将被其所代表的含义相应的属性值所替换，而且对某些字母来说，反复次数的不同，格式化后的结果也会有所不同。请看以下的样例：

Java代码 

  1. import java.text.SimpleDateFormat;
  2. import java.util.Date;
  3. public class DateTest {
  4. public static void main(String[] args) {
  5. // 使用系统当前日期时间值创建一个Date对象
  6. Date now = new Date();
  7. // 创建一个日期格式表达式
  8. String pattern = "年代:G;年份:y;月份:M;日:d;时(1~12):h;时(0~23):H;分:m;秒:s;毫秒:S;星期:E;上/下午:a;时区:z";
  9. // 使用日期格式表达式创建一个SimpleDateFormat对象
  10. SimpleDateFormat df = new SimpleDateFormat(pattern);
  11. // 调用SimpleDateFormat类的format(Date date)方法对Date对象进行格式化，并返回格式化后的字符串。
  12. // 该方法继承自java.text.DateFormat类
  13. System.out.println("1位：" + df.format(now));
  14. // 创建一个新的日期格式表达式
  15. pattern = "年代:GG;年份:yy;月份:MM;日:dd;时(1~12):hh;时(0~23):HH;分:mm;秒:ss;毫秒:SS;星期:EE;上/下午:aa;时区:zz";
  16. // 调用SimpleDateFormat的applyPattern(String pattern)方法用新创建的日期格式表达式替换其原有的
  17. df.applyPattern(pattern);
  18. System.out.println("2位：" + df.format(now));
  19. pattern = "年代:GGG;年份:yyy;月份:MMM;日:ddd;时(1~12):hhh;时(0~23):HHH;分:mmm;秒:sss;毫秒:SSS;星期:EEE;上/下午:aaa;时区:zzz";
  20. df.applyPattern(pattern);
  21. System.out.println("3位：" + df.format(now));
  22. pattern = "年代:GGGG;年份:yyyy;月份:MMMM;日:dddd;时(1~12):hhhh;时(0~23):HHHH;分:mmmm;秒:ssss;毫秒:SSSS;星期:EEEE;上/下午:aaaa;时区:zzzz";
  23. df.applyPattern(pattern);
  24. System.out.println("4位：" + df.format(now));
  25. pattern = "年代:GGGGG;年份:yyyyy;月份:MMMMM;日:ddddd;时(1~12):hhhhh;时(0~23):HHHHH;分:mmmmm;秒:sssss;毫秒:SSSSS;星期:EEEEE;上/下午:aaaaa;时区:zzzzz";
  26. df.applyPattern(pattern);
  27. System.out.println("5位：" + df.format(now));
  28. pattern = "年代:GGGGGG;年份:yyyyyy;月份:MMMMMM;日:dddddd;时(1~12):hhhhhh;时(0~23):HHHHHH;分:mmmmmm;秒:ssssss;毫秒:SSSSSS;星期:EEEEEE;上/下午:aaaaaa;时区:zzzzzz";
  29. df.applyPattern(pattern);
  30. System.out.println("6位：" + df.format(now));
  31. }
  32. }

输出结果例如以下：

  1. 1位：年代:公元;年份:08;月份:7;日:22;时(1~12):3;时(0~23):15;分:17;秒:49;毫秒:187;星期:星期二;上/下午:下午;时区:CST
  2. 2位：年代:公元;年份:08;月份:07;日:22;时(1~12):03;时(0~23):15;分:17;秒:49;毫秒:187;星期:星期二;上/下午:下午;时区:CST
  3. 3位：年代:公元;年份:08;月份:七月;日:022;时(1~12):003;时(0~23):015;分:017;秒:049;毫秒:187;星期:星期二;上/下午:下午;时区:CST
  4. 4位：年代:公元;年份:2008;月份:七月;日:0022;时(1~12):0003;时(0~23):0015;分:0017;秒:0049;毫秒:0187;星期:星期二;上/下午:下午;时区:中国标准时间
  5. 5位：年代:公元;年份:02008;月份:七月;日:00022;时(1~12):00003;时(0~23):00015;分:00017;秒:00049;毫秒:00187;星期:星期二;上/下午:下午;时区:中国标准时间
  6. 6位：年代:公元;年份:002008;月份:七月;日:000022;时(1~12):000003;时(0~23):000015;分:000017;秒:000049;毫秒:000187;星期:星期二;上/下午:下午;时区:中国标准时间

假设我们想输出原始的字母，而不是它们所代表含义的替换值，就须要用单引號将它们包括在内，对于预留字母也是如此，尽管它们没有确切的含义。一对单引號能够一次包括多个字母，而两个连续的单引號将输出一个单引號结果，双引號则须要转义后输出。对于26个字母之外的字符。能够放在一对单引號中，也能够直接书写。

请看以下的样例：

Java代码 

  1. import java.text.SimpleDateFormat;
  2. import java.util.Date;
  3. public class Test {
  4. public static void main(String[] args) {
  5. Date now = new Date();
  6. SimpleDateFormat df = new SimpleDateFormat(
  7. "‘YEAR‘: yyyy ‘MONTH:‘ ‘‘MM‘‘ ‘DAY:‘ \"dd\" ");
  8. System.out.println(df.format(now));
  9. }
  10. }

执行结果：

  • YEAR: 2008 MONTH: ‘07‘ DAY: "22"

上面的一些样例中，我们将日期对象转换成一定格式的字符串输出。以得到符合我们习惯的较为友好的表现形式。我们还能够反过来，使用DateFormat类的parse(String source)方法将具有一定格式的字符串转换为一个Date对象，前提是我们利用前面讲到日期格式表达式语法为其找到一个合适的Pattern。比如：

Java代码 

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. public class DateTest {
  5. public static void main(String[] args) throws ParseException {
  6. String s = "2008-08-08";
  7. System.out.println("原始字符串：" + s);
  8. String pattern = "yyyy-MM-dd";
  9. System.out.println("相应表达式：" + pattern);
  10. SimpleDateFormat df = new SimpleDateFormat(pattern);
  11. Date date = df.parse(s);
  12. System.out.println("转换后的值：" + date);
  13. System.out.println();
  14. s = "05年2月12日 18:04:33";
  15. System.out.println("原始字符串：" + s);
  16. pattern = "yy年M月d日 HH:mm:ss";
  17. System.out.println("相应表达式：" + pattern);
  18. df.applyPattern(pattern);
  19. date = df.parse(s);
  20. System.out.println("转换后的值：" + date);
  21. System.out.println();
  22. s = "16/5/2004 20:7:2.050";
  23. System.out.println("原始字符串：" + s);
  24. pattern = "d/M/yyyy HH:m:s.SSS";
  25. System.out.println("相应表达式：" + pattern);
  26. df.applyPattern(pattern);
  27. date = df.parse(s);
  28. System.out.println("转换后的值：" + date);
  29. }
  30. }

执行结果：

  1. 原始字符串：2008-08-08
  2. 相应表达式：yyyy-MM-dd
  3. 转换后的值：Fri Aug 08 00:00:00 CST 2008
  4. 原始字符串：05年2月12日 18:04:33
  5. 相应表达式：yy年M月d日 HH:mm:ss
  6. 转换后的值：Sat Feb 12 18:04:33 CST 2005
  7. 原始字符串：16/5/2004 20:7:2.050
  8. 相应的表达：d/M/yyyy HH:m:s.SSS
  9. 转换值：Sun May 16 20:07:02 CST 2004
时间： 2024-10-02 22:06:35

JAVA面试题解惑系列（七）——使用日期和时间的相关文章

JAVA面试题解惑系列（七）——日期和时间的处理

日期和时间的处理不仅在面试题中会考到,在实际项目开发中也是我们经常需要处理的问题,似乎没有哪个项目可以避开它们,我们常常在处理用户的出生年月日.注册日期,订单的创建时间等属性时用到,由此可见其重要性. java.util.Date类 提到日期和时间,我想大家最先想到应该是java.util.Date类吧.Date类可以精确到毫秒数,这个毫秒数是相对于格林威治标准时间"1970-01-01 00:00:00.000 GMT"的差值.那么,什么是格林威治标准时间呢?要回答这个问题,我们需要

2019年Java面试题基础系列228道，题目汇总，可以先看会多少

Java面试题(一) 1.面向对象的特征有哪些方面? 2.访问修饰符 public,private,protected,以及不写(默认)时的区别? 3.String 是最基本的数据类型吗? 4.float f=3.4;是否正确? 5.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗? 6.Java 有没有 goto? 7.int 和 Integer 有什么区别? 8.&和&&的区别? 9.解释内存中的栈(stack).堆

Java基础复习笔记系列 七 IO操作

Java基础复习笔记系列之 IO操作 1. 2.

2019年Java面试题基础系列228道（1）

1.面向对象的特征有哪些方面? 面向对象的特征主要有以下几个方面: 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面.抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么. 继承:继承是从已有类得到继承信息创建新类的过程.提供继承信息的类被称为父类(超类.基类):得到继承信息的类被称为子类(派生类).继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段(如果不能理解请阅读阎宏博士的<Java 与模式>或<设计模式精解&

2019年Java面试题基础系列228道（3）

51.类 ExampleA 继承 Exception,类 ExampleB 继承ExampleA. 有如下代码片断: try { throw new ExampleB("b")}catch(ExampleA e){ System.out.println("ExampleA");}catch(Exception e){ System.out.println("Exception");} **请问执行此段代码的输出是什么? 答: 输出:Example

Java面试题精粹(基础知识)

本篇博文是自己针对网络上已出现的Java面试题帖子汇总,汇总并不是给出链接或直接转载内容,而是分析对比并整理出各帖子中常见.高频的面试题,这些经常露脸的面试题透出面试的趋势(为什么可以成为经典的面试题)及面试官的共通点.而作为求职者.技术爱好者的我们不仅要能够自信.精准得回答这些问题,更要知道为什么出这些问题,面试官想考察我们什么或希望我们给出怎样的回答,适当的再对回答进行拓展以达到更好的效果.面试本身包含了一些心理上的东西,面试官对于问题是有一个心中期许的答案,面试者若能够触摸到边缘或击中要害

【Java基础08】内部类、枚举类、日期和时间、Math、Random

1 内部类 1.1 概念 大部分时候,类被定义成一个独立的程序单元,在某些情况下,也会把一个类放到另一个类的内部定义,这个定义在其他类内部的类就被称为内部类,包含内部类的类被称为外部类. 1.2 作用 1.提供更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类. 2.内部类成员可以直接访问外部类的私有数据,因为内部类被当成其外部类成员,同一个类的成员之间可以互相访问.但外部类不能访问内部类的实现细节,例如内部类的成员变量. 3.匿名内部类适合用于创建那些仅需要一次使用的类

Java 日期、时间类

Java 原本提供了 Date 和 Calendar 用于处理日期.时间的类,包括创建日期.时间对象,获取系统当前日期.时间等操作.但 Date 不仅无法实现国际化,而且它对不同属性也使用了前后矛盾的偏移量,比如月份与小时都是从0开始的,月份中的天数则是从1开始的,年又是从1900开始的,而 java.util.Calendar 则显得过于复杂,从下面介绍中会看到传统 Java 对日期.时间处理的不足.Java8 吸取了 Joda-Time 库(一个被广泛使用的日期.时间库)的经验,提供了一套全

Java日期时间API系列11-----Jdk8中java.time包中的新的日期时间API类，使用java8日期时间API重写农历LunarDate

通过Java日期时间API系列7-----Jdk8中java.time包中的新的日期时间API类的优点,java8具有很多优点,现在网上查到的农历转换工具类都是基于jdk7及以前的类写的,下面使用java新的日期时间API重写农历LunarDate. package com.xkzhangsan.time; import java.time.Instant; import java.time.LocalDate; import java.time.LocalDateTime; import ja