第九章 java常用类

9.1 包装类

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

 9.1.1  integer类

javalang包中的Integer类、Byte 类、Short类和Long类，分别将基本数据类型int. bye. 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型变量作为参数来获取Ineer对象。
例如，以Sring型变量作为参数创建Iter对象，代码如下:

Integer number = new Integer("45");

2.常用方法

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

package 第九章;     //类包
public class ss {      //创建类
	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对象比较
		  String str2 = Integer.toBinaryString(num);  //获取数字的二进制表示
		  String str3 = Integer.toHexString(num);   //获取数字的十六进制表示
		  String str4 = Integer.toOctalString(num);   //获取数字的八进制表示
		  String str5 = Integer.toString(num,5);   //获取数字的十五进制表示
		  System.out.println("456的二进制表示为:"+str2);   //输出二进制的值
		  System.out.println("456的十六进制表示为:"+str3);   //输出十六进制的值
		  System.out.println("456的八进制表示为:"+str4);   //输出八进制的值
		  System.out.println("456的十五进制表示为:"+str5);  //输出十五进制的值
		 }
		}

3.常量

nteger类提供了以下4个常量:

MAX_VALUE:表示int类型可取的最大值，即2平方31-1.

MIN_VALUE:表示int类型可取的最小值，即-2平方31

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

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

package 第九章;    //类包
public class dd {    //创建类
	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);   //将常量值输出
		  System.out.println("int类型可取的最小值是:"+minint);   //将常量值输出
		  System.out.println("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对象。
例如，以Sing型变量作为参数创建Dolo对象，代码如下:

Doble number = new Double (“3.14”);

2.常用方法

 下面通过一个实例演示double类的常用方法的使用

package 第九章;    //类包
public class dd {  //创建类
	public static void main(String[] args) {   //主方法
		  Double dNum = Double.valueOf("3.14");   //通过构造函数创建一个Double对象
		  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,类型的对象只包含一个类型为bolean的字段。此外，此类还为boolan和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.常用方法

package 第九章;   //类包
public class dd {   //创建类
	public static void main(String[] args) {   //主方法
		  Boolean b1 = new Boolean(true);   //创建Boolean1对象
		  Boolean b2 = new Boolean("ok");   //创建Boolean2对象
		  System.out.println("b1:"+b1.booleanValue());   //输出Boolean1对象结果
		  System.out.println("b2:"+b2.booleanValue());   //输出Boolean2对象结果
		 }
}

3.常量

Boolean提供了以下3个常量:

(1) TRUE: 对应基值true的Boolean对象。
(2) FALSE: 对应基值false的Boolean对象。
(3)TYPE:基本类型boolean的Class对象。

9.1.4  Character类

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

1.构造方法

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

Character (char value)

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

Character mychar = new Character('s');

2.常用方法

Characer类提供了很多方法来完成对字符的操作，常用的方法

下面通过实例开介绍Character类的大小写转换方法的使用

package 第九章;    //类包
public class dd {   //创建类
	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(mychar1+"是小写字母");  //为小写字母
	     System.out.println("转换为小写字母的结果:"+Character.toUpperCase(mychar1));   //转换为大写字母
	    }
	 }
}

3.常量

Character类提供了大量表示特定字符的常量，例如:

( 1 ) CONNECTOR PUNCTUATION: 返回byte型值，表示Unicode规范中的常规类别“Pc”。
(2) UNASSIGNED:返回byte型值，表示Unicode规范中的常规类别“Cn”。
(3) TITLECASE LETTER:返回byte型值，表示Unicode规范中的常规类别“Lt”。

9.1.5  Number类

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

9.2  Math类

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

9.2.1  Math类概述

Math类表示数学类，它位于java. ang包中，由系统默认调用，该类中提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值以及绝对值函数方法，这些方法都被定义为static 形式，因此在程序中可以直接通过类名进行调用。使用形式如下:

Math.数学方法

在Math类中除了函数方法之外还存在一些常用的数学常量， 如PI、 E等，这些数学常量作为Math类的成员变量出现，调用起来也很简单。可以使用如下形式调用:

Math. PI        //表示圆周率PI的值

Math.E         //表示自然对数底数e的值

例如，下面代码用来分别输出PI和E的值。代码如下:

System. out.println("圆周率π的值为:" + 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()。但需要注意的是，角度与弧度的转换通常是不精确的。

package 第九章;    //类包
public class dd {    //创建类  
	public static void main(String[] args) {//主方法
		  System.out.println("90度的正弦值:"+Math.sin(Math.PI/2));//取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°的正弦值为1, 0°的余弦值为1, 60°的正切与Math.sqrt(3)的值应该是一致的，也就是取3的平方根。在结果中可以看到第4~6行的值是基本相同的，这个值换算后正是45°，也就是获取的Math.sqrt(2)/2 反正弦、反余弦值与1的反正切值都是45°。最后两行打印语句实现的是角度和弧度的转换，其中Math.toRadians(120.0)语句是获取 120° 的弧度值，而Math. toDegrees(Math.PI2)语句是获取πu/2 的角度。读者可以将这些具体的值使用π的形式表示出来，与上述结果应该是基本致的， 这些结果不能做到十分精确，因为π本身也是一 个近似值。

2.指数函数方法

指数运算包括求方根、取对数以及求n次方的运算。为了使读者更好地理解这些指数函数方法的用法，下面举例说明。

package 第九章;   //类包
public class dd {    //创建类
	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的2次方
		 }
		}

3.取整函数方法

在具体的问题中，取整操作使用也很普遍，所以Java在Math类中添加了数字取整方法。Math类中常用的取整方法。

演示使用取整方法后的返回值，在坐标轴上表示

下面举例说明Math类中取整方法的使用

package tt;       //类包
public class IntFunction {   //创建类
	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后返回最接近的整数,并将结果强制转换为长整型
		 }
		}

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

Math类还有一些常用的数据操作方法，比如取最大值、最小值、绝对值等，它们的说明如表

下面举例说明上述方法的使用

package tt;      //类包
public class AnyFunction {       //创建类
	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));//取参数的绝对值
		 }
		}

