第九章 Java常用类

为了方便 Java 程序的开发，Java 的类包中提供了一些常用类供开发人员使用，比如将基本数据类型封装起来的包装类、解决常见数学问题的 Math 类、生成随机数的 Random 类，以及处理日期时间的相关类，本章将对这些 Java 中常用的类进行讲解。
通过阅读本章，您可以:
掌握 Integer 对象的创建以及Integer类提供的各种方法
掌握 Double 对象的创建以及 Double 类提供的各种方法

掌握Boolean 对象的创建以及Boolean类提供的各种方法

掌握 Character 对象的创建以及 Character 类提供的各种方法

了解所有数字类的父类 Number
掌握Math类中的各种数学运算方法
掌握如何在程序中生成任意范围内的随机数

熟悉日期时间类的使用方法

Java 是一种面向对象的语言，但在Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如in型数值的包装类Integer，boolean 型的包装类Boolean 等，这样便可以把这些基本数据类型转换为对象进行处理。Java 中的包装类及其对应的基本数据类型如表所示。

说明：Java是可以直接处理基本数据类型的，但在有些情况下需要将其作为对象来处理，这时就需要将其转换为包装类了，这里的包装类相当于基本数据类型与对象类型之间的一个桥梁。由于包装类和基本数据类型间的转换引入了装箱和拆箱的概念:装箱就是将基本数据类型转换为包装类，而拆箱就是将包装类转换为基本数据类型，这里只需要简单了解这两个概念即可。

9.1.1 Integer 类

java.lang 包中的 Integer 类、Byte类、Short 类和Long类，分别将基本数据类型int、byte、short 和long 封装成一个类，由于这些类都是Number 的子类，区别就是封装不同的数据类型，其包含的方法基本相同，所以本节以 Integer 类为例介绍数包类。
Integer类在对象中包装了一个基本数据类型 int 的值，该类的对象包含一个int类型的字段，此外，该类提供了多个方法，能在int 类型和String类型之间互相转换，同时还提供了其他一些处理 int类型时非常有用的常量和方法。

1.构造方法
Integer 类有以下两种构造方法。 (1)Integer (int number)
该方法以一个 int 型变量作为参数来获取 Integer 对象。
例如，以 int 型变量作为参数创建 Integer 对象，代码如下:

Integer number = new Integer(7);

(2)Integer(String str)
该方法以一个 String型变量作为参数来获取Integer 对象。
例如，以 String型变量作为参数创建Integer对象，代码如下

Integer number = new Integer("45");

注意:
如果要使用字符串变量创建 Integer 对象，字符串变量的值一定要是数值型的，如"123"，否则将会抛出 NumberFormatException 异常

2、常用方法 Integer 类的常用方法如表所示：

下面通过一个实例演示Integer 类的常用方法的使用：创建一个 Demo 类，其中首先使用 Integer 类的 parseInt 方法将一个字符串转换为 int 数据;然后创建一个 Integer 对象，并调用其 equa ls 方法与转换的 int 数据进行比较;最后演示使用 Integer 类的 toBinaryString 方法toHexString 方法去、toOctalString方法和toString方法将int数据转换为二进制、十六进制、八进制和不常使用的十五 i进制表示形式。

代码9_1

public class H9_1 {//创建类
	public static void main(String[] args) {//主函数
		int num = Integer.parseInt("456");// 将字符串转换为int类型
		Integer iNum = Integer.valueOf("456");// 通过构造函数创建一个Integer对象
		System.out.println("int数据与Integer对象的比较：" + iNum.equals(num));//输出"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);//输出"456的二进制表示为：" + str2
		System.out.println("456的十六进制表示为：" + str3);//输出456的十六进制表示为：" + str3
		System.out.println("456的八进制表示为：" + str4);//输出"456的八进制表示为：" + str4
		System.out.println("456的十五进制表示为：" + str5);//输出"456的十五进制表示为：" + str5
		System.out.println("圆周率π的值为：" + Math.PI);//输出"圆周率π的值为：" + Math.PI
		System.out.println("自然对数底数e的值为：" + Math.E);//输出"自然对数底数e的值为：" + Math.E
	}
}

结果

