Top

JAVA SE01 Unit03

使用setTime和getTime方法操作时间毫秒
使用format方法格式化日期
使用parse方法将字符串解析为日期
测试getInstance方法
调用set方法设置日期分量
调用get方法获取日期分量
输出某一年的各个月份的天数
输出一年后再减去3个月的日期
使Date表示的日期与Calendar表示的日期进行互换
测试集合持有对象
使用add方法向集合中添加元素
使用contains方法判断集合中是否包含某元素
测试方法size、clear、isEmpty的用法

1 使用setTime和getTime方法操作时间毫秒

1.1 问题

使用setTime和getTime方法操作毫秒表示的日期-时间，详细要求如下：

1）获取1970年1月1日零时距当前时刻的毫秒数。

2）获取明天此时此刻的日期-时间。

1.2 方案

1）首先，实例化Date类的对象获取当前日期-时间，代码如下所示：

Date date = new Date();

然后，调用Date类的getTime方法，获取1970年1月1日零时距当前时刻的毫秒数，代码如下：

long time = date.getTime();

2）首先，实例化Date类的对象获取当前日期-时间date对象，然后，调用Date类的getTime方法，获取1970年1月1日零时距当前时刻的毫秒数，并计算当前日期-时间增加一天后的毫秒数，最后，调用Date类的setTime方法将当前日期-时间date设置为增加一天后的日期-时间。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

首先，在名为JavaSE的工程下的src下新建名为day03的包，然后，在该包下新建类TestDate，在该类中添加测试方法testGetTime，代码如下所示：

package day03;

import java.util.Date;
import org.junit.Test;

public class TestDate {
	/**
	 * 测试getTime方法
	 */
	@Test
	public void testGetTime() {

	}
}

步骤二：获取1970年1月1日零时距当前时刻的毫秒数

首先，实例化Date类的对象获取当前时间；然后，调用Date类的getTime方法，获取1970年1月1日零时距当前时刻的毫秒数，代码如下所示：

package day03;

import java.util.Date;
import org.junit.Test;

public class TestDate {
	/**
	 * 测试testGetTime方法
	 */
	@Test
	public void testGetTime() {
#cold_bold		Date date = new Date();
#cold_bold		System.out.println(date);
#cold_bold
#cold_bold		// 1970年1月1日零时距此刻的毫秒数
#cold_bold		long time = date.getTime();
#cold_bold
#cold_bold		System.out.println(time);
	}
}

步骤三：运行

运行testGetTime方法，运行结果如下所示：

Mon Jan 13 17:56:52 CST 2014
1389607012302

观察输出结果，运行testGetTime方法时的日期-时间为2014年1月13日17:56:52 ，1970年1月1日零时距该时刻的毫秒数为1389607012302。

步骤四：实现当前日期-时间基础上增加一天

首先，获取当前日期-时间date，然后，调用Date类的getTime方法，获取1970年1月1日零时距当前时刻的毫秒数，并计算当前日期-时间增加一天后的毫秒数，最后，调用Date类的setTime方法将当前日期-时间date设置为增加一天后的日期和时间，代码如下所示：

package day03;

import java.util.Date;
import org.junit.Test;

public class TestDate {
	/**
	 * 测试testGetTime方法
	 */
	@Test
	public void testGetTime() {
		Date date = new Date();
		System.out.println(date);

		// 1970年1月1日零时距此刻的毫秒数
		long time = date.getTime();

		System.out.println(time); 
	}

#cold_bold	/**
#cold_bold	 * 测试testSetTime方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testSetTime() {
#cold_bold		Date date = new Date();
#cold_bold		
#cold_bold		// 输出当天此时此刻的日期和时间
#cold_bold		System.out.println(date);
#cold_bold
#cold_bold		long time = date.getTime();
#cold_bold
#cold_bold		// 增加一天所经历的毫秒数
#cold_bold		time += 60 * 60 * 24 * 1000;
#cold_bold
#cold_bold		date.setTime(time);
#cold_bold
#cold_bold		// 输出明天此时此刻的日期和时间
#cold_bold		System.out.println(date);
#cold_bold	}
}

步骤五：运行

运行testSetTime方法，运行结果如下所示：

Mon Jan 13 18:02:38 CST 2014
Tue Jan 14 18:02:38 CST 2014

观察输出结果，运行testSetTime方法时的时间日期为2014年1月13日18:02:38 ，在此时间基础上增加一天后的时间为 2014年1月14日18:02:38。

1.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.util.Date;
import org.junit.Test;

public class TestDate {
	/**
	 * 测试testGetTime方法
	 */
	@Test
	public void testGetTime() {
		Date date = new Date();
		System.out.println(date);

		// 1970年1月1日零时距此刻的毫秒数
		long time = date.getTime();

		System.out.println(time);
	}

	/**
	 * 测试testSetTime方法
	 */
	@Test
	public void testSetTime() {
		Date date = new Date();
		
		// 输出当天此时此刻的日期和时间
		System.out.println(date);

		long time = date.getTime();

		// 增加一天所经历的毫秒数
		time += 60 * 60 * 24 * 1000;

		date.setTime(time);

		// 输出明天此时此刻的日期和时间
		System.out.println(date);
	}
}

2 使用format方法格式化日期

2.1 问题

从上一案例中可以看出，输出日期-时间时显示的默认格式为“Tue Jan 14 18:02:38 CST 2014”，这种输出格式不符合我们日常看时间的形式，我们日常看的时间格式为“2014年1月13日18:02:38”或者为“2014-01-13 18:02:38”。

本案例要求将当前时间日期以“2014-01-13 18:02:38”这样的格式输出到控制台。

