第九章总结

最新推荐文章于 2022-09-10 16:55:03 发布

是小柒吖359

最新推荐文章于 2022-09-10 16:55:03 发布

阅读量213

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_65582406/article/details/124567143

版权

9.1 包装类

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

包装类	对应基本数据类型	包装类	对应基本数据类型
Byte	byte	Short	short
Integer	int	Long	long
Float	float	Double	double
Character	char	Boolean	boolean

9.1.1 Integer类

java.lang 包中的Integer类、Byte类、Short类和Long类，分别将基本数据类型int、byte、short和long封装成一个类，由于这些类是Number的子类，区别就是封装不同的数据类型，其包含的方法基本相同。
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");

2.常用方法

方法	返回值	功能描述
valueOf(String str)	Integer	返回保存指定的 String 值的 Integer 对象
parseInt(String str)	int	返回包含在由str指定的字符事中的数字的等价整数
toString()	String	返回一个表示该Integer 值的 String 对象(可以指定进制基数)
toBinaryString(int i)	String	以二进制无符号整数形式返回一个整数参数的字符串表示形式
toHexString(int i)	String	以十六进制无符号整数形式返回一个整数参数的字符串表示形式
toOctalString(int i)	String	以八进制无符号整数形式返回一个整数参数的字符串表示形式
equals(Object IntegerObj)	boolean	比较此对象与指定的对象是否相等
intValue()	int	以int 型返回此 Integer 对象
shortValue()	short	以short 型返回此 Integer 对象
byteValue()	byte	以byte 类型返回此Integer的值
compareTo(Intergeranother Interger)	int	在数字上比较两个Integer 对象。如果这两个值相等，则返回0:如果调用对象的数值小于anotherlnteger的数值，则返回负值:如果调用对象的数值大于anotherInteger的数值，则返回正值

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

代码

public class Demo {//创建Demo主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		int num = Integer.parseInt("456");// 将字符串转换为 int类型
		Integer iNum = Integer.valueOf("456"); //通过构造函数创建一个Integer对象
		System.out.println("int数据与Integer对象的比较:"+ iNum.equals (num));
		String str2 = Integer.toBinaryString(num); // 获取数字的二进制表示 Double 类 
		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);//输出结果
		
	}
}

结果

3.常量
Integer类提供了以下4个常量:
MAX_VALUE:表示int类型可取的最大值
MIN_VALUE:表示int类型可取的最小值
SIZE:用来以二进制补码形式表示int值的位数。
TYPE:表示基本类型int的Class实例。

例9.2在项目中创建类GetCon，在主方法中实现将Integer类的常量值输出。

代码