3.常量
Integer类提供了以下 4个常量:
MAX_VALUE:表示int类型可取的最大值,即2(31)-1

MIN_VALUE:表示int类型可取的最小值，即-2(31)。、

SIZE:用来以二进制补码形式表示 int 值的位数。

TYPE:表示基本类型 int 的 Class 实例。

代码9_2


public class H9_2 {//创建类
	public static void main(String args[]) { // 主方法
		int maxint = Integer.MAX_VALUE; // 获取Integer类的常量值
		int minint = Integer.MIN_VALUE;// 获取Integer类的常量值
		int intsize = Integer.SIZE;// 获取Integer类的常量值
		System.out.println("int类型可取的最大值是：" + maxint); //输出"int类型可取的最大值是：" + maxint
		System.out.println("int类型可取的最小值是：" + minint);//输出"int类型可取的最小值是：" + minint
		System.out.println("int类型的二进制位数是：" + intsize);//输出"int类型的二进制位数是：" + intsize
	}
}

结果

9.1.2 Double 类

Double 类和 Float 类是对double、float 基本类型的封装，它们都是 Number 类的子类，都是小数进行操作，所以常用方法基本相同，本节将对 Double 类进行介绍。对于Float 类可以参考Double类的相关介绍。
Double 类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个 double类型的字段。此外，该类还提供多个方法，可以将 double 转换为 String，将 String 转换为 double,也提供了其他一些处理 double 时有用的常量和方法。

1.构造方法
Double 类提供了以下两种构造方法来获得 Double 类对象。 (1)Double(double value)
基于 double 参数创建 Double 类对象。
例如，以 double 型变量作为参数创建 Double 对象，代码如下: Double number = new Double(3.14);(2)Double(String str)
该方法以一个 String型变量作为参数来获取 Double 对象。
例如，以 String型变量作为参数创建Double对象，代码如下: Double number=new Double("3.14");

2、常用方法

Double 类的常用方法如表所示：

下面通过一个实例演示Double类的常用方法的使用：创建一个useDouble 类，其中首先使用 Double 类的 valueOf 方法创建一个 Double 对象然后使用 Double类的常用方法对该对象进行操作，并查看它们的显示结果

代码9_3


public class H9_3 {//创建类
	public static void main(String[] args) {//主函数
		Double dNum = Double.valueOf("3.14"); // 通过构造函数创建一个Integer对象
		System.out.println("3.14是否为非数字值：" + Double.isNaN(dNum.doubleValue()));// 判断是否为非数字值
		System.out.println("3.14转换为int值为：" + dNum.intValue());// 转换为int类型
		System.out.println("值为3.14的Double对象与3.14的比较结果：" + dNum.equals(3.14));// 判断大小
		System.out.println("3.14的十六进制表示为：" + Double.toHexString(dNum));// 转换为十六进制
	}
}

结果

3. 常量
Double类主要提供了以下常量:
(1)MAX_EXPONENT:返回 int 值，表示有限 double 变量可能具有的最大指数。

(2)MIN EXPONENT:返回 int 值，表示标准化 double变量可能具有的最小指数。
(3)NEGATIVE INFINITY:返回 double值，表示保存double类型的负无穷大值的常量。(4)POSITIVE INFINITY:返回 double 值，表示保存 double类型的正无穷大值的常量。

9.1.3 Boolean类

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

1.构造方法
Boolean 类提供了以下两种构造方法来获得 Boolean 类对象。(1)Boolean(boolean value)
该方法创建一个表示 value 参数的 Boolean 对象。
例如，创建一个表示value 参数的Boolean 对象，代码如下: Boolean b = new Boolean(true);

(2)Boolean(String str)
该方法以 String变量作为参数创建 Boolean对象。如果String参数不为null且在忽略大小写时等于true，则分配一个表示true 值的Boolean 对象，否则获得一个false 值的Boolean 对象。
例如，以 String变量作为参数，创建 Boolean 对象。代码如下:

Boolean bool = new Boolean("ok");

2、常用方法

Boolean类的常用方法如表所示：

代码9_4


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

结果

3. 常量
Boolean 提供了以下3个常量:
(1)TRUE:对应基值true的Boolean 对象。

