第九章 Java常用类

9.1 包装类

Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中。

9.1.1 Integer类

Integer类在对象中包装了一个基本数据类型int的值，该类包含一个int了类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时提供了其他一些处理int类型是非常有用的常量和方法。

1. 构造方法

Integer类有以下两种构造方法

（1）Integer（int number）

该方法以一个int类型常量作为参数来获取Integer对象

（2）Integer（String str）

该方法以一个String型变量作为参数来获取Integer对象

2. 常用的方法

package hwd;

public class ObjectDome {//创建类

	public static void main(String[] args) {//主方法
		int num = Integer.parseInt("456");//调用方法
		Integer iNum = Integer.valueOf("456");//调用方法
		System.out.println("int数据与INteger对象进行比较：" + iNum.equals(num));//打印结果
		String str2 = Integer.toBinaryString(num);//调用方法
		String str3 = Integer.toHexString(num);//调用方法
		String str4 = Integer.toOctalString(num);//调用方法
		String str5 = Integer.toString(num, 15);//调用方法
		System.out.println("456的二进制表示为：" + str2);//打印结果
		System.out.println("456的十六进制表示为：" + str3);//打印结果
		System.out.println("456的八进制表示为：" + str4);//打印结果
		System.out.println("456 的十五进制表示为：" + str5);//打印结果

	}

}

int数据与INteger对象进行比较：true
456的二进制表示为：111001000
456的十六进制表示为：1c8
456的八进制表示为：710
456 的十五进制表示为：206

 3.常量

Integer类包含了下面的四个常量，它们分别是：1、MAX_VALUE：值为231-1的常量，它表示int类型能够表示的最大值。 2、MIN_VALUE：值为-231的常量，它表示int类型能够表示的最小值。 3、SIZE：用来以二进制补码形式表示int值的比特位数。

package hwd;

public class GetCon {//创建类

	public static void main(String[] args) {//主方法
		int maxint = Integer.MAX_VALUE;//调用方法
		int minint = Integer.MIN_VALUE;//调用方法
		int intsize = Integer.SIZE;//调用方法
		System.out.println("int类型可取的最大值是" + maxint);//打印结果
		System.out.println("int类型可取的最小值是" + minint);//打印结果
		System.out.println("int类型的二进制数是" + intsize);//打印结果
	}

}

int类型可取的最大值是2147483647
int类型可取的最小值是-2147483648
int类型的二进制数是32

 9.1.2 Double类

Double 类的构造方法

Double 类中的构造方法有如下两个。

• Double(double value)：构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。
• Double(String s)：构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。

1. Double double1 = new Double(5.456); // 以 double 类型的变量作为参数创建 Double 对象
2. Double double2 = new Double("5.456"); // 以 String 类型的变量作为参数创建 Double 对象

Double 类的常用方法

在 Double 类内部包含一些和 double 操作有关的方法，见表 1。
 

例如，将字符串 56.7809 转换为 double 类型的数值，或者将 double 类型的数值 56.7809 转换为对应的字符串，以下代码演示如何实现这两种功能：

1. String str = "56.7809";
2. double num = Double.parseDouble(str); // 将字符串转换为 double 类型的数值
3. double d = 56.7809;
4. String s = Double.toString(d); // 将double类型的数值转换为字符串

在将字符串转换为 double 类型的数值的过程中，如果字符串中包含非数值类型的字符，则程序执行将出现异常。

Double 类的常用常量

在 Double 类中包含了很多常量，其中较为常用的常量如下。

• MAX_VALUE:值为 1.8E308 的常量，它表示 double 类型的最大正有限值的常量。
• MIN_VALUE：值为 4.9E-324 的常量，它表示 double 类型数据能够保持的最小正非零值的常量。
• NaN：保存 double 类型的非数字值的常量。
• NEGATIVE_INFINITY：保持 double 类型的负无穷大的常量。
• POSITIVE_INFINITY：保持 double 类型的正无穷大的常量。
• SIZE：用秦以二进制补码形式表示 double 值的比特位数。
• TYPE：表示基本类型 double 的 Class 实例。