2.2 方案

1）实例化SimpleDateFormat类的对象，该类可以使用户选择自定义的日期-时间格式的模式，代码如下所示：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

以上代码中，设置的日期-时间格式为"yyyy-MM-dd HH:mm:ss"。

2）首先，实例化Date类的对象，获取当前日期-时间；然后，调用SimpleDateFormat类的format方法，将Date类的对象格式化为日期-时间字符串，代码如下所示：

Date date = new Date();
String dateStr = sdf.format(date);

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：新建类及测试方法

首先新建名为TestSimpleDateFormat的类，并在该类中新建测试方法testFormat，代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	/**
	 * 测试format方法
	 */
	@Test
	public void testFormat() {
	}
}

步骤二：设置自定义的日期-时间格式

实例化SimpleDateFormat类的对象，该类可以使用户选择自定义的日期-时间格式的模式，代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	/**
	 * 测试format方法
	 */
	@Test
	public void testFormat() {
#cold_bold		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	}
}

步骤三：使用format方法将Date类的对象格式化为日期-时间字符串

首先，实例化Date类的对象，获取当前日期-时间；然后，调用SimpleDateFormat类的format方法，将Date类的对象格式化为日期-时间字符串，代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	/**
	 * 测试format方法
	 */
	@Test
	public void testFormat() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
#cold_bold		Date date = new Date();
#cold_bold		String dateStr = sdf.format(date);
#cold_bold		System.out.println(dateStr);
	}
}

步骤四：运行

运行testFormat方法，运行结果如下所示：

2014-01-15 16:03:41

观察输出结果，可以看出已经将当前日期时间转换为“yyyy-MM-dd HH:mm:ss”格式。

2.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	/**
	 * 测试format方法
	 */
	@Test
	public void testFormat() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = new Date();
		String dateStr = sdf.format(date);
		System.out.println(dateStr);
	}
}

3 使用parse方法将字符串解析为日期

3.1 问题

在上一案例的基础上，将字符串表示的日期"2013-12-25"转换为Date类型表示的日期。

3.2 方案

1）实例化SimpleDateFormat类的对象，该类可以使用户选择自定义的日期-时间格式的模式，代码如下所示：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd);

以上代码中，设置的日期-时间格式为"yyyy-MM-dd",这是因为，我们要转换的时间格式"2013-12-25"要和SimpleDateFormat所构造的格式匹配，才可以进行转换。

2）调用SimpleDateFormat类的parse方法，将日期字符串转换为Date类的对象，代码如下所示：

Date date = sdf.parse(str);

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法及SimpleDateFormat类的对象

首先，在TestSimpleDateFormat类中新建测试方法testParse；然后，实例化SimpleDateFormat类的对象，该类可以使用户选择自定义的日期-时间格式的模式，代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
#cold_bold	/**
#cold_bold	 * 测试parse方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testParse() throws Exception {
#cold_bold		String str = "2013-12-25";
#cold_bold		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
#cold_bold	}
}

请注意，在此处SimpleDateFormat构造的日期格式要和字符串str日期格式相匹配。

步骤二：将日期字符串转换为Date类的对象

调用SimpleDateFormat类的parse方法，将日期字符串转换为Date类的对象，代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	/**
	 * 测试parse方法
	 */
	@Test
	public void testParse() throws Exception {
		String str = "2013-12-25";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
#cold_bold		Date date = sdf.parse(str);
#cold_bold		System.out.println(date);
	}
}

步骤三：运行

运行testParse方法，控制台输出结果如下：

Wed Dec 25 00:00:00 CST 2013

查看输出结果，可以是按照默认时间格式输出的日期-时间。

3.4 完整代码

本案例中，类TestSimpleDateFormat的完整代码如下所示：

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;

public class TestSimpleDateFormat {
	//...（之前案例的代码，略）

	/**
	 * 测试parse方法
	 */
	@Test
	public void testParse() throws Exception {
		String str = "2013-12-25";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date = sdf.parse(str);
		System.out.println(date);
	}
}

4 测试getInstance方法

4.1 问题

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。

本案例要求获取Calendar类的实例，获取实例后做如下操作：

1）获取Calendar实例所属的实际类型，并输出。

2）将Calendar对象转换为Date对象，并输出该Date对象。

3）使用GregorianCalendar构建对象，该对象对应的日期为2013年12月25日，将GregorianCalendar对象转换为Date对象，并输出该Date对象。

4.2 方案

1）首先，使用 Calendar类的getInstance方法获取Calendar类的对象，然后使用下列代码获取该对象所属的实际类型，并输出，代码如下所示：

System.out.println(c.getTime());

2）使用Calendar类的getTime方法，可以将Calendar对象转换为Date对象，然后，输出该Date类的对象。

3）使用GregorianCalendar构建日期为2013年12月25日的对象，然后，GregorianCalendar类的getTime方法将GregorianCalendar对象转换为Date对象，并输出该Date对象。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：创建测试方法

首先新建类TestCalendar；然后，在该类下新建测试方法testGetInstance，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试getInstance方法
	 */
	@Test
	public void testGetInstance() {
		
	}
}

步骤二：创建Calendar类的实例

首先，使用 Calendar类的getInstance方法获取Calendar类的对象，然后使用下列代码获取该对象所属的实际类型，并输出，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试getInstance方法
	 */
	@Test
	public void testGetInstance() {
#cold_bold		Calendar c = Calendar.getInstance();
#cold_bold		// 输出Calendar对象所属的实际类型
#cold_bold		System.out.println(c.getClass().getName());
	}
}