(2)FALSE:对应基值 false 的 Boolean 对象。

(3)TYPE:基本类型 boolean 的 Class 对象。

9.1.4 Character 类

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。

1.构造方法
Character类的构造方法语法如下:

Character(char value)
该类的构造方法的参数必须是一个char 类型的数据。通过该构造方法将一个char 类型数据包装成一个Character 类对象。一旦 Character 类被创建，它包含的数值就不能改变了。
例如，以char 型变量作为参数，创建 Character 对象。代码如下:

Character mychar = new Character('s');

2、常用方法

character 类的常用方法如表所示：

代码9_5

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

结果

3.常量
Character 类提供了大量表示特定字符的常量，例如:
(1)CONNECTOR_PUNCTUATION:返回 byte 型值，表示Unicode规范中的常规类别“Pc”。
(2)UNASSIGNED:返回 byte 型值，表示 Unicode 规范中的常规类别“Cn”。
(3)TITLECASE LETTER:返回byte型值，表示Unicode规范中的常规类别“Lt”。

9.1.5 Number 类

前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类--Number类，该类是一个抽象类，它是Byte、Integer、Short、Long、Float和Double类的父类，其子类必须提供将表示的数值转换为byte、int、short、long、float和double的方法。例如，doubleValue(方法返回双精度值，floatValueO方法返回浮点值，这些方法如表所示。
Number 类的方法分别被 Number 的各子类所实现，也就是说，在 Number 类的所有子类中都包含以上这几种方法。

9.2 Math 类

前面的章节我们学习过+、-、*、1%够基本的算术运算符，使用它们可以进行基长的。算，但是，如果我们碰到一些复杂的数学运算，该怎么办呢?Java 中提供了一个执行数学服，的Math 类该类包括常用的数学运算方法，如三角函数方法、指数函数方法、对数函数方根函数方法护一她常用数学雨数，除此之外还提供了一些常用的数学常量，如P、E解。介绍 Math 类以及其中的一些常用方法。

9.2.1 Math 类概述

Math类表示数学类，它位于java.lang 包中，由系统默认调用，该类中提供了众多数学函数法，主包三角函数方法，指数函数方法，取整数方法，取最大值、最小值以及绝对值函数方法，这些方法都被定义为static形式，因此在程中可以直接通过类名进行调用。使用形式如： Math.数学方法在Math 类中除了函数方法之外还存在一些常用的数学常量,如PI、E等，这些数学常量作为Math 类的成员变量出现，调用起来也很简单。可以使用如下形式调用:
Math.PI //表示圆周率 PI的值
Math.E //表示自然对数底数e的值
例如，下面代码用来分别输出PI和E的值。代码如下: System.out.printIn("圆周率n的值为:"+ Math.PI);
System.out.println("自然对数底数e的值为:"+ Math.E); 上面代码的输出结果为:
圆周率π的值为:3.141592653589793
自然对数底数e的值为:2.718281828459045

9.2.2常用数学运算方法

Math 类中的常用数学运算方法较多，大致可以有将其分为4大类别，分别为三角函数方法，指数函数方法，取整函数方法以及取最大值、最小值和绝色对值函数方法，下面分别进行介绍。

1.三角函数方法
Math 类中包含的三角函数方法如表所示。

以上每个方法的参数和返回值都是 double 型的，将这些方法的参数的值设置为double 型是有定道理的，参数以弧度代替角度来实现，其中1°等180弧度，所以180°可以使用元弧度表示。除了可以获取角的正弦、余弦、正切、反正弦、反余弦、反正切之外，Math 类还提供了角度狐度相互转换的方法toRadians和toDegrees但需要注意的是，角度与弧度的转换通常是不精确的。

代码9_6


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

结果

通过运行结果可以看出，90°的正弦值为1，0°的余弦值为 1，60°的正切与 Math.sqrt(3)的值应该是一致的，也就是取3的平方根。在结果中可以看到第 4~6 行的值是基本相同的，这个值换算后正是45°，也就是获取的Math.sqrt(2)/2 反正弦、反余弦值与1的反正切值都是 45°。最后两行丁印语句实现的是角度和弧度的转换，其中ahoadas1)语句是获取120°的弧度值，而 th.toDegrees(Math.PI/2)语句是获取π/2的角度。读者可以将这些具体的值使用的形式表示出来，与上述结果应该是基本一致的，这些结果不能做到十分精确，因为π本身也是一个近似值。