package hwd;

public class useDouble {//创建类

	public static void main(String[] args) {//主方法
		Double dNum = Double.valueOf("3.14");//调用方法
		System.out.println("3.14是否为非数字值：" + Double.isNaN(dNum.doubleValue()));//打印结果调用方法
		System.out.println("3.14转换为int值为：" +dNum.intValue());//打印结果调用方法
		System.out.println("值为3.14的Double对象与3.14的比较结果：" + dNum.equals(3.14));//打印结果调用方法
		System.out.println("3.14的十六进制表示为：" + Double.toHexString(dNum));//打印结果调用方法

	}

}

3.14是否为非数字值：false
3.14转换为int值为：3
值为3.14的Double对象与3.14的比较结果：true
3.14的十六进制表示为：0x1.91eb851eb851fp1

9.1.3 Boolean类

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 和 String 的相互转换提供了很多方法，并提供了处理 boolean 时非常有用的其他一些常用方法。

Boolean 类的构造方法

Boolean 类有以下两种构造形式：

1. Boolean(boolean boolValue);
2. Boolean(String boolString);

其中 boolValue 必须是 true 或 false（不区分大小写），boolString 包含字符串 true（不区分大小写），那么新的 Boolean 对象将包含 true；否则将包含 false。

Boolean 类的常用方法

在 Boolean 类内部包含了一些和 Boolean 操作有关的方法，见表 1。
 

例 1

编写一个 Java 程序，演示如何使用不同的构造方法创建 Boolean 对象，并调用 booleanValue() 主法将创建的对象重新转换为 boolean 数据输出。代码如下：

1. public class Test05 {
2. public static void main(String[] args) {
3. Boolean b1 = new Boolean(true);
4. Boolean b2 = new Boolean("ok");
5. Boolean b3 = new Boolean("true");
6. System.out.println("b1 转换为 boolean 值是：" + b1);
7. System.out.println("b2 转换为 boolean 值是：" + b2);
8. System.out.println("b3 转换为 boolean 值是：" + b3);
9. }
10. }

程序非常简单，运行后的输出结果如下：

b1 转换为 boolean 值是：true
b2 转换为 boolean 值是：false
b3 转换为 boolean 值是：true

Boolean 类的常用常量

在 Boolean 类中包含了很多的常量，其中较为常用的常量如下。

• TRUE：对应基值 true 的 Boolean 对象。
• FALSE：对应基值 false 的 Boolean 对象。
• TYPE：表示基本类型 boolean 的 Class 对象。

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 Boolean b1 = new Boolean(true);//创建对象
	 Boolean  b2 = new Boolean("ok");//创建对象
	 System.out.println("b1：" + b1.booleanValue());//打印结果
	 System.out.println("b2：" + b2.booleanValue());//打印结果
	 
 	}
}

b1：true
b2：false

 9.1.4 Character类

Character 类是字符数据类型 char 的包装类。Character 类的对象包含类型为 char 的单个字段，这样能把基本数据类型当对象来处理，其常用方法如表 1 所示。
 

可以从 char 值中创建一个 Character 对象。例如，下列语句为字符 S 创建了一个 Character 对象。 

1. Character character = new Character('S');

3.常量

Character.CONNECTOR返回byte型数据表示Unicode规范中的常规类别“Pc"
Character.UNASSIGNED Unicode规范中的常规类别"Cn"
Character.TITLECASE_LETTER Unicode中的规范常规类别"Lt"

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 Character mychar1 = new Character('A');//创建对象
	 Character mychar2 = new Character('a');//创建对象
	 if(Character.isUpperCase(mychar1)){//判断语句
		 System.out.println(mychar1 + "是大写字母");//打印结果
		 System.out.println("转换为小写字母的结果：" + Character.toUpperCase(mychar2));//打印结果调用方法
	 	}
	 
	 if(Character.isLowerCase(mychar2)){//判断语句
		 System.out.println(mychar2 + "是小写字母");//打印结果
		 System.out.println("转换为大写字母的结果" + Character.toUpperCase(mychar2));//打印结果调用方法
	 	}
 	}
}