9.3  随机数 

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

9.3.1 Math.random()方法

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

为了更好地解释这种生成随机数的方式，下面举例说明

package tt;    //类包
import java.util.Scanner;//导入要用到的包
public class NumGame {     //创建类
	public static void main(String[] args) {//主方法
		  System.out.println("——————猜数字游戏——————\n");//输出猜数字游戏
		  int iNum;//定义iNum
		  int iGuess;//定义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);   //输出猜中的数字
		  }
		  System.out.println("\n———————游戏结束———————");//输出游戏结束
		 }
		}

在Eclipse中运行本实例，结果如图9.12所示。
除了随机生成数字以外，使用Math类的random0方法还可以随机生成字符，例如，可以使用下面代码生成a~z之间的字符:

(char) ('a'+Math. random()*('z'-'a'+1)) ;

通过上述表达式可以求出更多的随机字符，如A~Z之间的随机字符，进而推理出求任意两个字符之间的随机字符，可以使用以下语句
表示:

(char) (chal +Math. random() * (cha2-cha1+1)) ;

在这里可以将这个表达式设计为一个方法，参数设置为随机生成字符的上限与下限。下面举例说明。

package tt;      //类包
public class MathRandomChar {    //创建类
	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', '9'));// 获取0~9之间的随机字符
		 }
		}

9.3.2  Randon类

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

Random r=new Random() ;

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

语法如下:

Random r=newRandom (seedValue);

r: Random类对象。

seedValue:: 随机数生成器的种子。

在Random类中提供了获取各科数据类型随机数的方法，其常用方法及说明

package tt;   //类包
import java.util.Random;//导入要用到的包
import java.util.Scanner;//导入要用到的包
public class RedBags {    //创建类
	public static void main(String[] args) {//主方法
		  System.out.println("————模拟微信抢红包————"); //输入————模拟微信抢红包————
		    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 
		     for (int i=1;i<bagsnum;i++){//设置“循环”
		     /*
		     *通过公式模拟数学中的离散模型计算一个红包可以放的最大金额
		     *本次红包可用最大金额=可分配金额-(红包总数-已发出的红包数)*红包的最小金额
		     */
		     double max=total-(bagsnum-i)*min;
		      double bound=max-min;// 设置随机金额的取值范围 
		     /*
		      * 据随机金额的取值范围，随机生成红包金额。
		      * 由于nextInt(int bound)只能用整型做参数，所以先将bound乘100(小数点向右挪两位
		     *获取到一个整数后，将这个整数除100(小数点向左挪两位)并转换成与金额相同的浮点类型
		      */
		     double safe=(double)random.nextInt((int)(bound*100))/100;
		     double money=safe+min;//最后加上红包的最小金额，以防safe出现0值
		     total=total- money;//替换total的值
		     System.out.println("第" + i + "个红包:" + String.format("%.2f",money) + "元");//输出结果
		       }
		       System.out.println("第" + bagsnum + "个红包:" + String.format("%.2f", total)+ "元");//输出结果
		       sc.close();// 关闭控制台输入
		  }
}