步骤三：运行

运行testGetInstance方法，控制台输出结果如下所示：

java.util.GregorianCalendar

从控制台的输出结果可以看出，对象c所属的实际类型为GregorianCalendar,这是因为，历史上有着许多种纪年方法，它们的差异实在太大了，比如说一个人的生日是“七月七日”，那么一种可能是阳（公）历的七月七日，它也可以是阴（农）历的七月七日。为了统一计时，全世界通常选择最普及、最通用的日历：Gregorian Calendar（格里高历），也就是我们所说的公历。

Calendar类本身是一个抽象类，它是所有日历类的模板，并提供了一些所有日历通用的方法；但它本身不能直接实例化对象，程序只能创建Calendar子类的实例，Java本身提供一个GregorianCalendar类，一个代表格里高历的子类，它代表了我们通常所说的公历。Calendar类提供了几个静态getInstance方法来获取Calendar对象，这些方法根据TimeZone、Locale类来获取特定的Calendar，如果不指定TimeZone、Locale，则使用默认的TimeZone、Locale来创建Calendar对象。

本案例中使用的getInstance方法刚好使用了默认的TimeZone、Locale来创建Calendar对象，通过输出结果可以看出默认的TimeZone、Locale创建的Calendar对象所属的实际类型为GregorianCalendar。

步骤四：将Calendar对象转换为Date对象

使用Calendar类的getTime方法，可以将Calendar对象转换为Date对象，然后，输出该Date类的对象,代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试getInstance方法
	 */
	@Test
	public void testGetInstance() {
		Calendar c = Calendar.getInstance();

		// 输出Calendar对象所属的实际类型
		System.out.println(c.getClass().getName());

#cold_bold		// getTime方法返回对应的Date对象
#cold_bold		System.out.println(c.getTime());
	}
}

步骤五：使用GregorianCalendar构建日期对象

使用GregorianCalendar构建日期为2013年12月25日的对象，然后，GregorianCalendar类的getTime方法将GregorianCalendar对象转换为Date对象，并输出该Date对象，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试getInstance方法
	 */
	@Test
	public void testGetInstance() {
		Calendar c = Calendar.getInstance();

		// 输出Calendar对象所属的实际类型
		System.out.println(c.getClass().getName());

		// getTime方法返回对应的Date对象
		System.out.println(c.getTime());

#cold_bold		// 创建GregorianCalendar对象
#cold_bold		GregorianCalendar c1 = new GregorianCalendar(2013, Calendar.DECEMBER,25);
#cold_bold		System.out.println(c1.getTime());
	}
}

步骤六：运行

运行testGetInstance方法，控制台输出结果如下所示：

java.util.GregorianCalendar
Mon Jan 20 10:40:39 CST 2014
Wed Dec 25 00:00:00 CST 2013

观察上述代码可以看出已经将Calendar对象和GregorianCalendar对象转换为Date对象。

总结前几个案例可以知道时间的表示方式可以是Date、long或者Calendar，它们之间的相互转换如图-1所示。

图- 1

4.4 完整代码

本案例中，类TestCalendar的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试getInstance方法
	 */
	@Test
	public void testGetInstance() {
		Calendar c = Calendar.getInstance();

		// 输出Calendar对象所属的实际类型
		System.out.println(c.getClass().getName());

		// getTime方法返回对应的Date对象
		System.out.println(c.getTime());

		// 创建GregorianCalendar对象
		GregorianCalendar c1 = new GregorianCalendar(2013, Calendar.DECEMBER,
				25);
		System.out.println(c1.getTime());
	}
}

5 调用set方法设置日期分量

5.1 问题

在上一案例的基础上，使用Calendar类的set方法设置日期-时间的各个分量，详细要求如下：

1）使用Calendar类表示时间，设置日期为2013年12月25日，时间为此时此刻的时间，并将该日期-时间日期转换为Date类输出。

2）修改Calendar类的对象，将日期中的日设置为32，其余不变，然后将该日期-时间日期转换为Date类输出。

5.2 方案

使用Calendar类的set方法设置日期时间的各个分量，该方法声明如下：

void set（int field，int value）

该方法表示将给定的日历字段设置为给定值。该方法需要一个int类型的field参数，field是Calendsr类的静态字段，如Calendar.YEAR、Calendar.MONTH等分别代表了年、月、日、小时、分钟、秒等时间字段。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：添加测试方法

在TestCalendar类中添加测试方法testSet，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
#cold_bold	/**
#cold_bold	 * 测试set方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testSet() {
#cold_bold		
#cold_bold	}
}

步骤二：使用Calendar类的set方法设置日期分量

首先，通过Calendar类的getInstance方法获取当前日期-时间；然后，使用set方法将日期改变为2013年12月25日，并将Calendar表示的时间转换为Date表示的时间输出到控制台，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试set方法
	 */
	@Test
	public void testSet() {
#cold_bold		Calendar c = Calendar.getInstance();
#cold_bold		c.set(Calendar.YEAR, 2013);
#cold_bold		c.set(Calendar.MONTH, Calendar.DECEMBER);
#cold_bold		c.set(Calendar.DATE, 25);
#cold_bold		System.out.println(c.getTime()); // Wed Dec 25 16:45:01 CST 2013
	}
}

步骤三：运行

运行testSet方法，控制台输出结果为：

Wed Dec 25 14:53:53 CST 2013

从输出结果可以看出已经将日期设置为2013年12月25日，时间为当前时间。

步骤四：将步骤二中的对象c的日设置31

