java笔试面试日期时间处理.docx
《java笔试面试日期时间处理.docx》由会员分享，可在线阅读，更多相关《java笔试面试日期时间处理.docx（31页珍藏版）》请在冰豆网上搜索。
java笔试面试日期时间处理
日期和时间的处理不仅在面试题中会考到，在实际项目开发中也是我们经常需要处理的问题，似乎没有哪个项目可以避开它们，我们常常在处理用户的出生年月日、注册日期，订单的创建时间等属性时用到，由此可见其重要性。
java.util.Date类
提到日期和时间，我想大家最先想到应该是java.util.Date类吧。
Date类可以精确到毫秒数，这个毫秒数是相对于格林威治标准时间“1970-01-0100:
00:
00.000GMT”的差值。
那么，什么是格林威治标准时间呢？
要回答这个问题，我们需要先来了解一下世界时间标准方面的知识。
世界时间标准主要有UTC，即CoordinatedUniversalTime（中文名译作世界协调时间、世界统一时间或世界标准时间），以及GMT，即GreenwichMeanTime（中文名译作格林威治标准时间或格林威治平均时间）两种。
严格来讲，UTC比GMT更加精确一些，不过它们的差值不会超过0.9秒，如果超过了，将会为UTC增加闰秒以与GMT，也就是地球自转周期保持一致。
所以在日常使用中，我们可以把UTC和GMT一样看待。
日期和时间的表示是与我们所处的时区相关联的，如果我们不指定时区，那么它们将以系统默认的时区来显示。
我们先来看看如何创建日期对象。
Date类有很多个构造器方法，大部分已经不被赞成使用了（Deprecated），不过还剩下两个可以使用的：
Java代码
1.public Date（） {
2. this（System.currentTimeMillis（））;
3.}
4.
5.public Date（long date） {
6. //other code
7.}
publicDate（）{
this（System.currentTimeMillis（））;
}
publicDate（longdate）{
//othercode
}
第一个是无参构造器，使用系统当前时间的毫秒数来创建Date对象，它调用了java.lang.System类的currentTimeMillis（）来取得系统的当前时间的毫秒值。
这是个本地方法，它的定义如下：
Java代码
1.public static native long currentTimeMillis（）;
publicstaticnativelongcurrentTimeMillis（）;
第二个构造器是根据给定的毫秒数来创建一个与之对应的Date对象，这个毫秒数决定了被创建对象的年、月、日、时、分、秒属性的值。
我们来看看日期和时间在默认时区下的显示效果：
Java代码
1.import java.util.Date;
2.
3.public class DateTest {
4. public static void main（String[] args） {
5. Date d = new Date（）;
6. // 在默认时区下输出日期和时间值
7. System.out.println（d）;
8. }
9.}
importjava.util.Date;
publicclassDateTest{
publicstaticvoidmain（String[]args）{
Dated=newDate（）;
//在默认时区下输出日期和时间值
System.out.println（d）;
}
}
运行结果：
∙TueJul2210:
44:
47CST2008
大家应该注意到了年份前的“CST”标识，它是ChinaStandardTime的缩写，指的是中国标准时间，也就是我们常说的北京时间。
它与UTC的时差是UTC+8:
00，就是说北京时间比世界标准时间早8个小时，如果世界标准时间是早上1点，北京时间就是早上9点。
一般情况下我们不需要关心时区问题。
在创建完Date对象之后，我们可以通过调用getTime（）方法来获得该对象的毫秒数值，调用setTime（longtime）方法来设置它的毫秒数值，从而影响年、月、日、时、分、秒这些属性。
这两个方法的定义如下：
Java代码
1.public long getTime（） {
2. //other code
3.}
4.
5.public void setTime（long time） {
6. //other code
7.}
publiclonggetTime（）{
//othercode
}
publicvoidsetTime（longtime）{
//othercode
}
既然Date对象可以表示盛相对于“1970-01-0100:
00:
00.000GMT”的毫秒数，我们自然可以通过这个值来比较两个日期的大小了，不过对于日期来讲，前后的说法应该更为恰当。
而Date类已经为我们提供了这样的方法：
Java代码
1.public boolean before（Date when） {
2. //other code
3.}
4.
5.public boolean after（Date when） {
6. //other code
7.}
8.
9.public int compareTo（Date anotherDate） {
10. //other code
11.}
publicbooleanbefore（Datewhen）{
//othercode
}
publicbooleanafter（Datewhen）{
//othercode
}
publicintcompareTo（DateanotherDate）{
//othercode
}
before（）是判断当前日期是否在参数日期之前，即当前日期毫秒数小于参数日期毫秒数；after（）是判断当前日期是否在参数日期之后，即当前日期毫秒数大于参数日期毫秒数。
而compareTo（）是将当前日期与参数日期比较后，返回一个int型值，它的返回值有三种可能：
-1、0和1。
如果返回-1则表示当前日期在参数日期之前；如果返回0则表示两个日期是同一时刻；返回1则表示当前日期在参数日期之后。
虽然我们可以用compareTo（）方法来比较两个Date对象，但是它的设计实际是另有用途的，我们在后面的章节将会讲到。
下面我们就用一个示例来检验一下以上方法的用法：
Java代码
1.import java.util.Date;
2.
3.public class DateTest {
4. public static void main（String[] args） {
5. // 2008-08-08 20:
00:
00对应的毫秒数
6. long t2008 = 1218196800000L;
7. // 1900-01-01 20:
00:
00对应的毫秒数
8. long t1900 = -2208945952000L;
9.
10. // 指定毫秒数创建Date对象
11. Date d2008 = new Date（t2008）;
12. // 使用系统默认时间创建Date对象
13. Date d1900 = new Date（）;
14. // 通过设置毫秒数改变日期和时间
15. d1900.setTime（t1900）;
16.
17. System.out.println（"调用方法：
d1900.before（d2008）"）;
18. System.out
19. .print（"比较结果：
\"1900-01-01 20:
00:
00\"在\"2008-08-08 20:
00:
00\""）;
20. // 使用before（）方法比较
21. if （d1900.before（d2008）） {
22. System.out.println（"之前"）;
23. } else {
24. System.out.println（"之后"）;
25. }
26.
27. System.out.println（）;
28.
29. System.out.println（"调用方法：
d2008.after（d1900）"）;
30. System.out
31. .print（"比较结果：
\"2008-08-08 20:
00:
00\"在\"1900-01-01 20:
00:
00\""）;
32. // 使用after（）方法比较
33. if （d2008.after（d1900）） {
34. System.out.println（"之后"）;
35. } else {
36. System.out.println（"之前"）;
37. }
38.
39. System.out.println（）;
40.
41. System.out.println（"调用方法：
pareTo（d2008）"）;
42. System.out
43. .print（"比较结果：
\"1900-01-01 20:
00:
00\"在\"2008-08-08 20:
00:
00\""）;
44. // 使用compareTo（）方法比较
45. int i = pareTo（d2008）;
46. if （i == -1） {
47. System.out.println（"之前"）;
48. } else if （i == 1） {
49. System.out.println（"之后"）;
50. } else if （i == 0） {
51. System.out.println（"是同一时刻"）;
52. }
53. }
54.}
importjava.util.Date;
publicclassDateTest{
publicstaticvoidmain（String[]args）{
//2008-08-0820:
00:
00对应的毫秒数
longt2008=1218196800000L;
//1900-01-0120:
00:
00对应的毫秒数
longt1900=-2208945952000L;
//指定毫秒数创建Date对象
Dated2008=newDate（t2008）;
//使用系统默认时间创建Date对象
Dated1900=newDate（）;
//通过设置毫秒数改变日期和时间
d1900.setTime（t1900）;
System.out.println（"调用方法：
d1900.before（d2008）"）;
System.out
.print（"比较结果：
\"1900-01-0120:
00:
00\"在\"2008-08-0820:
00:
00\""）;
//使用before（）方法比较
if（d1900.before（d2008））{
System.out.println（"之前"）;
}else{
System.out.println（"之后"）;
}
System.out.println（）;
System.out.println（"调用方法：
d2008.after（d1900）"）;
System.out
.print（"比较结果：
\"2008-08-0820:
00:
00\"在\"1900-01-0120:
00:
00\""）;
//使用after（）方法比较
if（d2008.after（d1900））{
System.out.println（"之后"）;
}else{
System.out.println（"之前"）;
}
System.out.println（）;
System.out.println（"调用方法：
pareTo（d2008）"）;
System.out
.print（"比较结果：
\"1900-01-0120:
00:
00\"在\"2008-08-0820:
00:
00\""）;
//使用compareTo（）方法比较
inti=pareTo（d2008）;
if（i==-1）{
System.out.println（"之前"）;
}elseif（i==1）{
System.out.println（"之后"）;
}elseif（i==0）{
System.out.println（"是同一时刻"）;
}
}
}
运行结果：
1.调用方法：
d1900.before（d2008）
2.比较结果：
"1900-01-0120:
00:
00"在"2008-08-0820:
00:
00"之前
3.调用方法：
d2008.after（d1900）
4.比较结果：
"2008-08-0820:
00:
00"在"1900-01-0120:
00:
00"之后
5.调用方法：
pareTo（d2008）
6.比较结果：
"1900-01-0120:
00:
00"在"2008-08-0820:
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.}
publicstaticCalendargetInstance（）{
//othercode
}
采用上面这个方法时，我们创建的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.
6.public class DateTest {
7. /**
8. * 以一种较为友好的方式格式化日期时间值
9. *
10. * @param c
11. * 日期时间对象
12. * @return 格式化后的日期时间字符串
13. */
14. public static String toFriendlyString（Calendar c） {
15. if （c !
= null） {
16. DateFormat df = new SimpleDateFormat（"yyyy年MM月dd日 HH:
mm:
ss"）;
17. return df.format（c.getTime（））;
18. }
19. return null;
20. }
21.
22. public static void main（String[] args） {
23. Calendar c1 = Calendar.getInstance（）;
24. System.out.println（"创建方式：
Calendar.getInstance（）"）;
25. System.out.println（"日期时间：
" + DateTest.toFriendlyString（c1））;
26. System.out.println（）;
27.
28. Calendar c2 = new GregorianCalendar（）;
29. System.out.println（"创建方式：
new GregorianCalendar（）"）;
30. System.out.println（"日期时间：
" + DateTest.toFriendlyString（c2））;
31. System.out.println（）;
32.
33. // 参数含义依次为：
年、月、日
34. Calendar c3 = new GregorianCalendar（2008, 8, 8）;
35. System.out.println（"创建方式：
new GregorianCalendar（2008, 8, 8）"）;
36. System.out.println（"日期时间：
" + DateTest.toFriendlyString（c3））;
37. System.out.println（）;
38.
39. // 参数含义依次为：
年、月、日、时、分
40. Calendar c4 = new GregorianCalendar（2008, 8, 8, 6, 10）;
41. System.out.println（"创建方式：
new GregorianCalendar（2008, 8, 8, 6, 10）"）;
42. System.out.println（"日期时间：
" + DateTest.toFriendlyString（c4））;
43. System.out.println（）;
44.
45. // 参数含义依次为：
年、月、日、时、分、秒
46. Calendar c5 = new GregorianCalendar（2008, 8, 8, 18, 10, 5）;
47. System.out.println（"创建方式：
new GregorianCalendar（2008, 8, 8, 18, 10, 5）"）;
48. System.out.println（"日期时间：
" + DateTest.toFriendlyString（c5））;
49. }
50.}
importjava.text.DateFormat;
importjava.text.SimpleDateFormat;
importjava.util.Calendar;
importjava.util.GregorianCalendar;
publicclassDateTest{
/**
*以一种较为友好的方式格式化日期时间值
*
*@paramc
*日期时间对象
*@return格式化后的日期时间字符串
*/
publicstaticStringtoFriendlyString（Calendarc）{
if（c!
=null）{
DateFormatdf=newSimpleDateFormat（"yyyy年MM月dd日HH:
mm:
ss"）;
returndf.format（c.getTime（））;
}
returnnull;
}
publicstaticvoidmain（String[]args）{
Cale
升级会员 