第十一章(常用类库)

Java 是一种面向对象语言，Java 中的类把方法与数据连接在一起，构成了自包含式的处理单元。为了提升Java 程序的开发效率，Java 的类包中提供了很多常用类以方便开发人员使用。正所谓，术业有专攻，在常用类中主要包含可以将基本数据类型封装起来的包装类、解决常见数学问题的 Math 类、成随机数的 Random类，以及处理日期时间的相关类等。

一.包装类

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

1.Integer类

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

例1：Integer类的常用方法


public class IntegerDemo {

	public static void main(String[] args) {//将字符串转换为int类型
		int num = Integer.parseInt("456");//创建一个Integer对象
		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);//获取数字的十五进制表示
		System.out.println("456的二进制表示为：" + str2);
		System.out.println("456的十六进制表示为：" + str3);
		System.out.println("456的八进制表示为：" + str4);
		System.out.println("456的十五进制表示为：" + str5);
	}

}

结果如下

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

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

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

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

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

例2：查看Integer类的常量值

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

结果如下

2.Double类

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

例3：Dounle类的常用方法

public class DoubleDemo {

	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.14d1十六进制表示为：" + Double.toHexString(dNum));
	}

}

结果如下

Double类主要提供了以下常量:

1. MAX_EXPONENT:返回int 值，表示有限double 变量可能具有的最大指数

2. MIN_EXPONENT:返回 int 值，表示标准化 double 变量可能具有的最小指数。

3. NEGATIVE_INFINITY:返回 double 值，表示保存 double 类型的负无穷大值的常量。

4. POSITIVE_INFINITY:返回double 值，表示保存double 类型的正无穷大值的常量。

3.Boolean类

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

例4：Boolean类的常用方法

public class BooleanDemo {

	public static void main(String[] args) {
		Boolean b1 = Boolean.valueOf("true");//创建Boolean对象
		Boolean b2 = Boolean.valueOf("ok");
		System.out.println("b1:" + b1.booleanValue());
		System.out.println("b2:" + b2.booleanValue());
	}

}

结果如下

Boolean 提供了以下3个常量:

1. TRUE:对应基值 true的 Boolean 对象。

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

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

4.Character类

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

例5：Character类的常用方法

public class UpperOrLower {

	public static void main(String[] args) {
		Character mychar1 = Character.valueOf('A');
		Character mychar2 = Character.valueOf('a');
		if(Character.isUpperCase(mychar1)) {//判断是否为大写字母
			System.out.println(mychar1 + "是大写字母");
			//转换为小写并输出
			System.out.println("转换为小写字母的结果：" + Character.toLowerCase(mychar1));
			}
		if(Character.isLowerCase(mychar2)) {//判断是否为小写字母
			System.out.println(mychar2 + "是小写字母");
			//转换为大写并输出
			System.out.println("转换为大写字母的结果：" + Character.toUpperCase(mychar2));
			}
	}
}

结果如下

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

1. CONNECTOR_PUNCTUATION:返回 byte 型值，表示Unicode 规范中的常规类别“Pc”

2. UNASSIGNED:返回 byte 型值，表示Unicode 规范中的常规类别“Cn”。

3. TITLECASE_LETTER:返回 byte 型值，表示Unicode 规范中的常规类别“Lt”。

5.Number类

前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类-Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byteint、short、long、float 和 double 的方法。例如，doubleValue()方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如表：

二.数字处理

在 Java 语言中，提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数方法。除此之外还提供了一些常用的数学常量，如PI、E等。本节将讲解 Math 类以及其中的一些常用方法。
在实际开发中，随机数的使用是很普遍的，所以要掌握生成随机数的操作。在Java 中主要提供了两种生成随机数的方式，分别为调用 Math 类的random0方法生成随机数和调用 Random类生成各种据类型的随机数。
在Java中，还提供了大数字的操作类，即javamath.BigInteger类与javamath.BigDecimal类。这两个类用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal类则是针对大小数的处理类。

1.数字格式化

数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 foat 型数据。在 Java 中使用 java.textDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。
在Java 中，没有格式化的数据遵循以下原则:
1. 如果数据绝对值大于0.001 并且小于10000000，使以常规小数形式表示
2. 如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Java中，可以使用DecimalFormat类进行格式化操作
DecimalForat类是NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一般情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中的applyPatten0方法来实现数字格式化。
当格式化数字时，可在 DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照-定的特殊字符规则进行匹配。表中列举了格式化模板中的特殊字符及其所代表的含义。

