`

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

Java面试CC++C# 
阅读更多

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

关键字: java 面试题 日期 时间 转换

作者：臧圩人（zangweiren）
网址：http://zangweiren.iteye.com

>>>转载请注明出处！ <<<

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

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.   
  5. public  Date( long  date) {  
  6.     //other code   
  7. }   
public Date() {
    this(System.currentTimeMillis());
}

public Date(long date) {
    //other code
}

第一个是无参构造器，使用系统当前时间的毫秒数来创建Date对象，它调用了java.lang.System类的currentTimeMillis()来取得系统的当前时间的毫秒值。这是个本地方法，它的定义如下：
Java代码 复制代码
  1. public   static   native   long  currentTimeMillis();   
public static native long currentTimeMillis();

第二个构造器是根据给定的毫秒数来创建一个与之对应的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. }   
import java.util.Date;

public class DateTest {
	public static void main(String[] args) {
		Date d = new Date();
		// 在默认时区下输出日期和时间值
		System.out.println(d);
	}
}

运行结果：
  • 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.   
  5. public   void  setTime( long  time) {  
  6.     //other code   
  7. }   
public long getTime() {
    //other code
}

public void setTime(long time) {
    //other code
}

既然Date对象可以表示盛相对于“1970-01-01 00:00:00.000 GMT”的毫秒数，我们自然可以通过这个值来比较两个日期的大小了，不过对于日期来讲，前后的说法应该更为恰当。而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. }   
public boolean before(Date when) {
    //other code
}

public boolean after(Date when) {
    //other code
}

public int compareTo(Date anotherDate) {
    //other code
}

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("调用方法：d1900.compareTo(d2008)" );  
  42.         System.out  
  43.                 .print("比较结果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"" );  
  44.         // 使用compareTo()方法比较   
  45.         int  i = d1900.compareTo(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. }   
import java.util.Date;

public class DateTest {
	public static void main(String[] args) {
		// 2008-08-08 20:00:00对应的毫秒数
		long t2008 = 1218196800000L;
		// 1900-01-01 20:00:00对应的毫秒数
		long t1900 = -2208945952000L;

		// 指定毫秒数创建Date对象
		Date d2008 = new Date(t2008);
		// 使用系统默认时间创建Date对象
		Date d1900 = new Date();
		// 通过设置毫秒数改变日期和时间
		d1900.setTime(t1900);

		System.out.println("调用方法：d1900.before(d2008)");
		System.out
				.print("比较结果：\"1900-01-01 20:00:00\"在\"2008-08-08 20: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-08 20:00:00\"在\"1900-01-01 20:00:00\"");
		// 使用after()方法比较
		if (d2008.after(d1900)) {
			System.out.println("之后");
		} else {
			System.out.println("之前");
		}
		
		System.out.println();
		
		System.out.println("调用方法：d1900.compareTo(d2008)");
		System.out
				.print("比较结果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"");
		// 使用compareTo()方法比较
		int i = d1900.compareTo(d2008);
		if (i == -1) {
			System.out.println("之前");
		} else if (i == 1) {
			System.out.println("之后");
		} else if (i == 0) {
			System.out.println("是同一时刻");
		}
	}
}

运行结果：
  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. }   
public static Calendar getInstance(){
    //other code
}

采用上面这个方法时，我们创建的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. }   
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class DateTest {
	/**
	 * 以一种较为友好的方式格式化日期时间值
	 * 
	 * @param c
	 *            日期时间对象
	 * @return 格式化后的日期时间字符串
	 */
	public static String toFriendlyString(Calendar c) {
		if (c != null) {
			DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
			return df.format(c.getTime());
		}
		return null;
	}

	public static void main(String[] args) {
		Calendar c1 = Calendar.getInstance();
		System.out.println("创建方式：Calendar.getInstance()");
		System.out.println("日期时间：" + DateTest.toFriendlyString(c1));
		System.out.println();

		Calendar c2 = new GregorianCalendar();
		System.out.println("创建方式：new GregorianCalendar()");
		System.out.println("日期时间：" + DateTest.toFriendlyString(c2));
		System.out.println();

		// 参数含义依次为：年、月、日
		Calendar c3 = new GregorianCalendar(2008, 8, 8);
		System.out.println("创建方式：new GregorianCalendar(2008, 8, 8)");
		System.out.println("日期时间：" + DateTest.toFriendlyString(c3));
		System.out.println();

		// 参数含义依次为：年、月、日、时、分
		Calendar c4 = new GregorianCalendar(2008, 8, 8, 6, 10);
		System.out.println("创建方式：new GregorianCalendar(2008, 8, 8, 6, 10)");
		System.out.println("日期时间：" + DateTest.toFriendlyString(c4));
		System.out.println();

		// 参数含义依次为：年、月、日、时、分、秒
		Calendar c5 = new GregorianCalendar(2008, 8, 8, 18, 10, 5);
		System.out.println("创建方式：new GregorianCalendar(2008, 8, 8, 18, 10, 5)");
		System.out.println("日期时间：" + DateTest.toFriendlyString(c5));
	}
}

运行结果如下：
  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. }   
public int get(int field){
    //other code
}

我们以一个示例来说明get(int field)方法所能接受的一些常用参数的含义及用法：
Java代码 复制代码
  1. import  java.text.DateFormat;  
  2. import  java.text.SimpleDateFormat;  
  3. import  java.util.Calendar;  
  4.   
  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.SSS" );  
  16.             return  df.format(c.getTime());  
  17.         }  
  18.         return   null ;  
  19.     }  
  20.   
  21.     public   static   void  main(String[] args) {  
  22.         Calendar c = Calendar.getInstance();  
  23.         System.out.println("当前时刻："  + DateTest.toFriendlyString(c));  
  24.         System.out.println();  
  25.   
  26.         System.out.println("属性名称：Calendar.AM_PM" );  
  27.         System.out.println("代表含义：上下午标识，上午返回Calendar.AM=0，下午返回Calendar.PM=1" );  
  28.         System.out.println("测试结果："  + c.get(Calendar.AM_PM));  
  29.         System.out.println();  
  30.   
  31.         System.out.println("属性名称：Calendar.DATE" );  
  32.         System.out.println("代表含义：一个月中的第几天，同Calendar.DAY_OF_MONTH" );  
  33.         System.out.println("测试结果："  + c.get(Calendar.DATE));  
  34.         System.out.println();  
  35.   
  36.         System.out.println("属性名称：Calendar.DAY_OF_MONTH" );  
  37.         System.out.println("代表含义：一个月中的第几天，同Calendar.DATE" );  
  38.         System.out.println("测试结果："  + c.get(Calendar.DAY_OF_MONTH));  
  39.         System.out.println();  
  40.   
  41.         System.out.println("属性名称：Calendar.DAY_OF_WEEK" );  
  42.         System.out.println("代表含义：一周中的第几天，对应星期几，第一天为星期日，于此类推。" );  
  43.         System.out.println("星期日:Calendar.SUNDAY=1" );  
  44.         System.out.println("星期一:Calendar.MONDAY=2" );  
  45.         System.out.println("星期二:Calendar.TUESDAY=3" );  
  46.         System.out.println("星期三:Calendar.WEDNESDAY=4" );  
  47.         System.out.println("星期四:Calendar.THURSDAY=5" );  
  48.         System.out.println("星期五:Calendar.FRIDAY=6" );  
  49.         System.out.println("星期六:Calendar.SATURDAY=7" );  
  50.         System.out.println("测试结果："  + c.get(Calendar.DAY_OF_WEEK));  
  51.         System.out.println();  
  52.   
  53.         System.out.println("属性名称：Calendar.DAY_OF_WEEK_IN_MONTH" );  
  54.         System.out.println("代表含义：这一天所对应的星期几在该月中是第几次出现" );  
  55.         System.out.println("测试结果："  + c.get(Calendar.DAY_OF_WEEK_IN_MONTH));  
  56.         System.out.println();  
  57.   
  58.         System.out.println("属性名称：Calendar.DAY_OF_YEAR" );  
  59.         System.out.println("代表含义：一年中的第几天" );  
  60.         System.out.println("测试结果："  + c.get(Calendar.DAY_OF_YEAR));  
  61.         System.out.println();  
  62.   
  63.         System.out.println("属性名称：Calendar.HOUR" );  
  64.         System.out.println("代表含义：12小时制下的小时数，中午和午夜表示为0" );  
  65.         System.out.println("测试结果："  + c.get(Calendar.HOUR));  
  66.         System.out.println();  
  67.   
  68.         System.out.println("属性名称：Calendar.HOUR_OF_DAY" );  
  69.         System.out.println("代表含义：24小时制下的小时数，午夜表示为0" );  
  70.         System.out.println("测试结果："  + c.get(Calendar.HOUR_OF_DAY));  
  71.         System.out.println();  
  72.   
  73.         System.out.println("属性名称：Calendar.MILLISECOND" );  
  74.         System.out.println("代表含义：毫秒数" );  
  75.         System.out.println("测试结果："  + c.get(Calendar.MILLISECOND));  
  76.         System.out.println();  
  77.   
  78.         System.out.println("属性名称：Calendar.MINUTE" );  
  79.         System.out.println("代表含义：分钟" );  
  80.         System.out.println("测试结果："  + c.get(Calendar.MINUTE));  
  81.         System.out.println();  
  82.   
  83.         System.out.println("属性名称：Calendar.MONTH" );  
  84.         System.out.println("代表含义：月份，从0到11表示12个月份，比实际月份值小1" );  
  85.         System.out.println("测试结果："  + c.get(Calendar.MONTH));  
  86.         System.out.println();  
  87.   
  88.         System.out.println("属性名称：Calendar.SECOND" );  
  89.         System.out.println("代表含义：秒" );  
  90.         System.out.println("测试结果："  + c.get(Calendar.SECOND));  
  91.         System.out.println();  
  92.   
  93.         System.out.println("属性名称：Calendar.WEEK_OF_MONTH" );  
  94.         System.out.println("代表含义：一个月中的第几个星期" );  
  95.         System.out.println("测试结果："  + c.get(Calendar.WEEK_OF_MONTH));  
  96.         System.out.println();  
  97.   
  98.         System.out.println("属性名称：Calendar.WEEK_OF_YEAR" );  
  99.         System.out.println("代表含义：一年中的第几个星期" );  
  100.         System.out.println("测试结果："  + c.get(Calendar.WEEK_OF_YEAR));  
  101.         System.out.println();  
  102.   
  103.         System.out.println("属性名称：Calendar.YEAR" );  
  104.         System.out.println("代表含义：年份" );  
  105.         System.out.println("测试结果："  + c.get(Calendar.YEAR));  
  106.     }  
  107. }   
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class DateTest {
	/**
	 * 以一种较为友好的方式格式化日期时间值
	 * 
	 * @param c
	 *            日期时间对象
	 * @return 格式化后的日期时间字符串
	 */
	public static String toFriendlyString(Calendar c) {
		if (c != null) {
			DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss.SSS");
			return df.format(c.getTime());
		}
		return null;
	}

	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		System.out.println("当前时刻：" + DateTest.toFriendlyString(c));
		System.out.println();

		System.out.println("属性名称：Calendar.AM_PM");
		System.out.println("代表含义：上下午标识，上午返回Calendar.AM=0，下午返回Calendar.PM=1");
		System.out.println("测试结果：" + c.get(Calendar.AM_PM));
		System.out.println();

		System.out.println("属性名称：Calendar.DATE");
		System.out.println("代表含义：一个月中的第几天，同Calendar.DAY_OF_MONTH");
		System.out.println("测试结果：" + c.get(Calendar.DATE));
		System.out.println();

		System.out.println("属性名称：Calendar.DAY_OF_MONTH");
		System.out.println("代表含义：一个月中的第几天，同Calendar.DATE");
		System.out.println("测试结果：" + c.get(Calendar.DAY_OF_MONTH));
		System.out.println();

		System.out.println("属性名称：Calendar.DAY_OF_WEEK");
		System.out.println("代表含义：一周中的第几天，对应星期几，第一天为星期日，于此类推。");
		System.out.println("星期日:Calendar.SUNDAY=1");
		System.out.println("星期一:Calendar.MONDAY=2");
		System.out.println("星期二:Calendar.TUESDAY=3");
		System.out.println("星期三:Calendar.WEDNESDAY=4");
		System.out.println("星期四:Calendar.THURSDAY=5");
		System.out.println("星期五:Calendar.FRIDAY=6");
		System.out.println("星期六:Calendar.SATURDAY=7");
		System.out.println("测试结果：" + c.get(Calendar.DAY_OF_WEEK));
		System.out.println();

		System.out.println("属性名称：Calendar.DAY_OF_WEEK_IN_MONTH");
		System.out.println("代表含义：这一天所对应的星期几在该月中是第几次出现");
		System.out.println("测试结果：" + c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
		System.out.println();

		System.out.println("属性名称：Calendar.DAY_OF_YEAR");
		System.out.println("代表含义：一年中的第几天");
		System.out.println("测试结果：" + c.get(Calendar.DAY_OF_YEAR));
		System.out.println();

		System.out.println("属性名称：Calendar.HOUR");
		System.out.println("代表含义：12小时制下的小时数，中午和午夜表示为0");
		System.out.println("测试结果：" + c.get(Calendar.HOUR));
		System.out.println();

		System.out.println("属性名称：Calendar.HOUR_OF_DAY");
		System.out.println("代表含义：24小时制下的小时数，午夜表示为0");
		System.out.println("测试结果：" + c.get(Calendar.HOUR_OF_DAY));
		System.out.println();

		System.out.println("属性名称：Calendar.MILLISECOND");
		System.out.println("代表含义：毫秒数");
		System.out.println("测试结果：" + c.get(Calendar.MILLISECOND));
		System.out.println();

		System.out.println("属性名称：Calendar.MINUTE");
		System.out.println("代表含义：分钟");
		System.out.println("测试结果：" + c.get(Calendar.MINUTE));
		System.out.println();

		System.out.println("属性名称：Calendar.MONTH");
		System.out.println("代表含义：月份，从0到11表示12个月份，比实际月份值小1");
		System.out.println("测试结果：" + c.get(Calendar.MONTH));
		System.out.println();

		System.out.println("属性名称：Calendar.SECOND");
		System.out.println("代表含义：秒");
		System.out.println("测试结果：" + c.get(Calendar.SECOND));
		System.out.println();

		System.out.println("属性名称：Calendar.WEEK_OF_MONTH");
		System.out.println("代表含义：一个月中的第几个星期");
		System.out.println("测试结果：" + c.get(Calendar.WEEK_OF_MONTH));
		System.out.println();

		System.out.println("属性名称：Calendar.WEEK_OF_YEAR");
		System.out.println("代表含义：一年中的第几个星期");
		System.out.println("测试结果：" + c.get(Calendar.WEEK_OF_YEAR));
		System.out.println();

		System.out.println("属性名称：Calendar.YEAR");
		System.out.println("代表含义：年份");
		System.out.println("测试结果：" + c.get(Calendar.YEAR));
	}
}

运行结果如下：
  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.   
  5. public   final   void  setTime(Date date) {  
  6.     //other code   
  7. }   
public final Date getTime() {
    //other code
}

public final void setTime(Date date) {
    //other code
}

分享到：
| java 面试题 初始化
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA面试题解惑系列合集

    .36 1.7 JAVA面试题解惑系列（七）——日期和时间的处理 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46 1.8 JAVA面试题解惑系列（八）——聊聊基本类型（内置类型） . . . . . ....

    臧圩人--JAVA面试题解惑系列合集.pdf

    **1.7 JAVA面试题解惑系列（七）——日期和时间的处理** - **知识点**：介绍Java中日期和时间API的使用，重点在于`Date`、`Calendar`类以及新引入的`java.time`包下的类如`LocalDate`、`LocalTime`、`ZonedDateTime...

    JAVA面试题解惑系列——类的初始化顺序

    总结来说，对于Java面试中常出现的关于类初始化顺序的问题，开发者应当掌握以下几点： 1. 单个类内成员的初始化顺序：静态变量、静态初始化块、变量、初始化块、构造器。 2. 在继承关系中，子类的静态成员会在父类...

    JAVA面试题解惑系列(一)——类的初始化顺序-JAVA程序员JAVA工程师面试必看.pdf，这是一份不错的文件

    JAVA面试题解惑系列（一）——类的初始化顺序 JAVA 是一门面向对象的编程语言，类的初始化顺序是 JAVA 程序员和 JAVA 工程师面试中一个非常重要的知识点。本文将详细讲解类的初始化顺序，并提供了相关的测试代码，...

    Java面试题详解，和一些基础知识的深入剖析，个人认为非常棒

    “JAVA面试题解惑系列（七）——日期和时间的处理”讨论的是Java中处理日期和时间的API，早期的java.util.Date和Calendar已经逐渐被Java 8引入的java.time包取代，后者提供了更加直观和易用的接口。 “JAVA面试题...

    Java面试题解惑系列

    ### Java面试题解惑系列——类的初始化顺序 在Java面试过程中，经常会出现关于类的初始化顺序的问题。这类问题通常涉及静态与非静态成员变量、静态初始化块、非静态初始化块以及构造函数的执行顺序。下面我们将深入...

    JAVA面试题解惑系列.doc

    《JAVA面试题解惑系列——类的初始化顺序》 在Java编程中，理解类的初始化顺序是面试中常见的考察点，因为它直接关系到程序的执行逻辑。本文将深入探讨类的初始化过程，以及在继承场景下如何理解这个过程。 首先，...

    面试题解惑系列(十)——话说多线程

    【标题】：“面试题解惑系列(十)——话说多线程” 【描述】：本篇文章主要探讨的是Java中的多线程概念及其在面试中常见的问题解析。 【标签】：“面试题解惑系列(十)——话说多线程” 【部分内容】：在Java中，多...

    JAVA面试题解惑系列(二)——到底创建了几个String对象-JAVA程序员JAVA工程师面试必看.pdf，这是一份不错的文件

    JAVA 面试题解惑系列之 String 对象创建机制 本文将深入探讨 JAVA 中 String 对象的创建机制，解答常见的面试题目，并探索 String 对象池的概念和机制。 一、String 对象的创建方式 在 JAVA 中，String 对象可以...

    经典JAVA面试题解惑系列合集

    JAVA面试题解惑系列（一）——类的初始化顺序 在Java编程语言中，理解类的初始化顺序是非常重要的，尤其是在涉及继承的情况下。本节将详细介绍类初始化的规则，并通过实例来帮助理解。 ##### 类的初始化顺序规则 ...

    JAVA面试题解惑系列.pdf

    ### Java面试题解惑系列——类的初始化顺序详解 #### 背景介绍 在Java面试过程中，关于类的初始化顺序的问题是常见的考察点之一。此类问题通常涉及到类的加载机制、静态变量与实例变量的区别、初始化块的作用及执行...

    JAVA面试题解惑系列(一)——类的初始化顺序-JAVA程序员JAVA工程师面试必看.pdf

    尤其对于那些准备应对技术面试的Java程序员和工程师来说，掌握这一知识点是面试时的必备能力之一。本文将深入探讨Java中类的初始化顺序，特别是在有继承关系的情况下，各个初始化阶段的执行流程，以及这一顺序的重要...

    JAVA面试题解惑系列合集.docx

    ### JAVA面试题解惑系列知识点总结 #### 一、类的初始化顺序 **知识点概述：** 在Java中，类的初始化顺序是一个常见的面试问题。它主要涉及到类成员（包括静态和非静态）的加载和初始化过程。理解这些基础知识有助...

    ‘’JAVA面试题解惑系列.doc

    《JAVA面试题解惑系列——类的初始化顺序》 在Java面试中，关于类的初始化顺序是一个常见的考点。深入理解这一概念，对于成为一名合格的Java开发者至关重要。在Java中，类的初始化顺序遵循一定的规则，这包括静态...

    JAVA面试题解惑系列(六)——字符串(String)杂谈[收集].pdf

    总的来说，理解和掌握`String`类的`length()`方法、字符数组与字符串的区别以及Unicode编码在Java中的应用，是Java程序员必备的基础技能，也是面试中常见的问题。对于处理中文字符，需要特别注意字符编码的细节，以...

    JAVA面试题解惑系列by(zangweiren)

    ### JAVA面试题解惑系列——类的初始化顺序 #### 一、基础知识回顾 在Java编程中，类的初始化顺序是一个非常重要的概念，特别是在面试时，它经常被用来考察面试者对于Java类加载机制的理解程度。类的初始化顺序...

    2021最新java面试合集pdf.rar

    JAVA面试题解惑系列.pdf Java面试题（基础）.pdf JVM 实用参数系列 - v1.0.pdf JVM与性能优化知识点整理.pdf JVM面试专题.docx JVM面试专题及答案.pdf Linux系统Redis笔记.docx MongoDB学习笔记.docx mybatis原理....

    （感谢所有超版和普版以及所有鹏友）

    - **《Java应该怎么学》的讲课宗旨和学习方法**：详细介绍了学习Java编程的最佳路径，包括基础知识、进阶技术和实战经验等。 ### 就业与职业发展 - **杨中科微软面试分享**：通过一位成功通过微软面试的同学的经历...

Magicbox
Global site tag (gtag.js) - Google Analytics