使用set方法将步骤二中的对象c的“日”设置为32，并将Calendar表示的日期-时间转换为Date表示的日期-时间输出到控制台，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试set方法
	 */
	@Test
	public void testSet() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 2013);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, 25);
		System.out.println(c.getTime()); // Wed Dec 25 16:45:01 CST 2013

#cold_bold		// 实际日期值为1月1日
#cold_bold		c.set(Calendar.DATE, 32);
#cold_bold		System.out.println(c.getTime()); // Wed Jan 01 16:45:01 CST 2014
	}
}

步骤五：运行

运行testSet方法，控制台输出结果为：

Wed Dec 25 14:53:53 CST 2013
Wed Jan 01 14:53:53 CST 2014

可以看出将日设置为32后，日期变化2014年1月1日，这是因为，当被修改的字段超出它允许的范围时，会发生进位，即上一级字段会变大。在本案例中，将日设置为32后，但是，2013年12月只有31天，超出了日允许的范围，因此发生进位，变为1月1日。

5.4 完整代码

本案例中，类TestCalendar的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	//...（之前案例的代码，略）

	/**
	 * 测试set方法
	 */
	@Test
	public void testSet() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 2013);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, 25);
		System.out.println(c.getTime()); // Wed Dec 25 16:45:01 CST 2013

		// 实际日期值为1月1日
		c.set(Calendar.DATE, 32);
		System.out.println(c.getTime()); // Wed Jan 01 16:45:01 CST 2014
	}
}

6 调用get方法获取日期分量

6.1 问题

在上一案例的基础上，使用Calendar类的get方法获取Calendar类表示的日期-时间的各个分量，详细要求为：首先，使用Calendar类表示时间，设置日期为2013年12月25日，时间为此时此刻的时间，然后，获取该日期-时间是周几。

6.2 方案

使用Calendar类的get方法获取Calendar类表示的时间-日期各个分量，该方法的声明如下所示：

int get（int field）

该方法表示返回指定日历字段的值。

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：

首先，为TestCalendar类添加测试方法testGet，然后，在该方法中，首先，通过Calendar类的getInstance方法获取当前日期-时间；然后，使用set方法将日期改变为2013年12月25日，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
#cold_bold	/**
#cold_bold	 * 测试get方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testGet() {
#cold_bold		Calendar c = Calendar.getInstance();
#cold_bold		c.set(Calendar.YEAR, 2013);
#cold_bold		c.set(Calendar.MONTH, Calendar.DECEMBER);
#cold_bold		c.set(Calendar.DATE, 25);
#cold_bold	}
}

步骤二：使用get方法

使用Calendar类的的get方法获取2013年12月25日对应的星期几，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 测试get方法
	 */
	@Test
	public void testGet() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 2013);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, 25);

#cold_bold		int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);
#cold_bold
#cold_bold		System.out.println(dayOfWeek); // 输出为4, 表示周三, 周日为每周的第1天.
	}
}

步骤三：运行

运行testGet方法，控制台输出结果如下所示：

可以看出控制台的输出结果为4, 表示周三, 周日为每周的第1天。

6.4 完整代码

本案例中，类TestCalendar的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	//...（之前案例的代码，略）

	/**
	 * 测试get方法
	 */
	@Test
	public void testGet() {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 2013);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, 25);

		int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);

		System.out.println(dayOfWeek); // 输出为4, 表示周三, 周日为每周的第1天.
	}
}

7 输出某一年的各个月份的天数

7.1 问题

在上一案例的基础上，获取2013年各个月份的天数。

7.2 方案

首先，使用Calendar类的getInstance方法获取当前日期-时间；然后，修改该日期-时间为2013年，日为1日；最后，使用循环，循环从1月循环到12月，在循环中修改当前日期-时间对象的月份，可以使用getActualMaximum方法获取各个月份的天数，该方法的声明如下：

getActualMaximum(int field)

该方法表示给定此 Calendar 的时间值，返回指定日历字段可能拥有的最大值。可以指定日期字段为Calendar.DATE。

7.3 步骤

步骤一：构建测试方法

首先，使用Calendar类的getInstance方法获取当前日期-时间；然后，修改该日期-时间为2013年，日为1日，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
#cold_bold	/**
#cold_bold	 * 输出某一年的各个月份的天数
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testGetActualMaximum() {
#cold_bold		int year = 2013;
#cold_bold		Calendar c = Calendar.getInstance();
#cold_bold		c.set(Calendar.YEAR, year);
#cold_bold		c.set(Calendar.DATE, 1);
#cold_bold	}
}

步骤二：使用getActualMaximum方法

使用循环，循环从1月循环到12月，在循环中修改当前日期-时间对象的月份，可以使用getActualMaximum方法获取各个月份的天数,代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	/**
	 * 输出某一年的各个月份的天数
	 */
	@Test
	public void testGetActualMaximum() {
		int year = 2013;
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, year);
		c.set(Calendar.DATE, 1);

#cold_bold		for (int month = Calendar.JANUARY; month <= Calendar.DECEMBER; month++) {
#cold_bold			c.set(Calendar.MONTH, month);
#cold_bold			System.out.println(year + "年" + (month + 1) + "月："
#cold_bold					+ c.getActualMaximum(Calendar.DATE) + "天");
#cold_bold		}
	}
}

此处需要注意的是，Calenar.MONTH字段表示月份，月份的起始值不是1，而是0，所示需要在取到的月份值的基础上加1才能与实际的月份对应。

步骤三：运行

运行testGetActualMaximum方法，控制台输出结果如下所示：

2013年1月：31天
2013年2月：28天
2013年3月：31天
2013年4月：30天
2013年5月：31天
2013年6月：30天
2013年7月：31天
2013年8月：31天
2013年9月：30天
2013年10月：31天
2013年11月：30天
2013年12月：31天