A是大写字母
转换为小写字母的结果：A
a是小写字母
转换为大写字母的结果A

9.1.5 Number类

Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类。

Number 类定义了一些抽象方法，以各种不同数字格式返回对象的值。如 xxxValue() 方法，它将 Number 对象转换为 xxx 数据类型的值并返回。这些方法如下表所示：
 

抽象类不能直接实例化，而是必须实例化其具体的子类。如下代码演示了 Number 类的使用：

1. Number num = new Double(12.5);
2. System.out.println("返回 double 类型的值：" + num.doubleValue());
3. System.out.println("返回 int 类型的值：" + num.intValue());
4. System.out.println("返回 float 类型的值：" + num.floatValue());

执行上述代码，输出结果如下：

返回 double 类型的值：12.5
返回 int 类型的值：12
返回 float 类型的值：12.5

9.2 Math类

Java 中的 +、-、*、/ 和 % 等基本算术运算符不能进行更复杂的数学运算，例如，三角函数、对数运算、指数运算等。于是 Java 提供了 Math 工具类来完成这些复杂的运算。

在 Java 中 Math 类封装了常用的数学运算，提供了基本的数学操作，如指数、对数、平方根和三角函数等。Math 类位于 java.lang 包，它的构造方法是 private 的，因此无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。

下面详细介绍该类的常量及数学处理方法。

静态常量

Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）。

例 1

调用 Math 类的 E 和 PI 两个常量，并将结果输出。代码如下：

1. System.out.println("E 常量的值：" + Math.E);
2. System.out.println("PI 常量的值：" + Math.PI);

执行上述代码，输出结果如下：

E 常量的值：2.718281828459045
PI 常量的值：3.141592653589793

求最大值、最小值和绝对值

在程序中常见的就是求最大值、最小值和绝对值问题，如果使用 Math 类提供的方法可以很容易实现。这些方法的说明如表 1 所示。
 

例 2

求 10 和 20 的较大值、15.6 和 15 的较小值、-12 的绝对值，代码如下：

1. public class Test02 {
2. public static void main(String[] args) {
3. System.out.println("10 和 20 的较大值：" + Math.max(10, 20));
4. System.out.println("15.6 和 15 的较小值：" + Math.min(15.6, 15));
5. System.out.println("-12 的绝对值：" + Math.abs(-12));
6. }
7. }

该程序的运行结果如下：

10和20的较大值：20
15.6和15的较小值：15.0
-12的绝对值：12

求整运算

Math 类的求整方法有很多，详细说明如表 2 所示。
 

例 3

下面的实例演示了 Math 类中取整函数方法的应用：

1. import java.util.Scanner;
2. public class Test03 {
3. public static void main(String[] args) {
4. Scanner input = new Scanner(System.in);
5. System.outprintln("请输入一个数字：");
6. double num = input.nextDouble();
7. System.out.println("大于或等于 "+ num +" 的最小整数：" + Math.ceil(num));
8. System.out.println("小于或等于 "+ num +" 的最大整数：" + Math.floor(num));
9. System.out.println("将 "+ num +" 加上 0.5 之后最接近的整数：" + Math.round(num));
10. System.out.println("最接近 "+num+" 的整数：" + Math.rint(num));
11. }
12. }

执行结果如下：

请输入一个数字：
99.01
大于或等于 99.01 的最小整数：100.0
小于或等于 99.01 的最大整数：99.0
将 99.01 加上 0.5 之后最接近的整数：100
最接近 99.01 的整数：99.0