例6：DecimalFormat类的常用方法

import java.text.DecimalFormat;
public class DecimalFormatSimpleDemo{
	static public void SimgleFormat(String pattern,double value) {
		DecimalFormat myFormat = new DecimalFormat(pattern);//实例化DecimalMformat对象
		String output = myFormat.format(value);//将数字进行格式化
		System.out.println(value +""+ pattern +""+ output);
	}
	static public void UseApplyPatternMethodFormat(String pattern,double value) {
		DecimalFormat myFormat = new DecimalFormat();//实例化DecimalFormat对象
		myFormat.applyPattern(pattern);//调用applyPattern()方法设置格式化模板
		System.out.println(value +""+ pattern +""+ myFormat.format(value));
	}

	public static void main(String[] args) {
		SimgleFormat("###,###.###",123456.789);//调用静态SimgleFormat()方法
		SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位
		//按照格式模板格式化数字，不存在的位以0显示
		SimgleFormat("000000.000",123.78);
		//调用静态UseApplyPatternMethodFormat()方法
		UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式
		UseApplyPatternMethodFormat("###.##",123456.789);//将小数点后格式化为两位
		UseApplyPatternMethodFormat("0.00\u2030",0.789);//将数字转换为千分数形式
	}

}

结果如下

在本实例中可以看到，代码的第一行使用import 关键字将javatext.DecimalFormat 这个类导入，这是告知系统下面的代码将使用到 DecimalFormat类。然后定义了两个格式化数字的方法，这两个方法参数都为两个，分别代表数字格式化模板和具体需要格式化的数字。虽然这两个方法都可以实现数字的格式化，但采用的方式有所不同，SimgleFormat()方法是在实例化 DecimalFormat对象时设置数字格式化模板，而UseApplyPattemMethodFormat()方法是在实例化 DecimalFormat 对象后调用applyPattern()方法设置数字格式化模板。最后，在主方法中根据不同形式模板格式化数字。在结果中可以看到以“0特殊字符构成的模板进行格式化时，当数字某位不存在时，将显示0:而以“#”特殊字符构成的模板进行格式化操作时，格式化后的数字位数与数字本身的位数一致。
在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字进行格式化设置。例如：

DecimalFormat myFormat = new DecimalFormat();//实例化DecimalFormat类对象

myFormat.setGroupingSize(2);//设置将数字分组的大小

myFormat.setGroupingUsed(false);//设置是否支持分组

在上述代码中，setGroupingSize()方法设置格式化数字的分组大小，setGroupingUsed()方法

设置是否可以对数字进行分组操作。

2.Math类

Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用：

Math.数学方法

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

Math.PI

Math.E

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

1.三角函数方法

Math 类中包含的三角函数方法如下:

1. public static double sin(double a): 返回角的三角正弦。

2. public static double cos(double a): 返回角的三角余弦。

3. public static double tan(double a): 返回角的三角正切。

4. public static double asin(double a):返回一个值的反正弦。

5. public static double acos(double a): 返回一个值的反余弦。

6. public static double atan(double a):返回一个值的反正切。

7. public static double toRadians(double angdeg): 将角度转换为弧度。

8. public static double toDegrees(double angrad):将狐度转换为角度。

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

例7：在java代码中进行三角函数运算

public class TrigonometricFunction {