public class GetCon_2 {//创建GetCon_2主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		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 对象。

例如，以 String 型变量作为参数创建 Double 对象，代码如下:

Double number = new Double("3.14");

2.常用方法

方法	返回值	功能描述
valueOf(String str)	Double	返回保存用参数字符串str表示的double值的Double对象
parseDouble(String s)	double	返回一个新的double值，该值被初始化为用指定String表示的值，这与Double类的valueOf方法一样。
doubleValue()	double	以double形式返回此Double对象
isNaN()	boolean	如果此double值是非数字（NaN）值，则返回true；否则返回false
intValue()	int	以int形式返回double值
byteValue()	byte	以byte形式返回Double对象值（通过强制转换）
longValue()	long	以long形式返回此double的值（通过强制转换为long类型）
cmpareTo(Double d)	int
equals(Object obj)	boolean
toString()	String
toHexString(double d)	String	返回double参数的十六进制字符串表示形式

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

代码

public class useDouble_3 {//创建useDouble_3主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		Double dNum = Double.valueOf("3.14");//通过构造函数创建一个Double对象
		System.out.println("3.14是否为非数字值:" + Double.isNaN(dNum.doubleValue()));//判断是否为非数字值
		System.out.println("3.14转换为int值为:" + Double.isNaN(dNum.doubleValue()));//转换为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.常用方法

方法	返回值	功能描述
booleanValue()	boolean	将Boolean对象的值以对应的boolean值返回
equals(Object obj)	boolean	判断调用该方法的对象与obj是否相等。当且仅当参数表示null，而且与调用该方法的对象一样都表示同一个boolean值的Boolean对象时，才返回true
parseBoolean(String s)	boolean	将字符串参数解析为boolean值
toString()	String	返回表示该boolean值的String对象
valueOf(String s)	boolean	返回一个用指定的字符串表示的boolean值

例9.4 在项目中创建类GetBoolean，在主方法中以不同的构造方法创建Boolean对象，并调用booleanValue()方法将创建的对象重新装换为boolean数据输出。

代码

public class GetBoolean_4 { //创建类GetBoolean 

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		Boolean b1 = new Boolean(true); //创建Boolean对象 
		Boolean b2 = new Boolean("ok"); //创建Boolean 对象 
		System.out.println("bl: " + b1.booleanValue());//输出结果
		System.out.println("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类提供了很多方法来完成对字符的操作

方法	返回值	功能描述
compareTo(Character anotherCharacter)	int	根据数字比较两个 Character 对象，若这两个对象相等则返回0
equals(Object obj)	Boolean	将调用该方法的对象与指定的对象相比较
toUpperCase(char ch)	char	将字符参数转换为大写
toLowerCase(char ch)	char	将字符参数转换为小写
toString()	String	返回一个表示指定char值的String对象
charValuc()	char	返回此Character对象的值
isUpperCase(char ch)	boolean	判断指定字符是否是大写字符
isLowerCase(char ch)	boolean	判断指定字符是否是小写字符
isLetter(char ch)	boolean	判断指定字符是否为字母
isDigit(char ch)	boolean	判断指定字符是否为数字

例9.5例在项目中创建类 UpperOrLower，在主方法中创建 Character 类的对象，通过判断字符的大小写状态确认将其转换为大写还是小写。

代码

public class UpperOrLower_5 {//创建UpperOrLower_5

	public static void main(String[] args) { //主方法 
		// TODO Auto-generated method stub
		Character mycharl = new Character('A'); // 声明 Character 对象 
		Character mychar2 = new Character('a'); // 声明Character 对象 
		if (Character.isUpperCase(mycharl)) { // 判断是否为大写字母 
			System.out.println(mycharl+"是大写字母");//输出结果
			System.out.println("转换为小写字母的结果:"+Character.toLowerCase(mycharl));//转换为小写
}
		if (Character.isLowerCase(mychar2)) { //判断是否为小写字母 
			System.out.println(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方法返回浮点值，这些方法如表 9.6 所示。

方法	返回值	功能描述
byteValue()	byte	以byte形式返回指定的数值
intValue()	int	以int形式返回指定的数值
floatValue()	float	以float形式返回指定的数值
shortValue()	short	以short形式返回指定的数值
doubleValue()	long	以long形式返回指定的数值
longValue()	double	以 double 形式返回指定的数值

9.2 Math类

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

9.2.1 Math 类概述

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

Math.数学方法

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

Math.PI //表示圆周丰PI的值 
Math.E //表示自然对数底数e的值

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

System.out.println("圆周率x的值为:"+ Math.PI);
System.out.printIn("自然对数底数e的值为:”+ Math.E);

上面代码的输出结果为:
圆周半x的值为:3.141592653589793
自然对数底数e的值为:2718281828459045

9.2.2 常用数学运算方法

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

1.三角函数方法

方法	返回值	功能描述
sin(double a)	double	返回角的三角正弦
cos(double a)	double	返回角的三角余弦
tan(double a)	double	返回角的三角正切
asin(double a)	double	返回一个值的反正弦
acos(double a)	double	返回一个值的反余弦
atan(double a)	double	返回一个值的反正切
toRadians(double angdeg)	double	将角度转换为弧度
toDegrees(double angrad)	double	将弧度转换为角度

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

例9.6在项目中创建TrigonometricFunction类，在类的主方法中调用Math类提供的各种三角函数运算方法，并输出运算结果。

代码

public class TrigonometricFunction_6 {//创建主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		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("n/2的角度值:"+ Math.toDegrees(Math.PI / 2)); //取n/2 的角度
	}
}

结果

2.指数函数方法

方法	返回值	功能描述
exp(double a)	double	用于获取e的a次方
double log(double a)	double	用于取自然对数，即取lna的值
double log10(double a)	double	用于取底数为10的对数
sqrt(double a)	double	用于取a的平方根，其中a的值不能为负值
cbrt(double a)	double	用于取a的立方根
poe(double a,double b)	double	用于取a的b次方

例9.7 在项目中创建ExponentFunction类，在类的主方法中调用Math类中的方法实现指数函数的运算，并输出结果。

代码

public class ExponentFunction_7 {//创建ExponentFunction_7主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		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.取整函数方法

方法	返回值	功能描述
ceil(double a)	double	返回大于等于参数的最小整数
fiool(double a)	double	返回小于等于参数的最大值
rint(double a)	double	返回与参数最接近的整数，如果两个同为整数且同样接近，则结果取偶数
round(float a)	double	将参数加上0.5后返回参数最近的整数
roud(double a)	double	将参数加上0.5后返回参数最近的整数，然后强制装换为长整型

例9.8 在项目中创建IntFunction类，在类中的方法实现取整函数的运算，并输出结果。

代码

public class IntFunction_8 {//创建主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		System.out.println("使用cei1()方法取整:"+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.去最大值、最小值、绝对值函数方法

方法	返回值	功能描述
max(double a,double b)	double	取a与b之间的最大值
min(int a,int b)	int	取a与b之间的最小值，参数为整型
min(long a,long b)	long	取a与b之间的最小值，参数为长整型
min(float a,float b)	float	取a与b之间的最小值，参数为浮点型
min(double a,double b)	double	取a与b之间的最小值，参数为双精度型
abs(int a)	int	返回整型参数的绝对值
abs(long a)	long	返回长整型参数的绝对值
abs(float a)	float	返回浮点型参数的绝对值
abs(double a)	doubloe	返回双精度型参数的绝对值

例9.9在项目中创建AnyFunction类，在类的主方法中调用Math类中的方法实现求两数的最大值、最小值和绝对值运算，并输出结果。

代码

public class AnyFunction_9 {//创建主类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		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 随机数

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

9.3.1 Math.random()

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

例9.10 使用Math.random()方法实现一个简单的猜数字小游戏，要求:使用 Math.random()方法生成一个 0~100 之间的随机数字，然后用户输入猜测的数字，判断输入的数字是否与随机生成的数字匹配，如果不匹配，提示相应的信息，如果匹配，则表示猜中，游戏结束。

代码

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("太大，请重新输入：");//sc“太大，请重新输入：”
		    iGuess = in.nextInt();//赋值
		   }
		  }
		  if (iGuess == -1)// 若最后一次输入的数字是-1，循环结束的原因是用户选择退出游戏
		  {
		   System.out.println("退出游戏！");//输出“退出游戏！”
		  } else// 若最后一次输入的数字不是-1，用户猜对数字，获得成功，游戏结束
		  {
		   System.out.println("恭喜你，你赢了，猜中的数字是：" + iNum);//输出结果
		  }
		  System.out.println("\n———————游戏结束———————");//输出———————游戏结束———————
		 }
	}

结果

除了随机生成数字以外，使用Math类的random()方法还可以随机生成字符，例如，可以使用下面代码生成a~z之间的字符:

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

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

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

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

例9.11 在项目中创建MathRandomChar 类，在类中编写 GetRandomCharO方法生成随机字符，并在主方法中输出该字符。

代码

public class MathRandomChar_11 {//创建主类

	public static char GetRandomChar(char chal, char cha2) {//定义获取任意字符之间的随机字符
		return (char) (chal + Math.random() * (cha2 - chal+ 1));//使用Math类的Random()方法
	}
	public static void main(String[] args) {//获取 a~z 之间的随机字符
		System.out.println("任意小写字符"+ GetRandomChar('a','z'));//获取A~z之间的随机字符
		System.out.println("任意大写字符"+ GetRandomChar('A','Z'));//获取0~9之间的随机字符
		System.out.println("0到9任意数字字符"+ GetRandomChar('0','9'));//输出结果
		}
}

结果

9.3.2 Random类

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

Random r = new Random();

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

语法如下:

Random r*new Random(seedValue);

r:Random类对象。
seedValuc:随机数生成器的种子。

方法	返回值	功能描述
nextInt()	int	返回一个随机整数
nextInt(int n)	int	返回大于等于0小于n的随机整数
nextLong()	long	返回一个随机长整型值
nextBoolean()	boolean	返回一个随机布尔型值
nextFloat	float	返回一个随机浮点型值
nextDouble	double	返回一个随机双精度型值
nextGaussian	double	返回一个概率密度为高斯分布的双精度值

例9.12

代码

import java.util.Random;//导入需要用的方法
import java.util.Scanner;//导入
public class RedBags_10 {//创建一个RedBags类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		System.out.println("————模拟微信抢红包————\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 
		for (int i = 1; i < bagsnum; i++) { // 设置“循环”
		/*
		*通过公式模拟数学中的离散模型计算一个红包可以放的最大金额
		*本次红包可用最大金额 = 可分配金额 - (红包总数 - 已发出的红包数) * 红包的最小金额*
		*/
		double max= total-(bagsnum-i) *min;//定义max的值
		
		double bound = max - min;// 设置随机金额的取值范围
		/*
		*据随机金额的取值范围，随机生成红包金额。
		*由于nextInt(int bound)只能用整型做参数，所以先将bound乘100(小数点向右挪两位）
		*获取到一个整数后，将这个整数除100(小数点向左挪两位)并转换成与金额相同的浮点类
		*/
		double safe = (double) random.nextInt((int) (bound *100)) / 100;//定义safe的值
		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 类的对象，其构造方法及说明如表 9.12 所示。

构造方法	功能描述
Date	分配 Date 对象并初始化此对象，以表示分配它的时间(精确到毫秒)
Date(long date)	分配Date对象并初始化此对象，以表示自从标准基准时间(即1970年1月1日00:00:00GMT)以来的指定毫秒数
Date(int year, int month, int date)	已过时
Date(int year, int month, int date,hrs, int min)	已过时
Date(int year, int month, int date, int hrs, int min, int sec)	已过时
Date(String s)	已过时

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

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

方法	返回值	功能描述
after(Date when)	boolean	测试当前日期是否在指定的日期之后
before(Date when)	boolean	测试当前日期是否在指定的日期之前
getTime()	long	获得自1970年1月1日00:00:00GMT开始到现在所表示的毫秒数
setTime(long time)	void	设置当前Date对象所表示的日期时间值，该值用以表示1970年1月1日00:00:00GMT 以后time 毫秒的时间点

例9.13 在项目中创建类，使用Date类的getTime方法获取自1970年1月1日00:00:00GMT开始到现在所表示的毫秒数，并输出。

代码

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);//输出结果
		System.out.println("到现在所经历的毫秒数为: " + value);//输出结果
		}
	}

结果

DateFormat类是日期/时间格式化子类的抽象类，它位于java.text 包中，可以按照指定的格式对日期或时间进行格式化。DateFormat提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期/时间Formatter，格式化风格包括SHORT、MEDIUM、LONG和FULL等4种，分别如下:
SHORT:完全为数字，如 12.13.52或3:30pm。
MEDIUM:较长，如 Jan 12,1952。
YLONG:更长，如 January 12,1952 或 3:30:32pm。
FULL:完全指定，如 Tuesday、April 12、1952AD或3:30:42pm PST。
另外，使用DateFormat还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态工厂方法 getDateInstance进行创建。语法如下:

DateFormat df = DateFormat.getDateInstance();

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

方法	返回值	功能描述
format(Date date)	String	将一个Date格式化为日期/时间字符串
getCalendar()	Calendar	获取于此日期/时间格式器关联的日历
getDateInstance()	static DateFormat	获取日期格式器，该格式器具有默认语言的默认格式分格
getDateTimeInstance()	static DateFormat	获取日期/时间格式器，该格式器具有默认语言的默认格式分格
getInstance()	static DateFormat	获取为日期和时间使用SHORT风格的默认日期/时间格式器
getTimeInstance()	static DateFormat	获取时间格式器，该格式器具有默认语言的默认格式分格
parse(String source)	Date	将字符串解析成一个日期，并返回这个日期的Date对象

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

代码

import java.text.DateFormat;//导入
import java.text.SimpleDateFormat;//导入 
import java.util.Date; //导入
import java.util.Locale;//导入
public class DateFormatTest_14 {//创建主类
	
	public static void main(String[] args) {//主方法
			Date date = new Date();//创建日期
			//创建不同的日期格式
			DateFormat df1 = DateFormat.getInstance();//创建df1日期格式
			DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE");//创建df2日期格式
			DateFormat df3 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒EE", Locale.CHINA);//创建df3日期格式
			DateFormat df4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE", Locale.US);//创建df4日期格式
			DateFormat df5 = new SimpleDateFormat("yyyy-MM-dd");//创建df5日期格式
			DateFormat df6 = new SimpleDateFormat("yyyy年MM月dd日");//创建df6日期格式
			// 将日期时间按照不同的格式进行输出
			System.out.println("————将日期时间按照不同的格式进行输出————");//输出结果
			System.out.println("按照Java默认的日期格式: " + df1.format(date));//输出结果
			System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss，系统默认区域:" + df2.format(date));//输出结果
			System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒，区域为中文 : " + df3.format(date));//输出结果
			System.out.println("按照指定格式yyyy-MM-dd hh:mm:ss,区域为美国: " + df4.format(date));//输出结果
			System.out.println("按照指定格式 yyyy-MM-dd: " + df5.format(date));//输出结果
			System.out.println("按照指定格式yyyy年MM月dd日: " + df6.format(date));//输出结果
		}
	}

结果

9.4.2 Calendar类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、 HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期)提供了一些方法，另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方注被定义为protected。
Calendar 提供了一个类方法getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstand方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化。使用方法如下:

Calendar rightNow = Calendar.getInstance();

字段名	说明
DATE	get和set的字段数字，指示一个月中的某天
DAY_of_MONTH	get和set的字段数字，指示一个月中的某天
DAY_of_WEEK	get和set的字段数字，指示一个星期中的某天
DAY_of_WEEK_IN_MONTH	get和set的字段数字，指示当前月中的第几个星期
DAY_of_YEAR	get和set的字段数字，指示当前年中的天数
HOUR	get和set的字段数字，指示上午或下午的小时
HOUR_OF_DAY	get和set的字段数字，指示一天中的小时
MILLISECOND	get和set的字段数字，指示一秒中的毫秒
MINUTE	get和set的字段数字，指示一小时中的分钟
MONTH	指示月份的get和set的字段数字
SECOND	get和set的字段数字，指示一分钟的秒数
time	日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间1970年1月1日0:00:00后经过的时间
WEEK_OF_MONTH	get和set的字段数字，指示当前月中的星期数
WEEK_OF_YEAR	get和set的字段数字，指示当前年中的星期数
YEAR	指示年的get和set的字段数字

方法	返回值	功能描述
add(int field,int amount)	void	根据日历的规则，为给定的日历字段添加或减去指定的时间量
after(Object when)	boolean	判断此Calendar表示的时间是否在指定Object表示的时间之后，返回判断结果
before(Object when)	boolean	判断此 Calendar表示的时间是否在指定Object表示的时间之前，返回判断结果
get(int field)	int	返回给定日历字段的值
getInstance()	static Calendar	使用默认时区和语言环境获得一个日历
getTime()	Date	返回一个表示此Calendar时间值（从历元至现在的毫秒偏移量)的Date 对象
getTimeInMillis()	long	返回此 Calendar 的时间值，以毫秒为单位
roll(int field, boolean up)	abstract void	在给定的时间字段上添加或减去(上/下)单个时间单元，不更改更大的字段
set(int field, int value)	void	将给定的日历字段设置为给定值
set(int year, int month, int date)	void	设置日历字段 YEAR、MONTH 和DAY_OF_MONTH 的值
set(int year, int month, int date, int hourOfDay, int minute)	void	设置日历字段YEAR、MONTH、DAY_OF_MONTH、HOUR_ OF_DAY 和MINUTE 的值
set(int year, int month, int date. int hourOfDay, int minute, int second)	void	设置字段YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE和 SECOND 的值
setTime(Date date)	void	使用给定的 Date 设置此 Calendar 的时间
setTimeInMillis(longmillis)	void	用给定的long 值设置此Calendar 的当前时间值

例9.15 创建一个Java程序，在其中通过使用Calendar类的相关方法输出2022年“北京-张家口”冬奥会的倒计时。

代码

import java.text.SimpleDateFormat; //导入函数需要用的包
import java.util.Calendar; //导入函数需要用的包
import java.util.Date;//导入函数需要用的包
public class OlympicWinterGames_15 {//创建0lympicWinterGames类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		System.out.println("————————冬奥会倒计时————————"); //输出“————————冬奥会倒计时————————”
		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中的年、月、日的值。因为月份从0开始计算的，所这里要减1
		long time2 = calendar.getTimeInMillis();//计算自1970年1月1日00:00:00至2022年2月4日所经过的毫秒数
		long day = (time2 - time1) / (1000 * 60 * 60 * 24);//计算2022年2月4日距离当前时间相差的天数
		System.out.println("距离2022年“北京—张家口”冬奥会还有“ + day+ ” 天!");//输出结果
		}
}

结果