2、指数函数方法

Math类中与指数相关的函数方法如表所示：

代码9_7


public class H9_7 {//创建类
	public static void main(String[] args) {//主函数
		System.out.println("e的平方值：" + Math.exp(2)); // 取e的2次方
		// 取以e为底2的对数
		System.out.println("以e为底2的对数值：" + Math.log(2));
		// 取以10为底2的对数
		System.out.println("以10为底2的对数值：" + Math.log10(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的2次方
	}
}

结果

3、取整函数方法
在具体的问题中，取整操作使用也很普遍，所以 Java在Math了数字方法。Math类中常用的取整方法如表所示。

下面以1.5作为参数，演示使用取整方法后的返回值，在坐标轴上表示如图所示：

注意:
由于数10和数20距离数1.5都是0.5个单位长度，因此 Math.rint 返回偶数 2.0。

代码9_8


public class H9_8 {//创建类
	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));
		// 将参数加上0.5后返回最接近的整数
		System.out.println("使用round()方法取整：" + Math.round(3.4f));
		// 将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
		System.out.println("使用round()方法取整：" + Math.round(2.5));
	}
}

结果

4.取最大值、最小值、绝对值函数方法
Math 操法，比如取最大值值、最小值、绝对值等，它们的说明如表所示。

代码9_9

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

结果

9.3 随机数

在实际开发中生成随机数的使用是很普遍的，所以在程序中生成随机数的操作很重要。在 Java主要提供了两种方式生成随机数，分别为调用 Math类的random方法和Random 类提供的生成各种数据类型随机数的方法，下面分别进行讲解。

9.3.1 Math.random()方法

在Math类中存在一个random()方法，用于生成随机数字，该方法默认生成大于等于 0.0小于 1.0 double 型随机数，即 0<=Math.randomO<1.0，虽然Math.randomO方法只可以生成 0~1之间的 double型数字，但只要在Math.random()语句上稍加处理，就可以使用这个方法生成任意范围的随机数，如图所示。

代码9_10

	/**
	 * 猜数字游戏
	 */
import java.util.Scanner;//导入java.util.Scanner包
public class H9_10 {//创建类
		public static void main(String[] args) {//主函数
			System.out.println("——————猜数字游戏——————\n");//输出——————猜数字游戏——————\n
			int iNum;
			int iGuess;
			Scanner in = new Scanner(System.in);// 创建扫描器对象，用于输入
			iNum = (int) (Math.random() * 100);// 生成1到100之间的随机数
			System.out.print("请输入你猜的数字：");
			iGuess = in.nextInt(); // 输入首次猜测的数字
			while ((iGuess != -1) && (iGuess != iNum))// 判断输入的数字不是-1或者基准数
			{
				if (iGuess < iNum)// 若猜测的数字小于基准数，则提示用户输入的数太小，并让用户重新输入
				{
					System.out.print("太小，请重新输入：");//输出太小，请重新输入：
					iGuess = in.nextInt();
				} else// 若猜测的数字大于基准数，则提示用户输入的数太大，并让用户重新输入
				{
					System.out.print("太大，请重新输入：");//输出太大，请重新输入：
					iGuess = in.nextInt();//输入下一个数字
				}
			}
			if (iGuess == -1)// 若最后一次输入的数字是-1，循环结束的原因是用户选择退出游戏
			{
				System.out.println("退出游戏！");//输出退出游戏
			} else// 若最后一次输入的数字不是-1，用户猜对数字，获得成功，游戏结束
			{
				System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum);//输出"恭喜你，你赢了，猜中的数字是：" + iNum
			}
			System.out.println("\n———————游戏结束———————");//输出\n———————游戏结束———————
		}
}

结果