三角函数运算

Math 类中包含的三角函数方法及其说明如表 3 所示。
 

在表 3 中，每个方法的参数和返回值都是 double 类型，参数以弧度代替角度来实现，其中 1 度等于 π/180 弧度，因此平角就是 π 弧度。

例 4

计算 90 度的正弦值、0 度的余弦值、1 的反正切值、120 度的弧度值，代码如下：

1. public class Test04 {
2. public static void main(String[] args) {
3. System.out.println{"90 度的正弦值：" + Math.sin(Math.PI/2));
4. System.out.println("0 度的余弦值：" + Math.cos(0));
5. System.out.println("1 的反正切值：" + Math.atan(l));
6. System.out.println("120 度的弧度值：" + Math.toRadians(120.0));
7. }
8. }

在上述代码中，因为 Math.sin() 中的参数的单位是弧度，而 90 度表示的是角度，因此需要将 90 度转换为弧度，即 Math.PI/180*90，故转换后的弧度为 Math.PI/2，然后调用 Math 类中的 sin() 方法计算其正弦值。

该程序的运行结果如下：

90 度的正弦值：1.0
0 的余弦值：1.0
1 的反正切值：0.7853981633974483
120 度的弧度值：2.0943951023931953

指数运算

指数的运算包括求方根、取对数及其求 n 次方的运算。在 Math 类中定义的指数运算方法及其说明如表 4 所示。
 

例 5

使用 Math 类中的方法实现指数的运算，main() 方法中的代码如下：

1. public class Test05 {
2. public static void main(String[] args) {
3. System.out.println("4 的立方值：" + Math.pow(4, 3));
4. System.out.println("16 的平方根：" + Math.sqrt(16));
5. System.out.println("10 为底 2 的对数：" + Math.log1O(2));
6. }
7. }

该程序的运行结果如下：

4 的立方值：64.0
16 的平方根：4.0
10 为底 2 的对数：0.3010299956639812

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("90度的正弦：" + Math.sin(Math.PI / 3));//取90度的正弦
	 System.out.println("0度的余弦：" + Math.cos(0));//取0度余弦
	 System.out.println("60度的正切值：" + Math.tan(Math.PI / 3)); //取60度的正弦
	 System.out.println("2的平方根与2商的反弦值：" + Math.asin(Math.sqrt(2) / 2));//取2的平方根与2商的反正弦
	 System.out.println("2的平方根与2商的反余弦值：" + Math.acos(Math.sqrt(2) / 2));//取2的平方根与2商的反余弦
	 System.out.println("1的反正切值：" + Math.atan(1));//取1的反正切
	 System.out.println("120度的弧度值：" + Math.toRadians(120.0));//取120的弧度值
	 System.out.println("Π/2的角度值：" + Math.toDegrees(Math.PI / 2));//取Π/2的角度
	 
 	}
}

90度的正弦：0.8660254037844386
0度的余弦：1.0
60度的正切值：1.7320508075688767
2的平方根与2商的反弦值：0.7853981633974484
2的平方根与2商的反余弦值：0.7853981633974483
1的反正切值：0.7853981633974483
120度的弧度值：2.0943951023931953
Π/2的角度值：90.0

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("e的平方值：" + Math.exp(2));//取e的2次方
	 System.out.println("取e为底2的对数值：" + Math.log(2));//取以e为底2的对数
	 System.out.println("以10为底2的对数值：" + Math.log10(2));//取以10为底2的对数
	 System.out.println("4的平方根值：" + Math.sqrt(4));//取4的平方根
	 System.out.println("8的立方根值：" + Math.cbrt(8));//取8的立方根
	 System.out.println("2的2次方值：" + Math.pow(2, 2));//取2的次方
	 
 	}
}