从输出结果可以看出，已经将2013年的各个月对应的天数获取到了。

7.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	//...（之前案例的代码，略）

	/**
	 * 输出某一年的各个月份的天数
	 */
	@Test
	public void testGetActualMaximum() {
		int year = 2013;
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, year);
		c.set(Calendar.DATE, 1);

		for (int month = Calendar.JANUARY; month <= Calendar.DECEMBER; month++)
 {
			c.set(Calendar.MONTH, month);
			System.out.println(year + "年" + (month + 1) + "月："
					+ c.getActualMaximum(Calendar.DATE) + "天");
		}
	}
}

8 输出一年后再减去3个月的日期

8.1 问题

在上一案例的基础上，输出当前日期基础上一年后再减去3个月的日期的年、月、日。

8.2 方案

首先，使用Calendar类的getInstance方法获取当前日期-时间；然后，使用Calendar类的add方法，加上一年；最后，再次，使用add方法，加上-3月，即减去3个月并输出计算后的年月日。

8.3 步骤

步骤一：构建测试方法

首先，在TestCalendar类中添加测试方法testAdd，然后，使用Calendar类的getInstance方法获取当前日期-时间；最后，使用Calendar类的add方法，加上一年，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
 /**
  * 输出一年后再减去3个月的日期
  */
#cold_bold	@Test
#cold_bold	public void testAdd() {
#cold_bold		Calendar calendar = Calendar.getInstance();
#cold_bold		calendar.add(Calendar.YEAR, 1);// 加一年
#cold_bold	}
}

步骤二：使用add方法,实现减去3个月

再次，使用add方法，加上-3月，即减去3个月并输出计算后的年月日,代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
 /**
  * 输出一年后再减去3个月的日期
  */
	@Test
	public void testAdd() {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.YEAR, 1);// 加一年
#cold_bold		calendar.add(Calendar.MONTH, -3);// 减3个月
#cold_bold		System.out.println("year:" + calendar.get(Calendar.YEAR));
#cold_bold		System.out.println("month:" + (calendar.get(Calendar.MONTH) + 1));
#cold_bold		System.out.println("day:" + calendar.get(Calendar.DAY_OF_MONTH));
	}
}

此处需要注意的是，Calenar.MONTH字段表示月份，月份的起始值不是1，而是0，所示需要在取到的月份值的基础上加1才能与实际的月份对应。

步骤三：运行

运行testAdd方法，控制台输出结果如下所示：（注：我的运行时间为2014年2月24日）

year:2014
month:11
day:24

从输出结果可以看出，实现了输出当前日期基础上一年后再减去3个月的日期的年、月、日。

8.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	//...（之前案例的代码，略）

 /**
  * 输出一年后再减去3个月的日期
  */
	@Test
	public void testAdd() {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.YEAR, 1);// 加一年
		calendar.add(Calendar.MONTH, -3);// 减3个月
		System.out.println("year:" + calendar.get(Calendar.YEAR));
		System.out.println("month:" + (calendar.get(Calendar.MONTH) + 1));
		System.out.println("day:" + calendar.get(Calendar.DAY_OF_MONTH));
	}
}

9 使Date表示的日期与Calendar表示的日期进行互换

9.1 问题

在上一案例的基础上，使Date表示的日期与Calendar表示的日期进行互换。

9.2 方案

首先，使用Calendar类的getInstance方法获取当前日期-时间calendar；然后，实例化Date类，获取表示的当前日期-时间对象date；最后，首先，使用Calendar的setTime方法将Date对象转换为Calendar对象，然后，使用Calendar对象的getTime方法再将Calendar表示对象转换为Date对象。

9.3 步骤

步骤一：构建测试方法

首先，在TestCalendar类中添加测试方法testSetTimeAndGetTime；然后，使用Calendar类的getInstance方法获取当前日期-时间calendar；最后，实例化Date类，获取表示的当前日期-时间对象date，代码如下所示：

package day03;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
#cold_bold /**
#cold_bold  * 使Date表示的日期与Calendar表示的日期进行互换
#cold_bold  */
#cold_bold	@Test
#cold_bold	public void testSetTimeAndGetTime() {
#cold_bold		Calendar calendar = Calendar.getInstance();
#cold_bold		Date date = new Date();
#cold_bold	}
}

步骤二：使用setTime方法

首先，使用Calendar的setTime方法将Date对象转换为Calendar对象，然后，使用Calendar对象的getTime方法再将Calendar表示对象转换为Date对象,代码如下所示：

package day03;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
 /**
  * 使Date表示的日期与Calendar表示的日期进行互换
  */
	@Test
	public void testSetTimeAndGetTime() {
		Calendar calendar = Calendar.getInstance();
		Date date = new Date();
#cold_bold		calendar.setTime(date);//将Date转换为Calendar
#cold_bold		date = calendar.getTime();//将Calendar转换为Date
	}
}

9.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import org.junit.Test;

public class TestCalendar {
	//...（之前案例的代码，略）

 /**
  * 使Date表示的日期与Calendar表示的日期进行互换
  */
	@Test
	public void testSetTimeAndGetTime() {
		Calendar calendar = Calendar.getInstance();
		Date date = new Date();
		calendar.setTime(date);//将Date转换为Calendar
		date = calendar.getTime();//将Calendar转换为Date
	}
}

10 测试集合持有对象

10.1 问题

测试集合持有对象，详细要求如下：

1）使用ArrayList构造集合对象cells。

2）构造行和列为（1，2）的Cell对象，将其放入集合cells中。