除了随机生成数字以外，使用Math类的random方法还可以随机生成字符，例如，可以使用下面代码生成 a~z之间的字符:
(char)('a'+Math.random()*('z'-'a'+1));
通过上述表达式可以求出更多的随机字符，如A~Z之间的随机字符，进而推理出求任意两个字符之间的随机字符，可以使用以下语句表示:
(char)(chal+Math.random()*(cha2-chal+1));
在这里可以将这个表达式设计为一个方法，参数设置为随机生成字符的上限与下限。下面举例说明。

代码9_11


public class H9_11 {//创建类
		public static char GetRandomChar(char cha1, char cha2) {	// 定义获取任意字符之间的随机字符
			return (char) (cha1 + Math.random() * (cha2 - cha1 + 1));//随机返回一个属于这个范围的字符
		}

		public static void main(String[] args) {//主函数
			System.out.println("任意小写字符" + GetRandomChar('a', 'z'));			// 获取a~z之间的随机字符
			System.out.println("任意大写字符" + GetRandomChar('A', 'Z'));			// 获取A~Z之间的随机字符
			System.out.println("0到9任意数字字符" + GetRandomChar('0', '2'));// 获取0~9之间的随机字符
		}
}

结果

9.3.2 Random类

除了Mathrndom法可以获取随机数之外，Java中还提供了一种可以获取随机的方式，那就是java.util.Random 类，该类表示一个随机数生成器，可以通过实例化一个 Random 对象创建一个随机数生成器。语法如下:

Random r=new Random();

其中，r是指 Random 对象。
以这种方式实例化对象时，Java编译器系间作为随机数生成器的种子，因为每时每刻的
时间不可能相同，所以生成的随机数将不同，但是如果运行速度太快，也会生成两次运行结果相同的随机数。

同时也可以在实例化 Random 类对象时，设置随机数生成器的种子。
语法如下:
Random r=new Random(seedValue);
r:Random 类对象。
seedValue:随机数生成器的种子。
在Random类中提供了获取各种数据类型随机数的方法，其常用方法及说明如表所示。

代码9.12

使用Random类模拟微信的抢级红包功能，具体实现时，在项目中创建 RedBags 类，然后根据用户输入的红包额度和个数随机生成我每个红包的金额。

import java.text.DecimalFormat;//导入java.text.DecimalFormat包
import java.util.Random;//导入java.util.Random包
import java.util.Scanner;//导入java.util.Scanner包
/**
 * 模拟微信抢红包功能
 */
public class H9_12 {//创建类
	public static void main(String[] args) {//主函数
		System.out.println("—————————模拟微信抢红包—————————\n"); //输出—————————模拟微信抢红包—————————\n
		Scanner sc = new Scanner(System.in); //控制台输入
		System.out.print("请输入要装入红包的总金额（元）："); //输出"请输入要装入红包的总金额（元）："
		double total = sc.nextDouble(); //输入“红包的总金额”
		System.out.print("请输入红包的个数（个）："); //输出"请输入红包的个数（个）："
		int bagsnum = sc.nextInt(); //输入“红包的个数”
		double min = 0.01; //初始化“红包的最小金额”
		Random random = new Random(); //创建随机数对象random
		DecimalFormat df = new DecimalFormat("###,###,###.##"); //创建DecimalFormat类的对象df，并设置格式
		for (int i = 1; i < bagsnum; i++) { //设置“循环”
			double safe = (total - (bagsnum - i) * min) / (bagsnum - i); //通过公式模拟数学中的离散模型
			double money = (double) random.nextInt((int) ((safe - min) * 100)) / 100 + min; //根据离散模型得到每个红包的金额
			total = total - money; //替换total的值
			String temp = df.format(money); //调用format()方法，对数字money格式化
			System.out.println("第" + i + "个红包：" + temp + "元"); //输出结果
		}
		String left = df.format(total); //调用format()方法，对数字total格式化
		System.out.println("第" + bagsnum + "个红包：" + left + "元"); //输出结果
		sc.close(); //关闭控制台输入
	}
}

结果

9.4 日期时间类

在程序开发中，经常需要处理日期时间，Java理应操作本节将对Java中日期时间类进行详细讲解。

9.4.1 Date类

Date类用于表示日期时间，它位于java.util包中，程序中使用该类表示时间时，需要使用其构造方法创建Date类的对象，如表