e的平方值：7.38905609893065
取e为底2的对数值：0.6931471805599453
以10为底2的对数值：0.3010299956639812
4的平方根值：2.0
8的立方根值：2.0
2的2次方值：4.0

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("使用ceil（）方法取整：" + Math.ceil(5.2));//返回一个个大于等于参数的整数
	 System.out.println("使用floor（）方法取整： " + Math.floor(2.5));//返回一个小于等于参数的整数
	 System.out.println("使用rint（）方法取整：" + Math.rint(2.7));//返回与参数最接近的整数
	 System.out.println("使用rint（）方法取整：" + Math.rint(2.5));//返回与参数最接近的整数
	 System.out.println("使用round方法取整：" + Math.round(3.4f));//将参数加上0.5后返回最接近的整数
	 System.out.println("使用round方法取整：" + Math.round(2.5));//将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
	 
 	}
}

使用ceil（）方法取整：6.0
使用floor（）方法取整： 2.0
使用rint（）方法取整：3.0
使用rint（）方法取整：2.0
使用round方法取整：3
使用round方法取整：3

取最大值、最小值、绝对值函数方法

package hwd;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("4和8较大者：" + Math.max(4, 8));//取两个参数的最大值
	 System.out.println("4.4和4较小者：" + Math.min(4.4, 4));//取两个参数的最小值
	 System.out.println("-7的绝对值：" + Math.abs(-7));//取参数的绝对值
	 
	 
 	}
}

4和8较大者：8
4.4和4较小者：4.0
-7的绝对值：7

9.3 随机数

在 Java 中要生成一个指定范围之内的随机数字有两种方法：一种是调用 Math 类的 random() 方法，一种是使用 Random 类。

Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数，这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。

Random 类位于 java.util 包中，该类常用的有如下两个构造方法。

• Random()：该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。
• Random(long seed)：使用单个 long 类型的参数创建一个新的随机数生成器。

Random 类提供的所有方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的概率是均等的，在表 1 中列出了 Random 类中常用的方法。
 

package hwd;
import java.util.*;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	System.out.println("-------猜数字游戏--------\n");//打印标题
	int iNum;//创建属性
	int iGuess;//创建属性
	Scanner in = new Scanner(System.in);//获取键盘值
	iNum = (int) (Math.random()*100);//随机生成值
	System.out.println("亲输入你猜的数字");//打印标题
	iGuess = in.nextInt();//赋值
	
	while ((iGuess != -1) && (iGuess != iNum))//判断
	{
		if (iGuess < iNum)//判断
		{
			System.out.println("太小，请重新输入：");//打印结果
			iGuess = in.nextInt();//赋值
		}else //判断
		{
			System.out.println("太大，请重新输入：");//打印结果
			iGuess = in.nextInt();//赋值
		}
	}
	if (iGuess == -1)//判断
	{
		System.out.println("退出游戏!");//打印结果
	}else//判断
	{
		System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum);//打印结果
	}
	 System.out.println("\n-------游戏结束----------");//打印结果
 	}
}

-------猜数字游戏--------

亲输入你猜的数字
60
太大，请重新输入：
5
太小，请重新输入：
45
太大，请重新输入：
30
恭喜你，你赢了，猜中的数字是：30

-------游戏结束----------

package hwd;
import java.util.*;


class Dome{//创建类
	
	public static char GetRandomChar(char cha1, char cha2){//创建方法
		return (char) (cha1 + Math.random() * (cha2 - cha1));//返回值
	}
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("任意小写字符:" + GetRandomChar('a' , 'z'));//打印结果
	 System.out.println("任意大写字符：" + GetRandomChar('A' , 'Z'));//打印结果
	 System.out.println("0到9任意数字字符：" + GetRandomChar('0' , '9'));//打印结果
	 
	 
 	}
}

任意小写字符:c
任意大写字符：W
0到9任意数字字符：5