3）构造行和列为（2，3）的Cell类的对象cell，将其放入集合cells中。

4）输出cell对象和cells对象。

5）将cell对象下落一个格子。

6）再次输出cell对象和cells对象，比较两次输出的结果。

10.2 方案

首先，构建包和类，并在类中新建测试方法。

其次，使用ArrayList构造集合对象cells，代码如下：

Collection<Cell> cells = new ArrayList<Cell>();

以上代码表明集合存放的数据为Cell类型。

第三，构造行和列为（1，2）的Cell对象，使用集合的add方法将该对象放入集合cells中。

第四，构造行和列为（2，3）的Cell类的对象cell，使用集合的add方法将该对象放入集合cells中，并输出cell对象和cells对象。

第五，将cell对象下落一个格子，然后再次输出cell对象和cells对象。

10.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建包、类以及测试方法

首先新建名为TestCollection的类，最后，在该类中新建测试方法testRef，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 集合持有对象的引用
	 */
	@Test
	public void testRef() {
		
	}
}

步骤二：拷贝Cell 类

拷贝day02包下的Cell类到day03包下，工程结构如图-2所示。

图- 2

步骤三：构建集合

使用ArrayList构造集合对象cells，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 集合持有对象的引用
	 */
	@Test
	public void testRef() {
#cold_bold		Collection<Cell> cells = new ArrayList<Cell>();
	}
}

步骤四：构造两个Cell类的对象，将其放入集合

首先，构造行和列为（1，2）的Cell对象，使用集合的add方法将该对象放入集合cells中。其次，构造行和列为（2，3）的Cell类的对象cell，使用集合的add方法将该对象放入集合cells中，并输出cell对象和cells对象，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 集合持有对象的引用
	 */
	@Test
	public void testRef() {
		Collection<Cell> cells = new ArrayList<Cell>();
#cold_bold		cells.add(new Cell(1, 2));
#cold_bold		Cell cell = new Cell(2, 3);
#cold_bold		cells.add(cell);
#cold_bold		System.out.println(cell); // (2,3)
#cold_bold		System.out.println(cells); // [(1,2), (2,3)]
	}
}

步骤五：运行

运行方法testRef，控制台输出内容为：

(2,3)
[(1,2), (2,3)]

从输出结果上可以看出，构造的cell对象的行和列为（2，3），在集合中显示也为（2，3）。

步骤六：将cell对象下落一个格子

将cell对象下落一个格子，然后再次输出cell对象和cells对象。

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 集合持有对象的引用
	 */
	@Test
	public void testRef() {
		Collection<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(1, 2));
		Cell cell = new Cell(2, 3);
		cells.add(cell);
		System.out.println(cell); // (2,3)
		System.out.println(cells); // [(1,2), (2,3)]

#cold_bold		cell.drop();
#cold_bold		System.out.println(cell); // (3,3)
#cold_bold		System.out.println(cells); // [(1,2), (3,3)]
	}
}

步骤七：运行

再次运行testRef方法，控制台的输出内容为：

(2,3)
[(1,2), (2,3)]
#cold_bold(3,3)
#cold_bold[(1,2), (3,3)]

从输出结果上可以看出，将cell对象下落一个格子后，其行和列变为（3，3），在集合中该对象的行和列也为（3，3），因此可以说明，集合cells持有对象cell的引用，cell对象的属性发生变化，cells集合中该对象的属性也发生变化。

10.4 完整代码

本案例中，TestCollection类的完整代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 集合持有对象的引用
	 */
	@Test
	public void testRef() {
		Collection<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(1, 2));
		Cell cell = new Cell(2, 3);
		cells.add(cell);
		System.out.println(cell); // (2,3)
		System.out.println(cells); // [(1,2), (2,3)]

		cell.drop();
		System.out.println(cell); // (3,3)
		System.out.println(cells); // [(1,2), (3,3)]
	}
}

Cell类的完整代码如下所示：

package day03;

public class Cell{
	int row;
	int col;

	public Cell(int row, int col) {
		this.row = row;
		this.col = col;
	}

	public Cell() {
		this(0, 0);
	}

	public Cell(Cell cell) {
		this(cell.row, cell.col);
	}

	public void drop() {
		row++;
	}

	public void moveRight() {
		col++;
	}

	public void moveLeft() {
		col--;
	}

	@Override
	public String toString() {
		return "(" + row + "," + col + ")";
	}

	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		if (obj instanceof Cell) {
			Cell cell = (Cell) obj;
			return cell.row == row && cell.col == col;
		} else {
			return false;
		}
	}
}

11 使用add方法向集合中添加元素

11.1 问题

使用add方法向集合中添加元素，详细要求如下：

1）使用ArrayList构造集合对象c，并输出该对象。

2）将字符串“a”、“b”、“c”放入集合c中，再次输出集合对象。

11.2 方案

首先，使用 ArrayList构造集合对象c，代码如下所示：

Collection<String> c = new ArrayList<String>();

接着输出对象c。

然后，使用Collection的add方法将字符串“a”、“b”、“c”分别放入集合中，最后，再次输出集合c。

11.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

在上一案例的基础上，在类TestCollection中构建测试方法testAdd，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
#cold_bold	/**
#cold_bold	 * 测试add方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testAdd() {
#cold_bold		
#cold_bold	}
}

步骤二：构造集合对象

首先，使用 ArrayList构造集合对象c，然后输出对象c，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试add方法
	 */
	@Test
	public void testAdd() {
#cold_bold		Collection<String> c = new ArrayList<String>();
#cold_bold		System.out.println(c); // []
	}
}