说明:
从表中可以看出，Date类的后4种构造方法已经显示过时，它们已经被Calendar的相应方法或者DateFormat类的相应方法取代了，后面将介绍这两个类。

例如，使用Date类种法创建个Date类的对象，代码如下:

long timeMillis=System.currentTimeMillis();

Date date=new Date(timeMillis);

上面代码中的System类curenTimeMillis（）方法主要用来获取系统当前时间距标准基准时间毫秒数，另外，这里需要注意的是，创建Date 对象时使用的是long型整数，而不是 double 型，这主要是因为 double 类型可能会损失精度。
使用Date类创建的对象表示日期和时间，它涉及最多的操作就是比较，例如两个人的生日，哪个较早，哪个又晚一些，或者两人的生日完全相等，其常用的方法如表所示。

代码9_13

import java.util.Date;//导入java.util.Date 包
public class H9_13 {//创建类
	public static void main(String[] args) {//主函数
		Date date = new Date(); 				// 创建现在的日期
		long value = date.getTime(); 			// 获得毫秒数
		System.out.println("日期：" + date);//输出"日期：" + date
		System.out.println("到现在所经历的毫秒数为： " + value);//输出"到现在所经历的毫秒数为： " + value
	}
}

结果

说明:
由于Date类所创建对象的时间是变化的，所以每次运行程序在控制台所输出的结果都是不一样的。

从例 9.13可以看到，如果在程序中直接输出 Date对象，显示的是“Mon Feb 29 17:39:50 CST2016”这种形势的日期时间，那么如何将其显示为“20016-02-29”或者“17:39:50”这样的日期时间形势呢?JavaateFormat类来实现类似的功能。
DateFormat间子类象类，java.text 包中，可以按照指定的格式对日期或时间进行格式化。DateFormat提供了多类法，以获得基于默认或给定语言环境和多种格式化风格的默认日期/时间Formatter，格式化风格包括SHORTMEDIUM、LONG和FULL等4种，分别如下:
SHORT:完全为数字，如 12.13.52或3:30pm。 MEDIUM:较长，如 Jan 12,1952。
LONG;更长，如January12,1952或3:30:32pm。
FULL:完全指定，如 Tuesday、April 12、1952AD 或 3:30:42pm PST。
另外，使用DateFormat还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建 DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态工厂方法 getDateInstance进行创建。语法如下:
DateFormat df=DateFormat.getDateInstance();
使用getDateInstance获取的是该国家/地区的标准日期格式，另外，DateFormat类还提供了一些其他静态工厂方法，例如，使用getTimeInstance可获取该国家/地区的时间格式，使用 getDateTimeInstance可获取日期和时间格式。
DateFormat 类的常用方法及说明如表所示。

由于DateFormat类是一个抽象类，不能用new创建实例对象，因此，除了使用getXXXInstance方法创建其对象外，还可以使用其子类，例如 SimpleDateFormat类，该类是一个以与语言环境相关的方式来格式化和分析日期的具体类，它允许进行格式化(日期>文本)、分析(文本>日期)和规范化。

创建一个Java类，在其中首先创建Date 类的对象;然后使用DateFormat类的 getlnstance方法和SimpleDateFormat类的构造方法创建不同的 DateFormat对象，并指定不同的日期时间格式，并对当前日期时间进行格式化，并输出。代码如下:

代码9_14