package hwd;
import java.util.*;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 System.out.println("-------模拟微信抢红包---------\n");
	 Scanner sc = new Scanner(System.in);
	 System.out.println("请输入要装入红包的总金额：");
	 
	 double total = sc.nextDouble();
	 System.out.println("请输入红包个数：");
	 int bagsnum = sc.nextInt();
	 double min = 0.01;
	 
	 
	 Random random = new Random();
	 for (int i = 1; i < bagsnum; i++)
	 {
		 /**
		  * 通过公式模拟数字中的离散模型计算一个红包可以放的最大金额
		  * 本次可用最大金额 = 可分配金额 - （红包总数*已发出红包数）*红包的最小金额
		  */
		 double max = total - (bagsnum - i) * min;
		 
		 double bound = max - min;
		 
		 double safe = (double) random.nextInt();
		 double money = safe + min;
		 
		 total = total - money;
		 
		 System.out.println("第" + i + "个红包" + String.format("%.2f", money) + "元");
		 
		 System.out.println("第" + bagsnum + "个红包" + String.format("%.2f", total) + "元");
		 
		 sc.close();
	 }
	 
 	}
}

-------模拟微信抢红包---------

请输入要装入红包的总金额：
5000
请输入红包个数：
10
第1个红包927994417.01元
第10个红包-927989417.01元
第2个红包877448233.01元
第10个红包-1805437650.02元
第3个红包-902867854.99元
第10个红包-902569795.03元
第4个红包-565542664.99元
第10个红包-337027130.04元
第5个红包-638226273.99元
第10个红包301199143.95元
第6个红包967157435.01元
第10个红包-665958291.06元
第7个红包1599464618.01元
第10个红包-2265422909.07元
第8个红包443169422.01元
第10个红包-2708592331.08元
第9个红包-971456545.99元
第10个红包-1737135785.09元

9.4 日期时间类​​​​​​​

在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。其中，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。下面详细介绍这两个类的具体使用。

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 所示。
 

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：星期几。

格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。

在 Java 中，可以使用 DateFormat 类和 SimpleDateFormat 类来格式化日期，下面详细介绍这两个格式化日期类的使用。

DateFormat 类

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

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

DateFormat df = DateFormat.getDatelnstance();

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

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

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

• 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。

• SimpleDateFormat 类

  如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。
  
  SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。
  
  SimpleDateFormat 类主要有如下 3 种构造方法。
• SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
• SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateF ormat。
• SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateF ormat。

本实例使用有关日期处理和日期格式化的类实现一个日期查询的功能，即查询指定日期所在周的周一日期、两个指定日期间相差的天数和指定日期为所在周的星期几的日期 3 个功能。

从功能上来看，本实例至少需要定义 3 个方法，分别完成：获取指定日期所在周的周一日期、获取两个指定日期的相差天数以及获取指定日期为所在周的星期几的日期这 3 个功能，同时需要定义 Date 类型的日期与 String 类型之间的转换方法。

(1) 新建 Exercise 类，在该类中导入需要的包。代码如下：

1. import java.text.Parse Exception;
2. import java.text.SimpleDateFormat;
3. import java.util.Calendar;
4. import java.util.Date;
5. public class Exercise {
6. // 在该类中有5个方法，在下面的步骤中将会讲解，这里省略
7. }

(2) 在 Exercise 类中定义获取指定日期所在周的周一日期的方法——getMonday()，该方法是一个静态方法，返回值为 String 类型，并且需要传递一个 Date 类型的参数，然后将该日期参数作为 Calendar 对象的日期，并调用 Calendar 类的 set(int field,int value)方法改变 Calendar 对象中的日期，再将使用 SimpleDateFormat 类格式化后的日期返回。

getMonday() 方法的代码实现如下：

1. // 获取指定日期所在周的周一日期
2. public static String getMonday(Date date) {
3.     Calendar c = Calendar.getInstance();
4.     c.setTime(date);
5.     c.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);
6.     return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
7. }

(3) 继续在 Exercise 类中定义获取两个日期间相差天数的方法——getTwoDay()，该方法需要传递两个 String 类型的参数。