	public static void main(String[] args) {
		System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90°的正弦
		System.out.println("o度的余弦值："+Math.cos(0));//取0°的余弦
		System.out.println("60度的正切值："+Math.tan(Math.PI/3));//取60°的正切
		//取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的反正切
		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°，也就是获取的 Mathsqrt(2)/2 反正弦、反余弦值与1的反正切值都是 45°。最后两行打印语句实现的是角度和弧度的转换，其中 Math.toRadians(120.0)语句是获取 120°的弧度值，而 MadtoDegrees(Math.PI/2)语句是获取 π/2 的角度值。读者可以将这些具体的值使用的形式表示出来,与上述结果应该是基本一致的，这些结果不能做到十分精确，因为π本身也是一个近似值。

2.指数函数方法

Math 类中与指数相关的函数方法如下：

1. public static double exp(double a):用于获取e的a次方。

2. public static double log(double a):用于取自然对数，即取Ina的值。

3. public static double log10(double a):用于取底数为10 的a的对数。

4. public static double sqrt(double a): 用于取a的平方根，其中a 的值不能为负值。

5. public static double cbrt(doublea):用于取a的立方根。

6. public static double pow(double a,double b): 用于取a的b 次方。

例8：在java代码中进行指数函数运算

public class ExponentFunction {

	public static void main(String[] args) {
		System.out.println("e的平方根："+Math.exp(2));//取e的2次方
		System.out.println("以e为底2的对数值："+Math.log(2));//取以为底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类中主要包括以下几种取整方法:

1. public static double ceil(double a): 返回大于等于参数的最小整数。

2. public static double floor(double a):返回小于等于参数的最大整数。

3. public static double rint(double a): 返回与参数最接近的整数，如果存在两个同样接近的整数V则结果取偶数。

4. public staticintround(float a):将参数加上0.5后返回与参数最近的整数。

5. public static longround(double a): 将参数加上0.5 后返与参数最近的整数，然后强制转换为长整型。

例9：各场景下取整函数的运算结果

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

	}

}

结果如下

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

在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下:

1. public static double max(double adouble b): 取a与b之间的最大值。

2. public static int min(int aint b): 取a与b之间的最小值，参数为整型。

3. public static long min(long a,long b): 取a与b之间的最小值，参数为长整型。

4. public static float min(float a,floatb):取a与b之间的最小值，参数为单精度浮点型

5. public static double min(double a,double b):取a与b之间的最小值，参数为双精度浮点型。

6. public static intabs(int a):返回整参数的绝对值。

7. public static longabs(long a):返回长整型参数的绝对值。

8. public static float abs(float a): 返回单精度浮点型参数的绝对值。

9. public static double abs(double a): 返回双精度浮点型参数的绝对值。

例10：取最大值、最小值、绝对值的方法

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));//取参数的绝对值

	}

}

结果如下

3.Random类

Random 类是JDK 中的随机数生成器类，可以通过实例化一个 Radom 对象创建一个随机数生器，语法如下：

Random r = new Random();

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

用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下：

Random r = new Random(seedValue);

1. r: Random类对象。

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

在Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：

1. public intnextInt():返回一个随机整数。

2. public int nextInt(int n): 返回大于等于0且小于n的随机整数。

3. public long nextLong0: 返回一个随机长整型值。

4. public boolean nextBoolean0: 返回一个随机布尔型值。

5. public float nextFloat0:返回一个随机单精度浮点型值。

6. 日 public doublenextDouble0:返回一个随机双精度浮点型值。

7. public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值。

例11：获取不同取值范围、不同类型的随机数

import java.util.Random; 
public class RandomDemo {

	public static void main(String[] args) {
		Random r = new Random();//实例化一个Random类
		//随机产生一个整数
		System.out.println("随机产生一个整数："+r.nextInt());
		//随机产生一个大于等于0且小于10的整数
		System.out.println("随机产生一个大于0小于10的整数："+r.nextInt(10));
		//随机产生一个布尔型的值
		System.out.println("随机产生一个布尔型的值："+r.nextBoolean());
		//随机产生一个双精度浮点型的值
		System.out.println("随机产生一个双精度浮点型的值："+r.nextDouble());
		//随机产生一个单精度浮点型的值
		System.out.println("随机产生一个单精度浮点型的值："+r.nextFloat());
		//随机产生一个概略密度为高斯分布的双精度浮点型的值
		System.out.println("随机产生一个概略密度为高斯分布的双精度浮点型的值："+r.nextGaussian());

	}

}

结果如下

4.BigInteger类

Biginteger 类的数字范围较 Integer 类的数字范围要大得多。前文介绍过 Integer 类是 int 的包装类int 的最大值为 23-1，如果要计算更大的数字，使用 nteer 类就无法实现了，所以 Java 中提供]BigInteger 类来处理更大的数字。Biginteger 类支持任意精度的整数，也就是说，在运算中 BigIntege类可以准确地表示任何大小的整数值而不会丢失信息。

在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数最大公约数以及判断是否为质数等操作。

使用 BigInteger类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。

例如，将2转换为 BigInteger 类型，可以使用以下语句进行初始化操作:

BigInteger twolnstance = new BigInteger("2");

一旦创建了对象实例，就可以调用 Bielncger 类中的一些方法进行运算操作，包括基本的数学这算和位运算以及一些取相反数、取绝对值等操作。列举了 BigInteger 类中常用的几种运算方法:

1. public BigInteger add(BigInteger val): 做加法运算。