9.4  日期时间类 

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

9.4.1  Date类

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

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

long timeMillis = System. currentTimeMillis() ;
Date date=new Date (timeMillis) ;

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

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

从例9.13可以看到，如果在程序中直接输出Date对象，显示的是“Mon Feb 29 17:39:50 CST2016”这种形势的日期时间，那么如何将其显示为“2016-02-29” 或者“17:39:50”这样的日期时间形势呢? Java中提供了DteFormat 类来实现类似的功能。
DateFomat类是日期/时间格式化子类的抽象类，它位于java.tet 包中，可以按照指定的格式对日期或时间进行格式化。DateFomat 提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Fomaterer格式化风格包括SHORT、MEDIUM、LONG和FULlL等4种，分别如下:

SHORT: 完全为数字，如12.13.52或3:30pm。

MEDIUM: 较长，如Jan 12, 1952。

LONG: 更长，如January 12, 1952或3:30:32pm。

FULL: 完全指定，如Tuesday、 April 12、 1952 AD或3:30:42pm PST.

另外，使用DateFormat还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态工厂方法getDateInstance进行创建。语法如下:

DateFormat df = DateFormat .getDateInstance() ;

使用getDateInstance获取的是该国家/地区的标准日期格式，另外，DateFormat类还提供了一些其他静态工厂方法，例如，使用getTimeInstance 可获取该国家/地区的时间格式，使用getDateTimeInstance可获取日期和时间格式。

DateFormat类的常用方法及说明

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

package tt;    //类包
import java.text.DateFormat;//导入用到的包
import java.text.SimpleDateFormat;//导入用到的包
import java.util.Date;//导入用到的包
import java.util.Locale;//导入用到的包
public class DateFormatTest {       //创建类
	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默认的日期格式
		  System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date));//输出yyyy-MM-dd hh:mm:ss格式
		  System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : " + df3.format(date));//输出yyyy年MM月dd日 hh时mm分ss秒格式
		  System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，区域为美国: " + df4.format(date));//输出yyyy-MM-dd hh:mm:ss格式
		  System.out.println("按照指定格式 yyyy-MM-dd: " + df5.format(date));//输出yyyy-MM-dd 格式
		  System.out.println("按照指定格式 yyyy年MM月dd日: " + df6.format(date));//输出yyyy年MM月dd日 格式
		 }
}

9.4.2  Calendar类

在9.4.1节中讲解Date中的构造方法时，我们发现有好几种方法都是过时的，这些过时的构造方法其实是被Calendar类的方法代替了，这里提到了Calendar 类，为什么要使用该类呢?因为Date类在设计之初没有考虑到国际化，它的很多方法都被标记为过时状态，而且其方法不能满足用户需求，比如需要获取指定时间的年月日时分秒信息，或者想要对日期时间进行加减运算等复杂的操作，Date类已经不能胜任。下 面对Calendar类进行详细讲解。

Calendar类是一个抽象类， 它为特 定瞬间与一组诸如YEAR、MONTH、DAY _OF MONTH、HOUR等日历字段之间的转换提供了一.些方法，并为操作日历字段(例如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为protected。

Calendar提供了一个类方法getInstance,以获得此类型的一个通用的对象。Calendar 的getInstance方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化。使用方法如下:

Calendar rightNow = Calendar. getInstance() ;

Calendar类提供的常用字段及说明

package tt;    //类包
import java.text.SimpleDateFormat;//导入要用到的包
import java.util.Calendar;//导入要用到的包
import java.util.Date;//导入要用到的包
public class OlympicWinterGames {      //创建类
	public static void main(String[] args) {//主方法
		  System.out.println("——————————冬奥会倒计时——————————\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年“北京-张家口”冬奥会还有多少天
		 }
}

 9.5  小结

本章主要讲解了Java 中常用类的使用方法，包括封装基本数据类型的包装类、Math 数学运算类、Random随机数类、Date 类以及Calendar 类，在实际开发中，这些类经常会用到，希望通过本章的学习，读者能够熟练掌握Java中常用类的使用方法，并能够在实际开发中灵活应用。