在该方法的主体中，首先需要创建一个 SimpleDateFormat 类对象，并指定日期的格式，然后需要调用 SimpleDateFormat 对象的 parse() 方法，将传递过来的两个 String 类型的日期转换为 Date 类型，并将这两个 Date 类型的日期进行运算，得出相差的天数，返回一个 int 类型的变量。

getTwoDay() 方法的代码实现如下：

1. // 获取两个日期间相差的天数
2. public static int getTwoDay(String sj1, String sj2) {
3.     SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
4.     int day = 0;
5.     try {
6.         Date date = myFormatter.parse(sj1);
7.         Date mydate = myFormatter.parse(sj2);
8.         // 计算两个日期间相差的天数
9.         day = (int)((date.getTime()-mydate.getTime())/(24*60*60*1000));
10.     } catch(Exception e) {
11.         return 0;
12.     }
13.     return day;
14. }

(4) 在 Exercise 类中继续创建两个静态方法，分别完成 String 类型的日期与 Date 类型日期的互换功能。代码如下：

1. // 将String类型的日期转换为Date类型
2. public static Date strToDate(String strDate) {
3. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
4. Date date = null;
5. try {
6. date = sdf.parse(strDate);
7. } catch(ParseException e) {
8. e.printStackTrace();
9. }
10. return date;
11. }
12. // 将Date类型的日期转换为String类型
13. public static String DateToStr(Date date) {
14. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
15. String strDate = sdf.format(date);
16. return strDate;
17. }

(5) 在 Exercise 类中定义获取指定日期所在周的指定星期的日期方法——getWeek()，该方法需要传递两个 String 类型的参数，其中第一个参数表示指定的日期，第二个参数表示星期几。

在该方法的主体中，首先调用了 strToDate() 方法，将 String 类型的日期转换为 Date 类型的日期，并将该日期作为 Calendar 类对象日期，然后判断传递过来的第二个参数的值，使用 Calendar 类中的 set(int field，int value) 方法改变日期，从而将格式化后的日期返回。

getWeek() 方法的代码实现如下：

1. // 获得一个日期所在周的星期几的日期，如要找出2011年5月1日所在周的星期一是几号
2. // @param sdate所确定的日期形式2011-05-01
3. // @param num要确定的是周几（1表示周一，2表示周二）
4. // @return
5. public static String getWeek(String sdate, String num) {
6. // 再转换为时间
7. Date dd = strToDate(sdate);
8. Calendar c = Calendar.getInstance();
9. c.setTime(dd);
10. int weekNo = Integer.parseInt(num);
11. switch (weekNo) {
12. case 1:
13. c.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY); //返回星期一所在的日期
14. break;
15. case 2:
16. c.set(Calendar.DAY_OF_WEEK,Calendar.TUESDAY); //返回星期二所在的日期
17. break;
18. case 3:
19. c.set(Calendar.DAY_OF_WEEK,Calendar.WEDNESDAY); //返回星期三所在的日期
20. break;
21. case 4:
22. c.set(Calendar.DAY_OF_WEEK,Calendar.THURSDAY); //返回星期四所在的日期
23. break;
24. case 5:
25. c.set(Calendar.DAY_OF_WEEK,Calendar.FRIDAY); //返回星期五所在的日期
26. break;
27. case 6:
28. c.set(Calendar.DAY_OF_WEEK,Calendar.SATURDAY); //返回星期六所在的曰期
29. break;
30. case 7:
31. c.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY); //返回星期曰所在的日期
32. break;
33. }
34. return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
35. }

(6) 创建测试类 Test15，调用 Exercise 类的方法，完成查询当前日期所在周的周一日期，并获取本周的周一曰期与当前曰期相差的天数，同时还可以查询本周中任意星期几的曰期。代码实现如下：