import java.text.DateFormat;//导入java.text.DateFormat包
import java.text.SimpleDateFormat;//导入java.text.SimpleDateFormat
import java.util.Date;//导入 java.util.Date
import java.util.Locale;//导入java.util.Locale
public class H9_14 {//创建类
	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");//创建一个日期格式化对象，设置格式为yyyy-MM-dd hh:mm:ss EE
		DateFormat df3 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 EE", Locale.CHINA);//创建一个日期格式化对象，设置格式为yyyy年MM月dd日 hh时mm分ss秒 EE", Locale.CHINA
		DateFormat df4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE", Locale.US);//创建一个日期格式化对象，设置格式为yyyy-MM-dd hh:mm:ss EE", Locale.US
		DateFormat df5 = new SimpleDateFormat("yyyy-MM-dd");//创建一个日期格式化对象，设置格式为yyyy-MM-dd
		DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");//创建一个日期格式化对象，设置格式为yyyy年MM月dd日
		// 将日期按照不同格式进行输出
		System.out.println("-------将日期时间按照不同格式进行输出------");//输出-------将日期时间按照不同格式进行输出------
		System.out.println("按照Java默认的日期格式: " + df1.format(date));//输出按照Java默认的日期格式: " + df1.format(date)
		System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date));//输出按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date)
		System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : " + df3.format(date));//输出按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : " + df3.format(date)
		System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，区域为美国: " + df4.format(date));//输出按照指定格式 yyyy-MM-dd hh:mm:ss，区域为美国: " + df4.format(date)
		System.out.println("按照指定格式 yyyy-MM-dd: " + df5.format(date));//输出按照指定格式 yyyy-MM-dd: " + df5.format(date)
		System.out.println("按照指定格式 yyyy年MM月dd日: " + df6.format(date));//输出按照指定格式 yyyy年MM月dd日: " + df6.format(date)
	}
}

结果

9.4.2 Calendar 类

在9.4.1节中讲解Date中的构造方法时，我们发现有好子几种方法都是过时的，这些过时的构造方法其实是被Calendar类的方法代替了，这里提到了 Calen dar 类，为什么要使用该类呢?因为Date类在设计之初没有考虑到国际化，它的很多方法都被标记为为过时状态，而且其方法不能满足用户需求，比如需要获取指定时间的年月日时分秒信息，或者想要对日期时间进行加减运算等复杂的操作， Date。Calendar类进行详细讲解。
Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY OF MONTH.
HOUR转提供一方法，并为操作日历字段(例如获得下星期的日期)提供一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected。
lendar 提供了一个类方法getInstance，获得此类型的一个通用的对象。Calendar 的 getInstance方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化。使用方法如下:

Calendar rightNow=Calendar.getInstance();

说明:
由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance方法创建其对象外，还可以使用其子类创建对象，例如 GregorianCalendar 类。
Calendar类提供的常用字段及说明如表所示。

Calendar 类提供的常用方法及说明如表所示

说明:
从上面的表格中可以看到，add方法和roll方法都用来为给定的日历字段添加或减去指定的时间量，它们的主要区别在于:使用add方法时会影响大的字段，像数学里加法的进位或错位，而使用roll方法设置的日期字段只是进行增加或减少，不会改变更大的字段。

创建一个 Java 程序，在其中通过使用 Calendar类的相关方法输出2022年“北京一张家口”冬奥会的倒计时、代码如下：

代码9_15

import java.text.SimpleDateFormat;//导入java.text.SimpleDateFormat
import java.util.Calendar;//导入java.util.Calendar
import java.util.Date;//导入java.util.Date

/**
 * 输出2022年冬奥会倒计时（暂定冬奥会举办时间为2022年2月2日）
 */
public class H9_15 {//创建类
	public static void main(String[] args) {//主函数
		System.out.println("——————————冬奥会倒计时——————————\n"); //输出——————————冬奥会倒计时——————————\n
		Date date = new Date(); //实例化Date
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); //创建SimpleDateFormat对象，制定目标格式
        String today = simpleDateFormat.format(date);// 调用format方法，格式化时间，转换为指定方法
        System.out.println("今天是" + today); //输出当前日期
        long time1 = date.getTime(); //计算“自 1970 年 1 月 1 日 00:00:00 至当前时间所经过的毫秒数
        Calendar calendar = Calendar.getInstance(); //使用默认时区和语言环境获得一个日历calendar
        calendar.set(2022, 2-1, 4); //设置日历calendar中的 YEAR、MONTH 和 DAY_OF_MONTH 的值
        long time2 = calendar.getTimeInMillis(); //计算“自 1970 年 1 月 1 日 00:00:00 至 2022 年 2 月 2 日所经过的毫秒数
        long day = (time2 - time1)/(24 * 60 * 60 * 1000); //计算2022 年 2 月 2 日距离当前时间的天数
        System.out.println("距离2022年“北京-张家口”冬奥会还有 " + day + " 天！");//输出"距离2022年“北京-张家口”冬奥会还有 " + day + " 天！"
	}
}