运行上述代码，控制台输出结果为：

[]

观察上述输出结果，可以看出集合c中当前没有任何元素。

步骤三：使用add方法向集合中添加元素

首先，使用Collection的add方法将字符串“a”、“b”、“c”分别放入集合中，然后，再次输出集合c，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试add方法
	 */
	@Test
	public void testAdd() {
		Collection<String> c = new ArrayList<String>();
		System.out.println(c); // []
#cold_bold		c.add("a");
#cold_bold		c.add("b");
#cold_bold		c.add("c");
#cold_bold		System.out.println(c); // [a, b, c]
	}
}

运行上述代码后，控制台的输出结果为:

[a, b, c]

从输出结果可以看出，已经将字符串“a”、“b”、“c”放入到集合c中。

11.4 完整代码

本案例中，类TestCollection的完整代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	//...（之前案例的代码，略）

	/**
	 * 测试add方法
	 */
	@Test
	public void testAdd() {
		Collection<String> c = new ArrayList<String>();
		System.out.println(c); // []
		c.add("a");
		c.add("b");
		c.add("c");
		System.out.println(c); // [a, b, c]
	}
}

12 使用contains方法判断集合中是否包含某元素

12.1 问题

判断某集合中是否包含某元素，详细要求如下：

1）使用ArrayList构建集合对象cells，使用行和列为（1，2）、（1，3）、（2，2）、（2，3）构建四个Cell类的对象，并将这四个对象放入集合cells中。

2）使用行和列为（1，3）构建Cell类的对象cell。

3）比较cell对象在集合cells中是否存在。

12.2 方案

1）首先，使用ArrayList构建集合对象cells；然后，使用行和列为（1，2）、（1，3）、（2，2）、（2，3）构建四个Cell类的对象，并将这四个对象放入集合cells中，代码如下所示：

Collection<Cell> cells = new ArrayList<Cell>();

		cells.add(new Cell(1, 2));
		cells.add(new Cell(1, 3));
		cells.add(new Cell(2, 2));
		cells.add(new Cell(2, 3));

2）使用行和列为（1，3）构建Cell类的对象cell,代码如下所示：

Cell cell = new Cell(1, 3);

3）使用Collection接口中提供的contains方法，判断cell对象是否存在于cells集合中，代码如下所示：

		boolean flag = cells.contains(cell);

12.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

在TestCollection类中添加单元测试方法testContains，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
#cold_bold	/**
#cold_bold	 * 测试contains方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testContains() {
#cold_bold
#cold_bold	}
}

步骤二：构建集合对象及其元素

首先，使用ArrayList构建集合对象cells；然后，使用行和列为（1，2）、（1，3）、（2，2）、（2，3）构建四个Cell类的对象，并将这四个对象放入集合cells中，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试contains方法
	 */
	@Test
	public void testContains() {
#cold_bold		Collection<Cell> cells = new ArrayList<Cell>();
#cold_bold
#cold_bold		cells.add(new Cell(1, 2));
#cold_bold		cells.add(new Cell(1, 3));
#cold_bold		cells.add(new Cell(2, 2));
#cold_bold		cells.add(new Cell(2, 3));
	}
}

步骤三：构建Cell类的对象cell

使用行和列为（1，3）构建Cell类的对象cell,代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试contains方法
	 */
	@Test
	public void testContains() {
		Collection<Cell> cells = new ArrayList<Cell>();

		cells.add(new Cell(1, 2));
		cells.add(new Cell(1, 3));
		cells.add(new Cell(2, 2));
		cells.add(new Cell(2, 3));

#cold_bold		Cell cell = new Cell(1, 3);
	}
}

步骤四：使用contains方法判断集合中是否存在某元素

使用Collection接口中提供的contains方法，判断cell对象是否存在于cells集合中,代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试contains方法
	 */
	@Test
	public void testContains() {
		Collection<Cell> cells = new ArrayList<Cell>();

		cells.add(new Cell(1, 2));
		cells.add(new Cell(1, 3));
		cells.add(new Cell(2, 2));
		cells.add(new Cell(2, 3));

		Cell cell = new Cell(1, 3);

#cold_bold		// List集合contains方法和对象的equals方法相关
#cold_bold		boolean flag = cells.contains(cell);
#cold_bold		// 如果Cell不重写equals方法将为false
#cold_bold		System.out.println(flag); // true
	}
}

步骤五：运行

运行上述代码后，控制台输出结果如下:

true

从输出结果可以看出，返回结果为true。判断集合中是否包含某个对象，是根据对象的equals方法进行判断的，当集合中的某个对象和当前对象进行比较，如果这两个对象使用equals方法进行比较返回true，那么说明集合中存在当前对象；反之，则返回false，表示不存在当前对象。

本案例中的Cell类，在day02中已经重写了equals方法，实现了行行相等，同时列列相等，那么两个Cell对象相等。因此，在集合cells中存在 cell对象，返回结果为true。

12.4 完整代码

本案例中，类TestCollection的完整代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import org.junit.Test;

public class TestCollection {
	//...（之前案例的代码，略）

	/**
	 * 测试contains方法
	 */
	@Test
	public void testContains() {
		Collection<Cell> cells = new ArrayList<Cell>();

		cells.add(new Cell(1, 2));
		cells.add(new Cell(1, 3));
		cells.add(new Cell(2, 2));
		cells.add(new Cell(2, 3));

		Cell cell = new Cell(1, 3);

		// List集合contains方法和对象的equals方法相关
		boolean flag = cells.contains(cell);
		// 如果Cell不重写equals方法将为false
		System.out.println(flag); // true
	}
}