1. package com.common.mxl;
2. import java.util.Date;
3. import java.util.Scanner;
4. import com.common.mxl.Exercise;
5. public class Test15 {
6. public static void main(String[] args) {
7. Scanner input = new Scanner(System.in);
8. Date date = new Date();
9. String monday = Exercise.getMonday(date);
10. System.out.print("这周一的日期为【"+monday+"】，");
11. String nowStr = Exercise.DateToStr(date); // 将 Date 类型的日期转换为 String 类型
12. int num = Exercise.getTwoDay(nowStr,monday);
13. System.out.print("与今天相差【"+num+"】天");
14. SyStem.out.println("\n请输入您要查询本周星期几的日期（1表示星期一，2表示星期二…)：");
15. String weekNo = input.next(); //获取用户输入的星期
16. int no = Integer.parseInt(weekNo);
17. //将用户输入的星期转换为int类型，以便使用switch语句
18. String strWeekNo = "";
19. switch(no) {
20. case 1:
21. strWeekNo = "星期一";
22. break;
23. case 2:
24. strWeekNo = "星期二";
25. break;
26. case 3:
27. strWeekNo = "星期三";
28. break;
29. case 4:
30. strWeekNo = "星期四";
31. break;
32. case 5:
33. strWeekNo = "星期五";
34. break;
35. case 6:
36. strWeekNo = "星期六";
37. break;
38. case 7:
39. strWeekNo = "星期日";
40. break;
41. }
42. System.out.println("本周【"+strWeekNo+"】的日期为："+Exercise.getWeek(nowStr,weekNo));
43. }
44. }

在本程序中，综合使用了 Date 类、Calendar 类和 SimpleDateFormat 类完成了时间处理功能。在源码中，多次使用 Calendar 类的 set(int field,int value) 方法来改变日期，从而获取用户查询的日期。该方法在日期操作方面比较常用，大家需要熟练掌握该方法。

package hwd;
import java.util.*;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 
	 Date date = new Date();
	 long value = date.getTime();
	 System.out.println("日期" + date);
	 System.out.println("到现在所经历的毫秒数为：" + value);
	 
 	}
}

日期Wed May 04 15:02:48 CST 2022
到现在所经历的毫秒数为：1651647768497

package hwd;
import java.util.*;
import java.text.*;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 
	 Date date = new Date();
	 DateFormat df1 = DateFormat.getInstance();
	 DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE");
	 DateFormat df3 = new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒EE", Locale.CHINA);
	 DateFormat df4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE", Locale.US);
	 DateFormat df5 = new SimpleDateFormat("yyyy-MM-dd");
	 DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");
	 
	 System.out.println(df1.format(date));
	 System.out.println(df2.format(date));
	 System.out.println(df3.format(date));
	 System.out.println(df4.format(date));
	 System.out.println(df5.format(date));
	 System.out.println(df6.format(date));
	 
	 
 	}
}

22-5-4 下午3:13
2022-05-04 03:13:32 星期三
2022年05月04日03时13分32秒星期三
2022-05-04 03:13:32 Wed
2022-05-04
2022年05月04日

package hwd;
import java.util.*;
import java.text.*;


class Dome{//创建类
	
 public static void main(String[]args){//主方法
	 
	 
	 System.out.println("--------东奥会倒计时---------");
	 Date date = new Date();
	 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
	 String today = simpleDateFormat.format(date);
	 System.out.println("今天是" + today);
	 long time1 = date.getTime();
	 Calendar calendar = Calendar.getInstance();
	 calendar.set(2022, 2 - 4, 4);
	 long time2 = calendar.getTimeInMillis();
	 long day = (time2 - time1) / (1000 * 60 * 60 * 24);
	 System.out.println("距离2022年“北京-张家口”冬奥会还有" + day + "天！");
	 
	 
 	}
}

--------东奥会倒计时---------
今天是2022-05-04
距离2022年“北京-张家口”冬奥会还有-180天！