2. public BigInteger subtract(BigInteger val): 做减法运算。

3. public BigInteger multiply(BigInteger val): 做乘法运算。

4. public BigInteger divide(BigInteger val): 做除法运算。

5. public BigInteger remainder(BigInteger val): 做取余操作。

6. public BigInteger divideAndRemainder(Biplntegcr val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。

7. public BigInteger pow(intexponent): 进行取参数的exponent 次方操作。

8. public BigInteger negate0: 取相反数。

9. public BigInteger shifLeft(intn):将数字左移n位，如果n为负数，做右移操作。

10. public BigInteger shiftRight(intn):将数字右移n位，如果n为负数，做左移操作。

11. public BigInteger and(BigInteger val): 做与操作。

12. 口 public BigInteger or(BigInteger val):做或操作。

13. publicintcompareTo(BigInteger val):做数字比较操作。

14. public boolean equals(Object x):当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。

15. public BigInteger min(BigInteger val):返回较小的数值。

16. public BigInteger max(BigIntegerval):返回较大的数值。

例12：使用BigInteger类进行数学运算

import java.math.BigInteger;
public class BiglntegerDemo {

	public static void main(String[] args) {
		BigInteger b1 = new BigInteger("987654321987654321");//第1个大数字
		BigInteger b2 = new BigInteger("123456789123456789");//第2个大数字
		System.out.println("加法操作："+b1.add(b2));//加法运算
		System.out.println("减法操作："+b1.subtract(b2));//减法运算
		System.out.println("乘法操作："+b1.multiply(b2));//乘法运算
		System.out.println("除法操作："+b1.divide(b2));//除法运算
		System.out.println("取商："+b1.divideAndRemainder(b2)[0]);//取商运算
		System.out.println("取余数："+b1.divideAndRemainder(b2)[1]);//取余运算
		System.out.println("做2次方操作："+b1.pow(2));//2次方运算
		System.out.println("取相反数操作："+b1.negate());//相反数运算
	}

}

结果如下

5.BigDecimal类

BigDecimal类和BigInteger类都能实现大数字的运算，不同的是 BigDecimal类加入了小数的概念般的foat 型和 double 型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。在BigDecimal类中，常用的两个构造方法如表:

BigDecimal类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal类实现的加、减、乘、除的方法下表：

在上述方法中，BigDecimal类中divide()方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义下表：

例13：使用BigDecimal类进行数学运算

import java.math.BigDecimal;

import java.math.RoundingMode;

public class BigDecimalDemo {

	public static void main(String[] args) {
		BigDecimal b1 = new BigDecimal("0.00987654321987654321");//第1个大小数
		BigDecimal b2 = new BigDecimal("0.00123456789123456789");//第2个大小数
		System.out.println("两个数字相加结果："+b1.add(b2));//加法运算
		System.out.println("两个数字相减结果："+b1.subtract(b2));//减法运算
		System.out.println("两个数字相乘结果："+b1.multiply(b2));//乘法运算
		//除法运算，商小数点后保留9位，并将结果进行四舍五入操作
		System.out.println("两个数字相除,保留小数点后9位："+b1.divide(b2,9,RoundingMode.HALF_UP));//
	}

}

结果如下

本章总结示例代码：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.Random;
public class MathTest {
	public static void main(String[] args) {
		//数字处理
		//数字格式化
		DecimalFormat myFormat1 = new DecimalFormat();
		myFormat1.applyPattern("###,###,###");
		String my1 = myFormat1.format(7857478);
		System.out.println(my1);
		
		DecimalFormat myFormat2 = new DecimalFormat();
		myFormat2.setGroupingSize(2);
		myFormat2.setGroupingUsed(true);
		String my2 = myFormat2.format(7857478);
		System.out.println(my2);
		
		//Math类
		//三角函数
		System.out.println(Math.toRadians(45));
		double a = Math.tan(Math.toRadians(45));
		System.out.println(a);
		System.out.println(Math.tan(Math.toRadians(45)));
		//指数函数
		System.out.println(Math.cbrt(64));
		System.out.println(Math.pow(3, 5));
		//取整函数
		System.out.println(Math.ceil(3.1));
		System.out.println(Math.floor(3.9));
		System.out.println(Math.rint(3.51));
		System.out.println(Math.rint(3.49));
		System.out.println(Math.rint(3.5));
		System.out.println(Math.rint(2.5));
		//最大、最小值、绝对值函数
		System.out.println(Math.max(3.5, 4.6));
		System.out.println(Math.min(7, 9));
		System.out.println(Math.abs(9));
		System.out.println(Math.abs(-3.25));
		//Random类
		Random r = new Random();
		System.out.println(r.nextInt());
		System.out.println(r.nextInt(100));
		System.out.println(r.nextDouble());
		
		//BigInteger类
		BigInteger b1 = new BigInteger("7463742232");
		BigInteger b2 = new BigInteger("38729749923293");
		BigInteger m1 = b1.multiply(b2);
		System.out.println(m1);
		
		//BigDecimal类
		BigDecimal a1 = new BigDecimal("923469.462462");
		BigDecimal a2 = new BigDecimal("8228642.47248");
		BigDecimal n1 = a1.multiply(a2);
		System.out.println(n1);
	}
}

三.System类

System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。System类提供了很多系统层面的操作方法，并且这些方法全部但是静态的。

1.控制台输出字符

System 类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3 个静态对象:in、out 和 err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。在控制台输出字符事，验出的方法有两种：

1.不会自动换行的print()方法

print()方法语法如下：

System.out.print("Hello!");

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。

2.可以自动换行的println()方法

printin0方法在print后面加上了“In”后缀(就是 line的简写)，语法如下：

System.out.println("书籍是人类进步的阶梯!");

此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。

Print()方法和println()方法输出的对比效果下表：

综上所述，java输出换行的方法有以下两种：

System.out.print("\n");//利用换行符\n实现换行

System.out.println();//空参数即可实现操作

2.计时

System.currentTimeMillis()方法可以获取1970年1月1日零点至今的毫秒数。虽然 Date日期也有类似的方法，但代码会比System 类多，所以System.currentTimeMillis()方法是为获取当前毫秒梦最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

例14：查看执行一万次字符串拼接所消耗的时间

package System;

public class SystemTimeDemo {

	public static void main(String[] args) {
		long start = System.currentTimeMillis();//程序开始记录时间
		String str = null;//创建null字符串
		for(int i = 0;i < 10000;i++) {//循环10000次
			str += i;//字符串与循环变量拼接
		}
		long end = System.currentTimeMillis();//记录循环结束时间
		System.out.println("循环用时：" + (end - start) + "毫秒");
	}
}

结果如下

四.Scanner类

与C语言不同，Java从控制台中读出用户输入的值，用到的不是一行可以直接使用的代码，而是由一个叫Scanner的类来实现的。Scanner英文直译就是扫描仪，它的用途就和现实生活中的扫描仪一样，可以把数字化信息流为人类可识别的文字。控制台输出内容用到了System.out就表示向控制台输出，System.in就表示从控制台输入，让Scanner扫描System.in就可以获取用户输入的值了。

使用Scanner类首先要引入该类，其语法如下：

import java.util.Scanner;//引入Scanner类

Scanner类提供了下表中的几种常用的方法，通过这些方法可以获取控制台输入的不同类型的值。

使用Scanner类扫描控制台的代码如下：

Scanner sc = new Scanner(System.in);

例15：猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class ScannerDemo {

	public static void main(String[] args) {
		Random r = new Random();//随机数对象
		int num = r.nextInt(100);//从1~99取值
		int input = -1;//记录用户输入的值
		Scanner sc = new Scanner(System.in);//扫描器扫描控制台输入
		while(true) {
			System.out.println("猜一猜随机数是多少？");
			input = sc.nextInt();//获取用户输入的一个整数
			if(input > num) {//如果大于随机数
				System.out.println("你输入的数字大了！");
			}else if(input < num) {//如果小于随机数
				System.out.println("你输入的数字小了");
			}else if(input == num) {//如果等于随机数
				break;
			}else {
				System.out.println("您的输入有误！");
			}
		}
		System.out.println("恭喜你答对了！");
		sc.close();//关闭扫描器
	}

}

结果如下

五.日期时间类

1.Date类

Date类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如下图：

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

long timeMillis = System.currentTimeMillis();//当前系统时间所经历的毫秒数

Date date = new Date(timeMillis);

上述代码中的System类的currentTimeMillis()方法主要用于获取当前系统时间距标准时间的毫秒数。另外，这里需要注意的是，创建Date类对象时使用的是long型整数，而不是double型，这主要是因为double类型可能会损失精度。Date类的常用方法及其说明，图如下：

例16：获取当前的日期和时间

import java.util.Date;
public class DateDemo {

 public static void main(String[] args) {
  Date date = new Date();     //创建现在的日期
  long value = date.getTime(); //获取毫秒数
  System.out.println("日期："+date);//输出
  System.out.println("到现在所经历的毫秒数为："+value);

 }

}

结果如下

2.日期时间格式化

DateFormat类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化，DateFormat类提供了很多类方法，以获得基于默认或给定语环境和多种格式化风格的默认日期时间formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：

1.SHORT: 完全为数字，如11.13.42或3:30pm。

2.MEDIUM: 较长，如Jan 12,1343。

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

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

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

DateFormat df = Dateformat.getDateInstance();

使用getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimelnstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明下表：

例如，将当前日期按照 DateFormat 类默认格式输出：

DateFormat df = DateFormat.getlnstance();

System.out.println(df.format(new Date());

结果如下：

2021/2/19 上午9:59

输入长类型格式的当前时间：

DateFormat df = DateFormat.getTimelnstance(DateFormat.LONG);

System.out.printin(df.format(new Date();

结果如下：

CST 上午10:00:33

输出长类型格式的当前日期:

DateFormat df = DateFormat.getDatelnstance(DateFormat.LONG);

System.out.println(df.format(new Date())):

结果如下：

2021年2月19日

输出长类型格式的当前日期和时间:

DateFormat df = DateFormatgetDate Timelnstance(DateFormat.LONG,DateFormat.LONG);

System.out.println(df.format(new Date()));

结果如下：

2021年2月19日CST上午10:01:12

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

SimpleDateFormat类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符下表：

通常表中的字符出现的数量会影响数字的格式。例如，yyyy 表示4 位年份，这样输入会显示202l:yy 表示两位，这样输入就会显示为 21; 只有一个y的话，会按照 yyyy 显示:如果超过4个一些常用的日期时间格式如表中所示。y，如yyyyyy，会在4位年份左侧补0，结果为02021。一些常用的日期时间格式下表：

例17：以中文形式打印当前的日期和时间

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo {

	public static void main(String[] args) {
		DateFormat df = new SimpleDateFormat("yyy年MM月dd日EEEEE HH时mm分ss秒");
		System.out.print("各位观众大家好，现在是");
		System.out.print(df.format(new Date()));
		System.out.println(", 欢迎收看新闻。");
	}

}

结果如下

DateFormat 类提供的Date parse(String source)方法可以将字符串转为其字面日期对应的 Date对象，整个过程相当于日期格式化的逆操作。

例如，将“2021-02-19”这个字符串转成Date对象，可以使用如下代码:

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

Date date = sdf.parse("2021-02-19");

3.Calendar类

打开JavaAPI 文档可以看到 iava.utilDate 类提供的大部分方法都已经过时了，因为 Date类在设计之初没有考虑到国际化，而且很多方法也不能满足用户需求，比如需要获取指定时间的年月日时分和信息，或者想要对日期时间进行加减运算等复杂的操作，Date 类已经不能胜任，因此JDK 提供了新的时间处理类--Calendar日历类。

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

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

Calendar rightNow = Calendar.getinstance();

Calendar 类提供的常用字段及其说明下表：

Calendar类提供的常用方法及其说明下表：

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

例18：具体离中华人民共和国成立100周年差多少天

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class CountDown {

	public static void main(String[] args) {
		System.out.println("——————————————中华人民共和国成立100周年倒计时——————————————");
		Date date = new Date();//当前时间
		//创建SimpleDateFormat对象，指定目标格式
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy年MM月dd日");
		//创建format方法，格式化时间，转换为指定格式
		String today = simpleDateFormat.format(date);
		System.out.println("今天是"+today);//输出当前日期
		//获取自1970年1月1日至当前时间所经过的毫秒数
		long time1 = date.getTime();
		//使用默认时区和语言环境得一个日历calendar
		Calendar calendar = Calendar.getInstance();
		//设置日历calendar中的年、月和日的值。因为月份是从0开始计算的，所以这里要减一
		calendar.set(2049,10-1,1);
		//计算自1970年1月1日至2049年10月1日所经过的毫秒数
		long time2 = calendar.getTimeInMillis();
		//计算2049年10月1日距离当前时间的天数
		long day = (time2 - time1)/(1000*60*60*24);
		System.out.println("距离2049年10月1日还有"+day+"天！");

	}

}

结果如下

最后对 Calendar 类的使用做出几点总结:

1. c.set(Calendar.DAY OF_MONTHO)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。

2. Calenda.rMONTH 的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。

3. Calendar.DAY_OF_WEEK 的第一天是周日，周一是第二天，周六是最后一天。

本章总结示例代码:

import java.text.DateFormat;
import java.util.Date;
import java.text.SimpleDateFormat;
public class DateTast {

	public static void main(String[] args) {
		//日期时间类
		//Date类
		Date d1 = new Date();
		System.out.println((d1));
		System.out.println(System.currentTimeMillis());
		Date d2 = new Date(1664732264079L);
		System.out.println(d2);
		
		
		System.out.println(d1.after(d2));
		System.out.println(d1.before(d2));
		System.out.println(d1.getTime());
		d1.setTime(2364732263079L);
		System.out.println(d1.getTime());
		
		//日期时间格式化
		DateFormat df1 = DateFormat.getInstance();
		System.out.println(df1.format(d1));
		DateFormat df2 = DateFormat.getDateInstance();
		System.out.println(df2.format(d1));
		DateFormat df3 = DateFormat.getTimeInstance();
		System.out.println(df3.format(d1));
		
		DateFormat df4 = new SimpleDateFormat("yyyy年MM月dd日 EEEE HH时mm分ss秒");
		System.out.println(df4.format(d1));
	}  
}

六.Runtime类

Runtime类是JDK提供的运行时类，该类为Java程序提供了与当前运行环境相连接的一个通道,Java程序可以利用该类对当前的运行环境执行一些简单的操作。Runtime 类不能使用 new 关键字创建实例，只能通过 Runtime.getRuntime()方法获取实例。

Runtime类的常用方法下表：

1.执行本地命令

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示shell命令，在 Windows 系统下表示 cmd 命令。

Runtime类提供exec0方法让Java 代码可以执行系统的命令，exec0方法有很多重载的形式，例如：

Process exec(String command)

Process exec(Stringl cmdarray)

1. command:要执行的系统命令，字符串类型。

2. cmdarray:要执行的命令和相应的命令参数，字符串数组类型。

其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下：

Runtime.getRuntime().exec("javac hello.java");

使用第二种重载方式的代码如下:

String command] = { "javac", "hello.java" };

Runtime.getRuntime().exec(command);

exec()方法会返回一个 Process 对象。Process 类是 Java中进程类，该类是抽象类，不能使用关键字创建实例。Process类的常用方法下表所示，开发可以使用 getinputStream()方法获取返回的信息。

例19：让java程序执行Windows系统的help命令

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class RuntimeExecDemo {
	public static void main(String[] args) {
		Runtime r = Runtime.getRuntime();//获取本地Runtime对象
		try {
			Process p = r.exec("help");//执行help命令，获取进程对象
			InputStream is = p.getInputStream();//获取进程的字节输入流
			//将字节输入流转换为字符输入流
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String str = null;//创建null字符串
			while((str = br.readLine())!= null) {//如果字符流中可以获取非空内容
				System.out.println(str);//打印获取的内容
			}
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
}

结果如下

2.查看内存

Runtime 类可以通过 freeMemory()方法查看当前Java 虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。

例20:监控虚拟机内存使用情况

public class MemoryDemo {
	public static void main(String[] args) {
		Runtime r = Runtime.getRuntime();//获取本地Rumtime对象
		Integer ints[] = new Integer[10000];//创建长度为10000的整型数组
		long before = r.freeMemory();//获取当前空闲内存数
		System.out.println("赋值前空闲内存字节数：" + before);
		for(int i = 0,length=ints.length; i <length; i++) {//循环为整型数组赋值
			ints[i] = i;//赋值
		}
		long after = r.freeMemory();//获取当前空闲内存数
		System.out.println("赋值后空闲内存字节数：" + after);
		System.out.println("数组用掉的内存字节数：" + (before - after));//输出数组用掉的内存数
	}
}

结果如下

s1133333

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十一章(常用类库)

Java 是一种面向对象语言，Java 中的类把方法与数据连接在一起，构成了自包含式的处理单元。为了提升Java 程序的开发效率，Java 的类包中提供了很多常用类以方便开发人员使用。正所谓，术业有专攻，在常用类中主要包含可以将基本数据类型封装起来的包装类、解决常见数学问题的 Math 类、成随机数的 Random类，以及处理日期时间的相关类等。
复制链接

扫一扫