Cell类的完整代码如下所示：

package day03;

public class Cell{
	int row;
	int col;

	public Cell(int row, int col) {
		this.row = row;
		this.col = col;
	}

	public Cell() {
		this(0, 0);
	}

	public Cell(Cell cell) {
		this(cell.row, cell.col);
	}

	public void drop() {
		row++;
	}

	public void moveRight() {
		col++;
	}

	public void moveLeft() {
		col--;
	}

	@Override
	public String toString() {
		return "(" + row + "," + col + ")";
	}

	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		if (obj instanceof Cell) {
			Cell cell = (Cell) obj;
			return cell.row == row && cell.col == col;
		} else {
			return false;
		}
	}
}

13 测试方法size、clear、isEmpty的用法

13.1 问题

测试Collection接口中size方法、clear方法、isEmpty方法的用法，详细要求如下：

1）使用HashSet构建集合c，并判断当前集合是否为空。

2）将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，并判断集合c是否为空以及集合c中元素的个数。

3）清空集合c，并判断集合c是否为空以及集合c中元素的个数。

13.2 方案

1）首先，使用HashSet构建集合c；然后，使用Collection接口提供的isEmpty方法判断集合c是否为空，代码如下所示：

	Collection<String> c = new HashSet<String>();
	System.out.println(c.isEmpty()); // true

2）首先，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中；然后，使用Collection接口提供的isEmpty方法判断集合c是否为空；最后，使用Collection接口提供的size方法获取集合c中元素的个数，代码如下所示：

c.add("java");
	c.add("cpp");
	c.add("php");
	c.add("c#");
	c.add("objective-c");
System.out.println("isEmpty:" + c.isEmpty() + ",size: " + c.size());

3）首先，使用Collection接口提供的clear方法清空集合c，然后，使用isEmpty方法和size方法，判断集合c是否为空以及获取集合中元素的个数。

c.clear();
	System.out.println("isEmpty:" + c.isEmpty() + ", size: " + c.size());

13.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

在类TestCollection中添加测试方法testSizeAndClearAndIsEmpty，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
#cold_bold	/**
#cold_bold	 * 测试size方法、clear方法、isEmpty方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testSizeAndClearAndIsEmpty() {
#cold_bold		
#cold_bold	}
}

步骤二：使用isEmpty方法判断集合c是否为空

首先，使用HashSet构建集合c；然后，使用Collection接口提供的isEmpty方法判断集合c是否为空，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试size方法、clear方法、isEmpty方法
	 */
	@Test
	public void testSizeAndClearAndIsEmpty() {
#cold_bold		Collection<String> c = new HashSet<String>();
#cold_bold		System.out.println(c.isEmpty()); // true
	}
}

运行testSizeAndClearAndIsEmpty方法，控制台输出结果如下：

true

观察输出结果，可以看出当前集合c为空。

步骤三：使用size方法获取集合中元素的个数

首先，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中；然后，使用Collection接口提供的isEmpty方法判断集合c是否为空；最后，使用Collection接口提供的size方法获取集合c中元素的个数，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试size方法、clear方法、isEmpty方法
	 */
	@Test
	public void testSizeAndClearAndIsEmpty() {
		Collection<String> c = new HashSet<String>();
		System.out.println(c.isEmpty()); // true

#cold_bold		c.add("java");
#cold_bold		c.add("cpp");
#cold_bold		c.add("php");
#cold_bold		c.add("c#");
#cold_bold		c.add("objective-c");
#cold_bold
#cold_bold		System.out.println("isEmpty:" + c.isEmpty() + ",size: " + c.size());
#cold_bold		// isEmpty:false, size: 5
	}
}

步骤四：运行

运行testSizeAndClearAndIsEmpty方法，运行结果如下所示：

true
#cold_boldisEmpty:false,size: 5

观察输出结果，可以看出集合c不再是空，而且其中有5个元素，所以其size为5。

步骤五： clear方法的使用

首先，使用Collection接口提供的clear方法清空集合c；然后，使用isEmpty方法和size方法，判断集合c是否为空以及获取集合c中元素的个数，代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试size方法、clear方法、isEmpty方法
	 */
	@Test
	public void testSizeAndClearAndIsEmpty() {
		Collection<String> c = new HashSet<String>();
		System.out.println(c.isEmpty()); // true

	c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

		System.out.println("isEmpty:" + c.isEmpty() + ",size: " + c.size());
		// isEmpty:false, size: 5
#cold_bold
#cold_bold		c.clear();
#cold_bold
#cold_bold		System.out.println("isEmpty:" + c.isEmpty() + ", size: " + c.size());
#cold_bold		// isEmpty:true, size: 0
	}
}

步骤六：运行

运行testSizeAndClearAndIsEmpty方法，运行结果如下所示：

true
isEmpty:false,size: 5
#cold_boldisEmpty:true, size: 0

观察输出结果，集合c调用clear方法以后，将集合进行了清空，集合中的元素个数变为0。

13.4 完整代码

本案例的完整代码如下所示：

package day03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	//...（之前案例的代码，略）

	/**
	 * 测试size方法、clear方法、isEmpty方法
	 */
	@Test
	public void testSizeAndClearAndIsEmpty() {
		Collection<String> c = new HashSet<String>();
		System.out.println(c.isEmpty()); // true

		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

		System.out.println("isEmpty:" + c.isEmpty() + ",size: " + c.size());
		// isEmpty:false, size: 5

		c.clear();

		System.out.println("isEmpty:" + c.isEmpty() + ", size: " + c.size());
		// isEmpty:true, size: 0
	}
}